75943fcbffa88cf3125f7fb5729293e826dcfb63ac7cf15097d5124a31d2cf67

langchain_md_files/integrations/providers/outline.mdx

@@ -0,0 +1,22 @@
+# Outline
+
+> [Outline](https://www.getoutline.com/) is an open-source collaborative knowledge base platform designed for team information sharing.
+
+## Setup
+
+You first need to [create an api key](https://www.getoutline.com/developers#section/Authentication) for your Outline instance. Then you need to set the following environment variables:
+
+```python
+import os
+
+os.environ["OUTLINE_API_KEY"] = "xxx"
+os.environ["OUTLINE_INSTANCE_URL"] = "https://app.getoutline.com"
+```
+
+## Retriever
+
+See a [usage example](/docs/integrations/retrievers/outline).
+
+```python
+from langchain.retrievers import OutlineRetriever
+```

langchain_md_files/integrations/providers/pandas.mdx

@@ -0,0 +1,29 @@
+# Pandas
+
+>[pandas](https://pandas.pydata.org) is a fast, powerful, flexible and easy to use open source data analysis and manipulation tool,
+built on top of the `Python` programming language.
+
+## Installation and Setup
+
+Install the `pandas` package using `pip`:
+
+```bash
+pip install pandas
+```
+
+
+## Document loader
+
+See a [usage example](/docs/integrations/document_loaders/pandas_dataframe).
+
+```python
+from langchain_community.document_loaders import DataFrameLoader
+```
+
+## Toolkit
+
+See a [usage example](/docs/integrations/tools/pandas).
+
+```python
+from langchain_experimental.agents.agent_toolkits import create_pandas_dataframe_agent
+```

langchain_md_files/integrations/providers/perplexity.mdx

@@ -0,0 +1,25 @@
+# Perplexity
+
+>[Perplexity](https://www.perplexity.ai/pro) is the most powerful way to search 
+> the internet with unlimited Pro Search, upgraded AI models, unlimited file upload, 
+> image generation, and API credits.
+>
+> You can check a [list of available models](https://docs.perplexity.ai/docs/model-cards).
+
+## Installation and Setup
+
+Install a Python package:
+
+```bash
+pip install openai
+````
+
+Get your API key from [here](https://docs.perplexity.ai/docs/getting-started).
+
+## Chat models
+
+See a [usage example](/docs/integrations/chat/perplexity).
+
+```python
+from langchain_community.chat_models import ChatPerplexity
+```

langchain_md_files/integrations/providers/petals.mdx

@@ -0,0 +1,17 @@
+# Petals
+
+This page covers how to use the Petals ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific Petals wrappers.
+
+## Installation and Setup
+- Install with `pip install petals`
+- Get a Hugging Face api key and set it as an environment variable (`HUGGINGFACE_API_KEY`)
+
+## Wrappers
+
+### LLM
+
+There exists an Petals LLM wrapper, which you can access with 
+```python
+from langchain_community.llms import Petals
+```

langchain_md_files/integrations/providers/pg_embedding.mdx

@@ -0,0 +1,22 @@
+# Postgres Embedding
+
+> [pg_embedding](https://github.com/neondatabase/pg_embedding) is an open-source package for
+> vector similarity search using `Postgres` and the `Hierarchical Navigable Small Worlds`
+> algorithm for approximate nearest neighbor search.
+
+## Installation and Setup
+
+We need to install several python packages.
+
+```bash
+pip install psycopg2-binary
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/pgembedding).
+
+```python
+from langchain_community.vectorstores import PGEmbedding
+```
+

langchain_md_files/integrations/providers/pgvector.mdx

@@ -0,0 +1,29 @@
+# PGVector
+
+This page covers how to use the Postgres [PGVector](https://github.com/pgvector/pgvector) ecosystem within LangChain
+It is broken into two parts: installation and setup, and then references to specific PGVector wrappers.
+
+## Installation
+- Install the Python package with `pip install pgvector`
+
+
+## Setup
+1. The first step is to create a database with the `pgvector` extension installed.
+
+    Follow the steps at [PGVector Installation Steps](https://github.com/pgvector/pgvector#installation) to install the database and the extension. The docker image is the easiest way to get started.
+
+## Wrappers
+
+### VectorStore
+
+There exists a wrapper around Postgres vector databases, allowing you to use it as a vectorstore,
+whether for semantic search or example selection.
+
+To import this vectorstore:
+```python
+from langchain_community.vectorstores.pgvector import PGVector
+```
+
+### Usage
+
+For a more detailed walkthrough of the PGVector Wrapper, see [this notebook](/docs/integrations/vectorstores/pgvector)

langchain_md_files/integrations/providers/pinecone.mdx

@@ -0,0 +1,51 @@
+---
+keywords: [pinecone]
+---
+
+# Pinecone
+
+>[Pinecone](https://docs.pinecone.io/docs/overview) is a vector database with broad functionality.
+
+
+## Installation and Setup
+
+Install the Python SDK:
+
+```bash
+pip install langchain-pinecone
+```
+
+
+## Vector store
+
+There exists a wrapper around Pinecone indexes, allowing you to use it as a vectorstore,
+whether for semantic search or example selection.
+
+```python
+from langchain_pinecone import PineconeVectorStore
+```
+
+For a more detailed walkthrough of the Pinecone vectorstore, see [this notebook](/docs/integrations/vectorstores/pinecone)
+
+## Retrievers
+
+### Pinecone Hybrid Search
+
+```bash
+pip install pinecone-client pinecone-text
+```
+
+```python
+from langchain_community.retrievers import (
+    PineconeHybridSearchRetriever,
+)
+```
+
+For more detailed information, see [this notebook](/docs/integrations/retrievers/pinecone_hybrid_search).
+
+
+### Self Query retriever
+
+Pinecone vector store can be used as a retriever for self-querying.
+
+For more detailed information, see [this notebook](/docs/integrations/retrievers/self_query/pinecone).

langchain_md_files/integrations/providers/pipelineai.mdx

@@ -0,0 +1,19 @@
+# PipelineAI
+
+This page covers how to use the PipelineAI ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific PipelineAI wrappers.
+
+## Installation and Setup
+
+- Install with `pip install pipeline-ai`
+- Get a Pipeline Cloud api key and set it as an environment variable (`PIPELINE_API_KEY`)
+
+## Wrappers
+
+### LLM
+
+There exists a PipelineAI LLM wrapper, which you can access with
+
+```python
+from langchain_community.llms import PipelineAI
+```

langchain_md_files/integrations/providers/predictionguard.mdx

@@ -0,0 +1,102 @@
+# Prediction Guard
+
+This page covers how to use the Prediction Guard ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific Prediction Guard wrappers.
+
+## Installation and Setup
+- Install the Python SDK with `pip install predictionguard`
+- Get a Prediction Guard access token (as described [here](https://docs.predictionguard.com/)) and set it as an environment variable (`PREDICTIONGUARD_TOKEN`)
+
+## LLM Wrapper
+
+There exists a Prediction Guard LLM wrapper, which you can access with 
+```python
+from langchain_community.llms import PredictionGuard
+```
+
+You can provide the name of the Prediction Guard model as an argument when initializing the LLM:
+```python
+pgllm = PredictionGuard(model="MPT-7B-Instruct")
+```
+
+You can also provide your access token directly as an argument:
+```python
+pgllm = PredictionGuard(model="MPT-7B-Instruct", token="<your access token>")
+```
+
+Finally, you can provide an "output" argument that is used to structure/ control the output of the LLM:
+```python
+pgllm = PredictionGuard(model="MPT-7B-Instruct", output={"type": "boolean"})
+```
+
+## Example usage
+
+Basic usage of the controlled or guarded LLM wrapper:
+```python
+import os
+
+import predictionguard as pg
+from langchain_community.llms import PredictionGuard
+from langchain_core.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+# Your Prediction Guard API key. Get one at predictionguard.com
+os.environ["PREDICTIONGUARD_TOKEN"] = "<your Prediction Guard access token>"
+
+# Define a prompt template
+template = """Respond to the following query based on the context.
+
+Context: EVERY comment, DM + email suggestion has led us to this EXCITING announcement! 🎉 We have officially added TWO new candle subscription box options! 📦
+Exclusive Candle Box - $80 
+Monthly Candle Box - $45 (NEW!)
+Scent of The Month Box - $28 (NEW!)
+Head to stories to get ALL the deets on each box! 👆 BONUS: Save 50% on your first box with code 50OFF! 🎉
+
+Query: {query}
+
+Result: """
+prompt = PromptTemplate.from_template(template)
+
+# With "guarding" or controlling the output of the LLM. See the 
+# Prediction Guard docs (https://docs.predictionguard.com) to learn how to 
+# control the output with integer, float, boolean, JSON, and other types and
+# structures.
+pgllm = PredictionGuard(model="MPT-7B-Instruct", 
+                        output={
+                                "type": "categorical",
+                                "categories": [
+                                    "product announcement", 
+                                    "apology", 
+                                    "relational"
+                                    ]
+                                })
+pgllm(prompt.format(query="What kind of post is this?"))
+```
+
+Basic LLM Chaining with the Prediction Guard wrapper:
+```python
+import os
+
+from langchain_core.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from langchain_community.llms import PredictionGuard
+
+# Optional, add your OpenAI API Key. This is optional, as Prediction Guard allows
+# you to access all the latest open access models (see https://docs.predictionguard.com)
+os.environ["OPENAI_API_KEY"] = "<your OpenAI api key>"
+
+# Your Prediction Guard API key. Get one at predictionguard.com
+os.environ["PREDICTIONGUARD_TOKEN"] = "<your Prediction Guard access token>"
+
+pgllm = PredictionGuard(model="OpenAI-gpt-3.5-turbo-instruct")
+
+template = """Question: {question}
+
+Answer: Let's think step by step."""
+prompt = PromptTemplate.from_template(template)
+llm_chain = LLMChain(prompt=prompt, llm=pgllm, verbose=True)
+
+question = "What NFL team won the Super Bowl in the year Justin Beiber was born?"
+
+llm_chain.predict(question=question)
+```

langchain_md_files/integrations/providers/promptlayer.mdx

@@ -0,0 +1,49 @@
+# PromptLayer
+
+>[PromptLayer](https://docs.promptlayer.com/introduction) is a platform for prompt engineering. 
+> It also helps with the LLM observability to visualize requests, version prompts, and track usage.
+>
+>While `PromptLayer` does have LLMs that integrate directly with LangChain (e.g. 
+> [`PromptLayerOpenAI`](https://docs.promptlayer.com/languages/langchain)), 
+> using a callback is the recommended way to integrate `PromptLayer` with LangChain.
+
+## Installation and Setup
+
+To work with `PromptLayer`, we have to:
+- Create a `PromptLayer` account
+- Create an api token and set it as an environment variable (`PROMPTLAYER_API_KEY`)
+
+Install a Python package:
+
+```bash
+pip install promptlayer
+```
+
+
+## Callback
+
+See a [usage example](/docs/integrations/callbacks/promptlayer).
+
+```python
+import promptlayer  # Don't forget this import!
+from langchain.callbacks import PromptLayerCallbackHandler
+```
+
+
+## LLM
+
+See a [usage example](/docs/integrations/llms/promptlayer_openai).
+
+```python
+from langchain_community.llms import PromptLayerOpenAI
+```
+
+
+## Chat Models
+
+See a [usage example](/docs/integrations/chat/promptlayer_chatopenai).
+
+```python
+from langchain_community.chat_models import PromptLayerChatOpenAI
+```
+

langchain_md_files/integrations/providers/psychic.mdx

@@ -0,0 +1,34 @@
+---
+sidebar_class_name: hidden
+---
+
+# Psychic
+
+:::warning
+This provider is no longer maintained, and may not work. Use with caution.
+:::
+
+>[Psychic](https://www.psychic.dev/) is a platform for integrating with SaaS tools like `Notion`, `Zendesk`, 
+> `Confluence`, and `Google Drive` via OAuth and syncing documents from these applications to your SQL or vector
+> database. You can think of it like Plaid for unstructured data. 
+
+## Installation and Setup
+
+```bash
+pip install psychicapi
+```
+
+Psychic is easy to set up - you import the `react` library and configure it with your `Sidekick API` key, which you get 
+from the [Psychic dashboard](https://dashboard.psychic.dev/). When you connect the applications, you  
+view these connections from the dashboard and retrieve data using the server-side libraries.
+ 
+1. Create an account in the [dashboard](https://dashboard.psychic.dev/).
+2. Use the [react library](https://docs.psychic.dev/sidekick-link) to add the Psychic link modal to your frontend react app. You will use this to connect the SaaS apps.
+3. Once you have created a connection, you can use the `PsychicLoader` by following the [example notebook](/docs/integrations/document_loaders/psychic)
+
+
+## Advantages vs Other Document Loaders
+
+1.	**Universal API:** Instead of building OAuth flows and learning the APIs for every SaaS app, you integrate Psychic once and leverage our universal API to retrieve data.
+2.	**Data Syncs:** Data in your customers' SaaS apps can get stale fast. With Psychic you can configure webhooks to keep your documents up to date on a daily or realtime basis.
+3.	**Simplified OAuth:** Psychic handles OAuth end-to-end so that you don't have to spend time creating OAuth clients for each integration, keeping access tokens fresh, and handling OAuth redirect logic.

langchain_md_files/integrations/providers/pygmalionai.mdx

@@ -0,0 +1,21 @@
+# PygmalionAI
+
+>[PygmalionAI](https://pygmalion.chat/) is a company supporting the 
+> open-source models by serving the inference endpoint 
+> for the [Aphrodite Engine](https://github.com/PygmalionAI/aphrodite-engine).
+
+
+## Installation and Setup
+
+
+```bash
+pip install aphrodite-engine
+```
+
+## LLMs
+
+See a [usage example](/docs/integrations/llms/aphrodite).
+
+```python
+from langchain_community.llms import Aphrodite
+```

langchain_md_files/integrations/providers/qdrant.mdx

@@ -0,0 +1,27 @@
+# Qdrant
+
+>[Qdrant](https://qdrant.tech/documentation/) (read: quadrant) is a vector similarity search engine. 
+> It provides a production-ready service with a convenient API to store, search, and manage 
+> points - vectors with an additional payload. `Qdrant` is tailored to extended filtering support.
+
+
+## Installation and Setup
+
+Install the Python partner package:
+
+```bash
+pip install langchain-qdrant
+```
+
+
+## Vector Store
+
+There exists a wrapper around `Qdrant` indexes, allowing you to use it as a vectorstore,
+whether for semantic search or example selection.
+
+To import this vectorstore:
+```python
+from langchain_qdrant import QdrantVectorStore
+```
+
+For a more detailed walkthrough of the Qdrant wrapper, see [this notebook](/docs/integrations/vectorstores/qdrant)

langchain_md_files/integrations/providers/rank_bm25.mdx

@@ -0,0 +1,25 @@
+# rank_bm25
+
+[rank_bm25](https://github.com/dorianbrown/rank_bm25) is an open-source collection of algorithms
+designed to query documents and return the most relevant ones, commonly used for creating
+search engines.
+
+See its [project page](https://github.com/dorianbrown/rank_bm25) for available algorithms.
+
+
+## Installation and Setup
+
+First, you need to install `rank_bm25` python package.
+
+```bash
+pip install rank_bm25
+```
+
+
+## Retriever
+
+See a [usage example](/docs/integrations/retrievers/bm25).
+
+```python
+from langchain_community.retrievers import BM25Retriever
+```

langchain_md_files/integrations/providers/reddit.mdx

@@ -0,0 +1,22 @@
+# Reddit
+
+>[Reddit](https://www.reddit.com) is an American social news aggregation, content rating, and discussion website.
+
+## Installation and Setup
+
+First, you need to install a python package.
+
+```bash
+pip install praw
+```
+
+Make a [Reddit Application](https://www.reddit.com/prefs/apps/) and initialize the loader with your Reddit API credentials.
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/reddit).
+
+
+```python
+from langchain_community.document_loaders import RedditPostsLoader
+```

langchain_md_files/integrations/providers/redis.mdx

@@ -0,0 +1,138 @@
+# Redis
+
+>[Redis (Remote Dictionary Server)](https://en.wikipedia.org/wiki/Redis) is an open-source in-memory storage, 
+> used as a distributed, in-memory key–value database, cache and message broker, with optional durability. 
+> Because it holds all data in memory and because of its design, `Redis` offers low-latency reads and writes, 
+> making it particularly suitable for use cases that require a cache. Redis is the most popular NoSQL database, 
+> and one of the most popular databases overall.
+
+This page covers how to use the [Redis](https://redis.com) ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific Redis wrappers.
+
+## Installation and Setup
+
+Install the Python SDK:
+
+```bash
+pip install redis
+```
+
+To run Redis locally, you can use Docker:
+
+```bash
+docker run --name langchain-redis -d -p 6379:6379 redis redis-server --save 60 1 --loglevel warning
+```
+
+To stop the container:
+
+```bash
+docker stop langchain-redis
+```
+
+And to start it again:
+
+```bash
+docker start langchain-redis
+```
+
+### Connections
+
+We need a redis url connection string to connect to the database support either a stand alone Redis server
+or a High-Availability setup with Replication and Redis Sentinels.
+
+#### Redis Standalone connection url
+For standalone `Redis` server, the official redis connection url formats can be used as describe in the python redis modules
+"from_url()" method [Redis.from_url](https://redis-py.readthedocs.io/en/stable/connections.html#redis.Redis.from_url)
+
+Example: `redis_url = "redis://:secret-pass@localhost:6379/0"`
+
+#### Redis Sentinel connection url
+
+For [Redis sentinel setups](https://redis.io/docs/management/sentinel/) the connection scheme is "redis+sentinel". 
+This is an unofficial extensions to the official IANA registered protocol schemes as long as there is no connection url
+for Sentinels available.
+
+Example: `redis_url = "redis+sentinel://:secret-pass@sentinel-host:26379/mymaster/0"`
+
+The format is  `redis+sentinel://[[username]:[password]]@[host-or-ip]:[port]/[service-name]/[db-number]`
+with the default values of "service-name = mymaster" and "db-number = 0" if not set explicit.
+The service-name is the redis server monitoring group name as configured within the Sentinel. 
+
+The current url format limits the connection string to one sentinel host only (no list can be given) and
+booth Redis server and sentinel must have the same password set (if used).
+
+#### Redis Cluster connection url
+
+Redis cluster is not supported right now for all methods requiring a "redis_url" parameter.
+The only way to use a Redis Cluster is with LangChain classes accepting a preconfigured Redis client like `RedisCache`
+(example below).
+
+## Cache
+
+The Cache wrapper allows for [Redis](https://redis.io) to be used as a remote, low-latency, in-memory cache for LLM prompts and responses.
+
+### Standard Cache
+The standard cache is the Redis bread & butter of use case in production for both [open-source](https://redis.io) and [enterprise](https://redis.com) users globally.
+
+```python
+from langchain.cache import RedisCache
+```
+
+To use this cache with your LLMs:
+```python
+from langchain.globals import set_llm_cache
+import redis
+
+redis_client = redis.Redis.from_url(...)
+set_llm_cache(RedisCache(redis_client))
+```
+
+### Semantic Cache
+Semantic caching allows users to retrieve cached prompts based on semantic similarity between the user input and previously cached results. Under the hood it blends Redis as both a cache and a vectorstore.
+
+```python
+from langchain.cache import RedisSemanticCache
+```
+
+To use this cache with your LLMs:
+```python
+from langchain.globals import set_llm_cache
+import redis
+
+# use any embedding provider...
+from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings
+
+redis_url = "redis://localhost:6379"
+
+set_llm_cache(RedisSemanticCache(
+    embedding=FakeEmbeddings(),
+    redis_url=redis_url
+))
+```
+
+## VectorStore
+
+The vectorstore wrapper turns Redis into a low-latency [vector database](https://redis.com/solutions/use-cases/vector-database/) for semantic search or LLM content retrieval.
+
+```python
+from langchain_community.vectorstores import Redis
+```
+
+For a more detailed walkthrough of the Redis vectorstore wrapper, see [this notebook](/docs/integrations/vectorstores/redis).
+
+## Retriever
+
+The Redis vector store retriever wrapper generalizes the vectorstore class to perform 
+low-latency document retrieval. To create the retriever, simply 
+call `.as_retriever()` on the base vectorstore class.
+
+## Memory
+
+Redis can be used to persist LLM conversations.
+
+### Vector Store Retriever Memory
+
+For a more detailed walkthrough of the `VectorStoreRetrieverMemory` wrapper, see [this notebook](https://python.langchain.com/v0.2/api_reference/langchain/memory/langchain.memory.vectorstore.VectorStoreRetrieverMemory.html).
+
+### Chat Message History Memory
+For a detailed example of Redis to cache conversation message history, see [this notebook](/docs/integrations/memory/redis_chat_message_history).

langchain_md_files/integrations/providers/remembrall.mdx

@@ -0,0 +1,15 @@
+# Remembrall
+
+>[Remembrall](https://remembrall.dev/) is a platform that gives a language model 
+> long-term memory, retrieval augmented generation, and complete observability.
+ 
+## Installation and Setup
+
+To get started, [sign in with Github on the Remembrall platform](https://remembrall.dev/login) 
+and copy your [API key from the settings page](https://remembrall.dev/dashboard/settings).
+
+
+## Memory
+
+See a [usage example](/docs/integrations/memory/remembrall).
+

langchain_md_files/integrations/providers/replicate.mdx

@@ -0,0 +1,46 @@
+# Replicate
+This page covers how to run models on Replicate within LangChain.
+
+## Installation and Setup
+- Create a [Replicate](https://replicate.com) account. Get your API key and set it as an environment variable (`REPLICATE_API_TOKEN`)
+- Install the [Replicate python client](https://github.com/replicate/replicate-python) with `pip install replicate`
+
+## Calling a model
+
+Find a model on the [Replicate explore page](https://replicate.com/explore), and then paste in the model name and version in this format: `owner-name/model-name:version`
+
+For example, for this [dolly model](https://replicate.com/replicate/dolly-v2-12b), click on the API tab. The model name/version would be: `"replicate/dolly-v2-12b:ef0e1aefc61f8e096ebe4db6b2bacc297daf2ef6899f0f7e001ec445893500e5"`
+
+Only the `model` param is required, but any other model parameters can also be passed in with the format `input={model_param: value, ...}`
+
+
+For example, if we were running stable diffusion and wanted to change the image dimensions:
+
+```
+Replicate(model="stability-ai/stable-diffusion:db21e45d3f7023abc2a46ee38a23973f6dce16bb082a930b0c49861f96d1e5bf", input={'image_dimensions': '512x512'})
+```
+
+*Note that only the first output of a model will be returned.*
+From here, we can initialize our model:
+
+```python
+llm = Replicate(model="replicate/dolly-v2-12b:ef0e1aefc61f8e096ebe4db6b2bacc297daf2ef6899f0f7e001ec445893500e5")
+```
+
+And run it:
+
+```python
+prompt = """
+Answer the following yes/no question by reasoning step by step.
+Can a dog drive a car?
+"""
+llm(prompt)
+```
+
+We can call any Replicate model (not just LLMs) using this syntax. For example, we can call [Stable Diffusion](https://replicate.com/stability-ai/stable-diffusion):
+
+```python
+text2image = Replicate(model="stability-ai/stable-diffusion:db21e45d3f7023abc2a46ee38a23973f6dce16bb082a930b0c49861f96d1e5bf", input={'image_dimensions':'512x512'})
+
+image_output = text2image("A cat riding a motorcycle by Picasso")
+```

langchain_md_files/integrations/providers/roam.mdx

@@ -0,0 +1,17 @@
+# Roam
+
+>[ROAM](https://roamresearch.com/) is a note-taking tool for networked thought, designed to create a personal knowledge base.
+ 
+## Installation and Setup
+
+There isn't any special setup for it.
+
+
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/roam).
+
+```python
+from langchain_community.document_loaders import RoamLoader
+```

langchain_md_files/integrations/providers/robocorp.mdx

@@ -0,0 +1,37 @@
+# Robocorp
+
+>[Robocorp](https://robocorp.com/) helps build and operate Python workers that run seamlessly anywhere at any scale
+
+
+## Installation and Setup
+
+You need to install `langchain-robocorp` python package:
+
+```bash
+pip install langchain-robocorp
+```
+
+You will need a running instance of `Action Server` to communicate with from your agent application. 
+See the [Robocorp Quickstart](https://github.com/robocorp/robocorp#quickstart) on how to setup Action Server and create your Actions.
+
+You can bootstrap a new project using Action Server `new` command.
+
+```bash
+action-server new
+cd ./your-project-name
+action-server start
+```
+
+## Tool
+
+```python
+from langchain_robocorp.toolkits import ActionServerRequestTool
+```
+
+## Toolkit
+
+See a [usage example](/docs/integrations/tools/robocorp).
+
+```python
+from langchain_robocorp import ActionServerToolkit
+```

langchain_md_files/integrations/providers/rockset.mdx

@@ -0,0 +1,33 @@
+# Rockset
+
+>[Rockset](https://rockset.com/product/) is a real-time analytics database service for serving low latency, high concurrency analytical queries at scale. It builds a Converged Index™ on structured and semi-structured data with an efficient store for vector embeddings. Its support for running SQL on schemaless data makes it a perfect choice for running vector search with metadata filters. 
+
+## Installation and Setup
+
+Make sure you have Rockset account and go to the web console to get the API key. Details can be found on [the website](https://rockset.com/docs/rest-api/).
+
+```bash
+pip install rockset
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/rockset).
+
+```python
+from langchain_community.vectorstores import Rockset 
+```
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/rockset).
+```python
+from langchain_community.document_loaders import RocksetLoader
+```
+
+## Chat Message History
+
+See a [usage example](/docs/integrations/memory/rockset_chat_message_history).
+```python
+from langchain_community.chat_message_histories import RocksetChatMessageHistory
+```

langchain_md_files/integrations/providers/runhouse.mdx

@@ -0,0 +1,29 @@
+# Runhouse
+
+This page covers how to use the [Runhouse](https://github.com/run-house/runhouse) ecosystem within LangChain.
+It is broken into three parts: installation and setup, LLMs, and Embeddings.
+
+## Installation and Setup
+- Install the Python SDK with `pip install runhouse`
+- If you'd like to use on-demand cluster, check your cloud credentials with `sky check`
+
+## Self-hosted LLMs
+For a basic self-hosted LLM, you can use the `SelfHostedHuggingFaceLLM` class. For more
+custom LLMs, you can use the `SelfHostedPipeline` parent class.
+
+```python
+from langchain_community.llms import SelfHostedPipeline, SelfHostedHuggingFaceLLM
+```
+
+For a more detailed walkthrough of the Self-hosted LLMs, see [this notebook](/docs/integrations/llms/runhouse)
+
+## Self-hosted Embeddings
+There are several ways to use self-hosted embeddings with LangChain via Runhouse.
+
+For a basic self-hosted embedding from a Hugging Face Transformers model, you can use 
+the `SelfHostedEmbedding` class.
+```python
+from langchain_community.llms import SelfHostedPipeline, SelfHostedHuggingFaceLLM
+```
+
+For a more detailed walkthrough of the Self-hosted Embeddings, see [this notebook](/docs/integrations/text_embedding/self-hosted)

langchain_md_files/integrations/providers/rwkv.mdx

@@ -0,0 +1,65 @@
+# RWKV-4
+
+This page covers how to use the `RWKV-4` wrapper within LangChain.
+It is broken into two parts: installation and setup, and then usage with an example.
+
+## Installation and Setup
+- Install the Python package with `pip install rwkv`
+- Install the tokenizer Python package with `pip install tokenizer`
+- Download a [RWKV model](https://huggingface.co/BlinkDL/rwkv-4-raven/tree/main) and place it in your desired directory
+- Download the [tokens file](https://raw.githubusercontent.com/BlinkDL/ChatRWKV/main/20B_tokenizer.json)
+
+## Usage
+
+### RWKV
+
+To use the RWKV wrapper, you need to provide the path to the pre-trained model file and the tokenizer's configuration.
+```python
+from langchain_community.llms import RWKV
+
+# Test the model
+
+```python
+
+def generate_prompt(instruction, input=None):
+    if input:
+        return f"""Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
+
+# Instruction:
+{instruction}
+
+# Input:
+{input}
+
+# Response:
+"""
+    else:
+        return f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+
+# Instruction:
+{instruction}
+
+# Response:
+"""
+
+
+model = RWKV(model="./models/RWKV-4-Raven-3B-v7-Eng-20230404-ctx4096.pth", strategy="cpu fp32", tokens_path="./rwkv/20B_tokenizer.json")
+response = model.invoke(generate_prompt("Once upon a time, "))
+```
+## Model File
+
+You can find links to model file downloads at the [RWKV-4-Raven](https://huggingface.co/BlinkDL/rwkv-4-raven/tree/main) repository.
+
+### Rwkv-4 models -> recommended VRAM
+
+
+```
+RWKV VRAM
+Model | 8bit | bf16/fp16 | fp32
+14B   | 16GB | 28GB      | >50GB
+7B    | 8GB  | 14GB      | 28GB
+3B    | 2.8GB| 6GB       | 12GB
+1b5   | 1.3GB| 3GB       | 6GB
+```
+
+See the [rwkv pip](https://pypi.org/project/rwkv/) page for more information about strategies, including streaming and cuda support.

langchain_md_files/integrations/providers/salute_devices.mdx

@@ -0,0 +1,37 @@
+# Salute Devices
+
+Salute Devices provides GigaChat LLM's models.
+
+For more info how to get access to GigaChat [follow here](https://developers.sber.ru/docs/ru/gigachat/api/integration).
+
+## Installation and Setup
+
+GigaChat package can be installed via pip from PyPI:
+
+```bash
+pip install gigachat
+```
+
+## LLMs
+
+See a [usage example](/docs/integrations/llms/gigachat).
+
+```python
+from langchain_community.llms import GigaChat
+```
+
+## Chat models
+
+See a [usage example](/docs/integrations/chat/gigachat).
+
+```python
+from langchain_community.chat_models import GigaChat
+```
+
+## Embeddings
+
+See a [usage example](/docs/integrations/text_embedding/gigachat).
+
+```python
+from langchain_community.embeddings import GigaChatEmbeddings
+```

langchain_md_files/integrations/providers/sap.mdx

@@ -0,0 +1,25 @@
+# SAP
+
+>[SAP SE(Wikipedia)](https://www.sap.com/about/company.html) is a German multinational 
+> software company. It develops enterprise software to manage business operation and 
+> customer relations. The company is the world's leading 
+> `enterprise resource planning (ERP)` software vendor.
+
+## Installation and Setup
+
+We need to install the `hdbcli` python package.
+
+```bash
+pip install hdbcli
+```
+
+## Vectorstore
+
+>[SAP HANA Cloud Vector Engine](https://www.sap.com/events/teched/news-guide/ai.html#article8) is 
+> a vector store fully integrated into the `SAP HANA Cloud` database.
+
+See a [usage example](/docs/integrations/vectorstores/sap_hanavector).
+
+```python
+from langchain_community.vectorstores.hanavector import HanaDB
+```

langchain_md_files/integrations/providers/searchapi.mdx

@@ -0,0 +1,80 @@
+# SearchApi
+
+This page covers how to use the [SearchApi](https://www.searchapi.io/) Google Search API within LangChain. SearchApi is a real-time SERP API for easy SERP scraping.
+
+## Setup
+
+- Go to [https://www.searchapi.io/](https://www.searchapi.io/) to sign up for a free account
+- Get the api key and set it as an environment variable (`SEARCHAPI_API_KEY`)
+
+## Wrappers
+
+### Utility
+
+There is a SearchApiAPIWrapper utility which wraps this API. To import this utility:
+
+```python
+from langchain_community.utilities import SearchApiAPIWrapper
+```
+
+You can use it as part of a Self Ask chain:
+
+```python
+from langchain_community.utilities import SearchApiAPIWrapper
+from langchain_openai import OpenAI
+from langchain.agents import initialize_agent, Tool
+from langchain.agents import AgentType
+
+import os
+
+os.environ["SEARCHAPI_API_KEY"] = ""
+os.environ['OPENAI_API_KEY'] = ""
+
+llm = OpenAI(temperature=0)
+search = SearchApiAPIWrapper()
+tools = [
+    Tool(
+        name="Intermediate Answer",
+        func=search.run,
+        description="useful for when you need to ask with search"
+    )
+]
+
+self_ask_with_search = initialize_agent(tools, llm, agent=AgentType.SELF_ASK_WITH_SEARCH, verbose=True)
+self_ask_with_search.run("Who lived longer: Plato, Socrates, or Aristotle?")
+```
+
+#### Output
+
+```
+> Entering new AgentExecutor chain...
+ Yes.
+Follow up: How old was Plato when he died?
+Intermediate answer: eighty
+Follow up: How old was Socrates when he died?
+Intermediate answer: | Socrates | 
+| -------- | 
+| Born | c. 470 BC Deme Alopece, Athens | 
+| Died | 399 BC (aged approximately 71) Athens | 
+| Cause of death | Execution by forced suicide by poisoning | 
+| Spouse(s) | Xanthippe, Myrto | 
+
+Follow up: How old was Aristotle when he died?
+Intermediate answer: 62 years
+So the final answer is: Plato
+
+> Finished chain.
+'Plato'
+```
+
+### Tool
+
+You can also easily load this wrapper as a Tool (to use with an Agent).
+You can do this with:
+
+```python
+from langchain.agents import load_tools
+tools = load_tools(["searchapi"])
+```
+
+For more information on tools, see [this page](/docs/how_to/tools_builtin).

langchain_md_files/integrations/providers/searx.mdx

@@ -0,0 +1,90 @@
+# SearxNG Search API
+
+This page covers how to use the SearxNG search API within LangChain.
+It is broken into two parts: installation and setup, and then references to the specific SearxNG API wrapper.
+
+## Installation and Setup
+
+While it is possible to utilize the wrapper in conjunction with  [public searx
+instances](https://searx.space/) these instances frequently do not permit API
+access (see note on output format below) and have limitations on the frequency
+of requests. It is recommended to opt for a self-hosted instance instead.
+
+### Self Hosted Instance:
+
+See [this page](https://searxng.github.io/searxng/admin/installation.html) for installation instructions.
+
+When you install SearxNG, the only active output format by default is the HTML format.
+You need to activate the `json` format to use the API. This can be done by adding the following line to the `settings.yml` file:
+```yaml
+search:
+    formats:
+        - html
+        - json
+```
+You can make sure that the API is working by issuing a curl request to the API endpoint:
+
+`curl -kLX GET --data-urlencode q='langchain' -d format=json http://localhost:8888`
+
+This should return a JSON object with the results.
+
+
+## Wrappers
+
+### Utility
+
+To use the wrapper we need to pass the host of the SearxNG instance to the wrapper with:
+    1. the named parameter `searx_host` when creating the instance.
+    2. exporting the environment variable `SEARXNG_HOST`.
+
+You can use the wrapper to get results from a SearxNG instance. 
+
+```python
+from langchain_community.utilities import SearxSearchWrapper
+s = SearxSearchWrapper(searx_host="http://localhost:8888")
+s.run("what is a large language model?")
+```
+
+### Tool
+
+You can also load this wrapper as a Tool (to use with an Agent).
+
+You can do this with:
+
+```python
+from langchain.agents import load_tools
+tools = load_tools(["searx-search"],
+                    searx_host="http://localhost:8888",
+                    engines=["github"])
+```
+
+Note that we could _optionally_ pass custom engines to use.
+
+If you want to obtain results with metadata as *json* you can use:
+```python
+tools = load_tools(["searx-search-results-json"],
+                    searx_host="http://localhost:8888",
+                    num_results=5)
+```
+
+#### Quickly creating tools
+
+This examples showcases a quick way to create multiple tools from the same
+wrapper.
+
+```python
+from langchain_community.tools.searx_search.tool import SearxSearchResults
+
+wrapper = SearxSearchWrapper(searx_host="**")
+github_tool = SearxSearchResults(name="Github", wrapper=wrapper,
+                            kwargs = {
+                                "engines": ["github"],
+                                })
+
+arxiv_tool = SearxSearchResults(name="Arxiv", wrapper=wrapper,
+                            kwargs = {
+                                "engines": ["arxiv"]
+                                })
+```
+
+For more information on tools, see [this page](/docs/how_to/tools_builtin).

langchain_md_files/integrations/providers/semadb.mdx

@@ -0,0 +1,19 @@
+# SemaDB
+
+>[SemaDB](https://semafind.com/) is a no fuss vector similarity search engine. It provides a low-cost cloud hosted version to help you build AI applications with ease.
+
+With SemaDB Cloud, our hosted version, no fuss means no pod size calculations, no schema definitions, no partition settings, no parameter tuning, no search algorithm tuning, no complex installation, no complex API. It is integrated with [RapidAPI](https://rapidapi.com/semafind-semadb/api/semadb) providing transparent billing, automatic sharding and an interactive API playground.
+
+## Installation
+
+None required, get started directly with SemaDB Cloud at [RapidAPI](https://rapidapi.com/semafind-semadb/api/semadb).
+
+## Vector Store
+
+There is a basic wrapper around `SemaDB` collections allowing you to use it as a vectorstore.
+
+```python
+from langchain_community.vectorstores import SemaDB
+```
+
+You can follow a tutorial on how to use the wrapper in [this notebook](/docs/integrations/vectorstores/semadb).

langchain_md_files/integrations/providers/serpapi.mdx

@@ -0,0 +1,31 @@
+# SerpAPI
+
+This page covers how to use the SerpAPI search APIs within LangChain.
+It is broken into two parts: installation and setup, and then references to the specific SerpAPI wrapper.
+
+## Installation and Setup
+- Install requirements with `pip install google-search-results`
+- Get a SerpAPI api key and either set it as an environment variable (`SERPAPI_API_KEY`)
+
+## Wrappers
+
+### Utility
+
+There exists a SerpAPI utility which wraps this API. To import this utility:
+
+```python
+from langchain_community.utilities import SerpAPIWrapper
+```
+
+For a more detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/serpapi).
+
+### Tool
+
+You can also easily load this wrapper as a Tool (to use with an Agent).
+You can do this with:
+```python
+from langchain.agents import load_tools
+tools = load_tools(["serpapi"])
+```
+
+For more information on this, see [this page](/docs/how_to/tools_builtin)

langchain_md_files/integrations/providers/singlestoredb.mdx

@@ -0,0 +1,28 @@
+# SingleStoreDB
+
+>[SingleStoreDB](https://singlestore.com/) is a high-performance distributed SQL database that supports deployment both in the [cloud](https://www.singlestore.com/cloud/) and on-premises. It provides vector storage, and vector functions including [dot_product](https://docs.singlestore.com/managed-service/en/reference/sql-reference/vector-functions/dot_product.html) and [euclidean_distance](https://docs.singlestore.com/managed-service/en/reference/sql-reference/vector-functions/euclidean_distance.html), thereby supporting AI applications that require text similarity matching. 
+
+## Installation and Setup
+
+There are several ways to establish a [connection](https://singlestoredb-python.labs.singlestore.com/generated/singlestoredb.connect.html) to the database. You can either set up environment variables or pass named parameters to the `SingleStoreDB constructor`. 
+Alternatively, you may provide these parameters to the `from_documents` and `from_texts` methods.
+
+```bash
+pip install singlestoredb
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/singlestoredb).
+
+```python
+from langchain_community.vectorstores import SingleStoreDB
+```
+
+## Memory
+
+See a [usage example](/docs/integrations/memory/singlestoredb_chat_message_history).
+
+```python
+from langchain.memory import SingleStoreDBChatMessageHistory
+```

langchain_md_files/integrations/providers/sklearn.mdx

@@ -0,0 +1,35 @@
+# scikit-learn
+
+>[scikit-learn](https://scikit-learn.org/stable/) is an open-source collection of machine learning algorithms, 
+> including some implementations of the [k nearest neighbors](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.NearestNeighbors.html). `SKLearnVectorStore` wraps this implementation and adds the possibility to persist the vector store in json, bson (binary json) or Apache Parquet format.
+
+## Installation and Setup
+
+- Install the Python package with `pip install scikit-learn`
+
+
+## Vector Store
+
+`SKLearnVectorStore` provides a simple wrapper around the nearest neighbor implementation in the
+scikit-learn package, allowing you to use it as a vectorstore.
+
+To import this vectorstore:
+
+```python
+from langchain_community.vectorstores import SKLearnVectorStore
+```
+
+For a more detailed walkthrough of the SKLearnVectorStore wrapper, see [this notebook](/docs/integrations/vectorstores/sklearn).
+
+
+## Retriever
+
+`Support vector machines (SVMs)` are the supervised learning 
+methods used for classification, regression and outliers detection.
+
+See a [usage example](/docs/integrations/retrievers/svm).
+
+```python
+from langchain_community.retrievers import SVMRetriever
+```
+

langchain_md_files/integrations/providers/slack.mdx

@@ -0,0 +1,32 @@
+# Slack
+
+>[Slack](https://slack.com/) is an instant messaging program.
+ 
+## Installation and Setup
+
+There isn't any special setup for it.
+
+
+## Document loader
+
+See a [usage example](/docs/integrations/document_loaders/slack).
+
+```python
+from langchain_community.document_loaders import SlackDirectoryLoader
+```
+
+## Toolkit
+
+See a [usage example](/docs/integrations/tools/slack).
+
+```python
+from langchain_community.agent_toolkits import SlackToolkit
+```
+
+## Chat loader
+
+See a [usage example](/docs/integrations/chat_loaders/slack).
+
+```python
+from langchain_community.chat_loaders.slack import SlackChatLoader
+```

langchain_md_files/integrations/providers/snowflake.mdx

@@ -0,0 +1,32 @@
+# Snowflake
+
+> [Snowflake](https://www.snowflake.com/) is a cloud-based data-warehousing platform 
+> that allows you to store and query large amounts of data.
+
+This page covers how to use the `Snowflake` ecosystem within `LangChain`.
+
+## Embedding models
+
+Snowflake offers their open-weight `arctic` line of embedding models for free
+on [Hugging Face](https://huggingface.co/Snowflake/snowflake-arctic-embed-m-v1.5). The most recent model, snowflake-arctic-embed-m-v1.5 feature [matryoshka embedding](https://arxiv.org/abs/2205.13147) which allows for effective vector truncation. 
+You can use these models via the 
+[HuggingFaceEmbeddings](/docs/integrations/text_embedding/huggingfacehub) connector:
+
+```shell
+pip install langchain-community sentence-transformers
+```
+
+```python
+from langchain_huggingface import HuggingFaceEmbeddings
+
+model = HuggingFaceEmbeddings(model_name="snowflake/arctic-embed-m-v1.5")
+```
+
+## Document loader
+
+You can use the [`SnowflakeLoader`](/docs/integrations/document_loaders/snowflake) 
+to load data from Snowflake:
+
+```python
+from langchain_community.document_loaders import SnowflakeLoader
+```

langchain_md_files/integrations/providers/spacy.mdx

@@ -0,0 +1,28 @@
+# spaCy
+
+>[spaCy](https://spacy.io/) is an open-source software library for advanced natural language processing, written in the programming languages Python and Cython.
+ 
+## Installation and Setup
+
+
+```bash
+pip install spacy
+```
+
+
+
+## Text Splitter
+
+See a [usage example](/docs/how_to/split_by_token/#spacy).
+
+```python
+from langchain_text_splitters import SpacyTextSplitter
+```
+
+## Text Embedding Models
+
+See a [usage example](/docs/integrations/text_embedding/spacy_embedding)
+
+```python
+from langchain_community.embeddings.spacy_embeddings import SpacyEmbeddings
+```

langchain_md_files/integrations/providers/sparkllm.mdx

@@ -0,0 +1,14 @@
+# SparkLLM
+
+>[SparkLLM](https://xinghuo.xfyun.cn/spark) is a large-scale cognitive model independently developed by iFLYTEK.
+It has cross-domain knowledge and language understanding ability by learning a large amount of texts, codes and images.
+It can understand and perform tasks based on natural dialogue.
+
+## SparkLLM LLM Model
+An example is available at [example](/docs/integrations/llms/sparkllm).
+
+## SparkLLM Chat Model
+An example is available at [example](/docs/integrations/chat/sparkllm).
+
+## SparkLLM Text Embedding Model
+An example is available at [example](/docs/integrations/text_embedding/sparkllm)

langchain_md_files/integrations/providers/spreedly.mdx

@@ -0,0 +1,15 @@
+# Spreedly
+
+>[Spreedly](https://docs.spreedly.com/) is a service that allows you to securely store credit cards and use them to transact against any number of payment gateways and third party APIs. It does this by simultaneously providing a card tokenization/vault service as well as a gateway and receiver integration service. Payment methods tokenized by Spreedly are stored at `Spreedly`, allowing you to independently store a card and then pass that card to different end points based on your business requirements.
+ 
+## Installation and Setup
+
+See [setup instructions](/docs/integrations/document_loaders/spreedly).
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/spreedly).
+
+```python
+from langchain_community.document_loaders import SpreedlyLoader
+```

langchain_md_files/integrations/providers/sqlite.mdx

@@ -0,0 +1,31 @@
+# SQLite
+
+>[SQLite](https://en.wikipedia.org/wiki/SQLite) is a database engine written in the 
+> C programming language. It is not a standalone app; rather, it is a library that 
+> software developers embed in their apps. As such, it belongs to the family of 
+> embedded databases. It is the most widely deployed database engine, as it is 
+> used by several of the top web browsers, operating systems, mobile phones, and other embedded systems.
+
+## Installation and Setup
+
+We need to install the `SQLAlchemy` python package.
+
+```bash
+pip install SQLAlchemy
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/sqlitevss).
+
+```python
+from langchain_community.vectorstores import SQLiteVSS
+```
+
+## Memory
+
+See a [usage example](/docs/integrations/memory/sqlite).
+
+```python
+from langchain_community.chat_message_histories import SQLChatMessageHistory
+```

langchain_md_files/integrations/providers/stackexchange.mdx

@@ -0,0 +1,36 @@
+# Stack Exchange
+
+>[Stack Exchange](https://en.wikipedia.org/wiki/Stack_Exchange) is a network of 
+question-and-answer (Q&A) websites on topics in diverse fields, each site covering 
+a specific topic, where questions, answers, and users are subject to a reputation award process.
+
+This page covers how to use the `Stack Exchange API` within LangChain.
+
+## Installation and Setup
+- Install requirements with 
+```bash
+pip install stackapi
+```
+
+## Wrappers
+
+### Utility
+
+There exists a StackExchangeAPIWrapper utility which wraps this API. To import this utility:
+
+```python
+from langchain_community.utilities import StackExchangeAPIWrapper
+```
+
+For a more detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/stackexchange).
+
+### Tool
+
+You can also easily load this wrapper as a Tool (to use with an Agent).
+You can do this with:
+```python
+from langchain.agents import load_tools
+tools = load_tools(["stackexchange"])
+```
+
+For more information on tools, see [this page](/docs/how_to/tools_builtin).

langchain_md_files/integrations/providers/starrocks.mdx

@@ -0,0 +1,21 @@
+# StarRocks
+
+>[StarRocks](https://www.starrocks.io/) is a High-Performance Analytical Database.
+`StarRocks` is a next-gen sub-second MPP database for full analytics scenarios, including multi-dimensional analytics, real-time analytics and ad-hoc query.
+
+>Usually `StarRocks` is categorized into OLAP, and it has showed excellent performance in [ClickBench — a Benchmark For Analytical DBMS](https://benchmark.clickhouse.com/). Since it has a super-fast vectorized execution engine, it could also be used as a fast vectordb.
+
+## Installation and Setup
+
+
+```bash
+pip install pymysql
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/starrocks).
+
+```python
+from langchain_community.vectorstores import StarRocks
+```

langchain_md_files/integrations/providers/stochasticai.mdx

@@ -0,0 +1,17 @@
+# StochasticAI
+
+This page covers how to use the StochasticAI ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific StochasticAI wrappers.
+
+## Installation and Setup
+- Install with `pip install stochasticx`
+- Get an StochasticAI api key and set it as an environment variable (`STOCHASTICAI_API_KEY`)
+
+## Wrappers
+
+### LLM
+
+There exists an StochasticAI LLM wrapper, which you can access with 
+```python
+from langchain_community.llms import StochasticAI
+```

langchain_md_files/integrations/providers/streamlit.mdx

@@ -0,0 +1,30 @@
+# Streamlit
+
+>[Streamlit](https://streamlit.io/) is a faster way to build and share data apps.
+>`Streamlit` turns data scripts into shareable web apps in minutes. All in pure Python. No front‑end experience required.
+>See more examples at [streamlit.io/generative-ai](https://streamlit.io/generative-ai).
+
+## Installation and Setup
+
+We need to install the  `streamlit` Python package:
+
+```bash
+pip install streamlit
+```
+
+
+## Memory
+
+See a [usage example](/docs/integrations/memory/streamlit_chat_message_history).
+
+```python
+from langchain_community.chat_message_histories import StreamlitChatMessageHistory
+```
+
+## Callbacks
+
+See a [usage example](/docs/integrations/callbacks/streamlit).
+
+```python
+from langchain_community.callbacks import StreamlitCallbackHandler
+```

langchain_md_files/integrations/providers/stripe.mdx

@@ -0,0 +1,16 @@
+# Stripe
+
+>[Stripe](https://stripe.com/en-ca) is an Irish-American financial services and software as a service (SaaS) company. It offers payment-processing software and application programming interfaces for e-commerce websites and mobile applications.
+
+
+## Installation and Setup
+
+See [setup instructions](/docs/integrations/document_loaders/stripe).
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/stripe).
+
+```python
+from langchain_community.document_loaders import StripeLoader
+```

langchain_md_files/integrations/providers/supabase.mdx

@@ -0,0 +1,26 @@
+# Supabase (Postgres)
+
+>[Supabase](https://supabase.com/docs) is an open-source `Firebase` alternative. 
+> `Supabase` is built on top of `PostgreSQL`, which offers strong `SQL` 
+> querying capabilities and enables a simple interface with already-existing tools and frameworks.
+
+>[PostgreSQL](https://en.wikipedia.org/wiki/PostgreSQL) also known as `Postgres`,
+> is a free and open-source relational database management system (RDBMS) 
+> emphasizing extensibility and `SQL` compliance.
+
+## Installation and Setup
+
+We need to install `supabase` python package.
+
+```bash
+pip install supabase
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/supabase).
+
+```python
+from langchain_community.vectorstores import SupabaseVectorStore
+```
+

langchain_md_files/integrations/providers/symblai_nebula.mdx

@@ -0,0 +1,17 @@
+# Nebula
+
+This page covers how to use [Nebula](https://symbl.ai/nebula), [Symbl.ai](https://symbl.ai/)'s LLM, ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific Nebula wrappers.
+
+## Installation and Setup
+
+- Get an [Nebula API Key](https://info.symbl.ai/Nebula_Private_Beta.html) and set as environment variable `NEBULA_API_KEY`
+- Please see the [Nebula documentation](https://docs.symbl.ai/docs/nebula-llm) for more details.
+
+### LLM
+
+There exists an Nebula LLM wrapper, which you can access with
+```python
+from langchain_community.llms import Nebula
+llm = Nebula()
+```

langchain_md_files/integrations/providers/tair.mdx

@@ -0,0 +1,23 @@
+# Tair
+
+>[Alibaba Cloud Tair](https://www.alibabacloud.com/help/en/tair/latest/what-is-tair) is a cloud native in-memory database service 
+> developed by `Alibaba Cloud`. It provides rich data models and enterprise-grade capabilities to 
+> support your real-time online scenarios while maintaining full compatibility with open-source `Redis`. 
+> `Tair` also introduces persistent memory-optimized instances that are based on 
+> new non-volatile memory (NVM) storage medium.
+
+## Installation and Setup
+
+Install Tair Python SDK:
+
+```bash
+pip install tair
+```
+
+## Vector Store
+
+```python
+from langchain_community.vectorstores import Tair
+```
+
+See a [usage example](/docs/integrations/vectorstores/tair).

langchain_md_files/integrations/providers/telegram.mdx

@@ -0,0 +1,25 @@
+# Telegram
+
+>[Telegram Messenger](https://web.telegram.org/a/) is a globally accessible freemium, cross-platform, encrypted, cloud-based and centralized instant messaging service. The application also provides optional end-to-end encrypted chats and video calling, VoIP, file sharing and several other features.
+
+
+## Installation and Setup
+
+See [setup instructions](/docs/integrations/document_loaders/telegram).
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/telegram).
+
+```python
+from langchain_community.document_loaders import TelegramChatFileLoader
+from langchain_community.document_loaders import TelegramChatApiLoader
+```
+
+## Chat loader
+
+See a [usage example](/docs/integrations/chat_loaders/telegram).
+
+```python
+from langchain_community.chat_loaders.telegram import TelegramChatLoader
+```

langchain_md_files/integrations/providers/tencent.mdx

@@ -0,0 +1,95 @@
+# Tencent
+
+>[Tencent Holdings Ltd. (Wikipedia)](https://en.wikipedia.org/wiki/Tencent) (Chinese: 腾讯; pinyin: Téngxùn) 
+> is a Chinese multinational technology conglomerate and holding company headquartered 
+> in Shenzhen. `Tencent` is one of the highest grossing multimedia companies in the 
+> world based on revenue. It is also the world's largest company in the video game industry
+> based on its equity investments.
+ 
+
+## Chat model 
+
+>[Tencent's hybrid model API](https://cloud.tencent.com/document/product/1729) (`Hunyuan API`) 
+> implements dialogue communication, content generation, 
+> analysis and understanding, and can be widely used in various scenarios such as intelligent 
+> customer service, intelligent marketing, role playing, advertising, copyrighting, product description,
+> script creation, resume generation, article writing, code generation, data analysis, and content
+> analysis.
+
+
+For more information, see [this notebook](/docs/integrations/chat/tencent_hunyuan)
+
+```python
+from langchain_community.chat_models import ChatHunyuan
+```
+
+
+## Document Loaders
+
+### Tencent COS
+
+>[Tencent Cloud Object Storage (COS)](https://www.tencentcloud.com/products/cos) is a distributed 
+> storage service that enables you to store any amount of data from anywhere via HTTP/HTTPS protocols. 
+> `COS` has no restrictions on data structure or format. It also has no bucket size limit and 
+> partition management, making it suitable for virtually any use case, such as data delivery, 
+> data processing, and data lakes. COS provides a web-based console, multi-language SDKs and APIs, 
+> command line tool, and graphical tools. It works well with Amazon S3 APIs, allowing you to quickly 
+> access community tools and plugins.
+
+Install the Python SDK:
+
+```bash
+pip install cos-python-sdk-v5
+```
+
+#### Tencent COS Directory
+
+For more information, see [this notebook](/docs/integrations/document_loaders/tencent_cos_directory)
+
+```python
+from langchain_community.document_loaders import TencentCOSDirectoryLoader
+from qcloud_cos import CosConfig
+```
+
+#### Tencent COS File
+
+For more information, see [this notebook](/docs/integrations/document_loaders/tencent_cos_file)
+
+```python
+from langchain_community.document_loaders import TencentCOSFileLoader
+from qcloud_cos import CosConfig
+```
+
+## Vector Store
+
+### Tencent VectorDB
+
+>[Tencent Cloud VectorDB](https://www.tencentcloud.com/products/vdb) is a fully managed, 
+> self-developed enterprise-level distributed database service
+>dedicated to storing, retrieving, and analyzing multidimensional vector data. The database supports a variety of index
+>types and similarity calculation methods, and a single index supports 1 billion vectors, millions of QPS, and
+>millisecond query latency. `Tencent Cloud Vector Database` can not only provide an external knowledge base for large
+>models and improve the accuracy of large models' answers, but also be widely used in AI fields such as
+>recommendation systems, NLP services, computer vision, and intelligent customer service.
+
+Install the Python SDK:
+
+```bash
+pip install tcvectordb
+```
+
+For more information, see [this notebook](/docs/integrations/vectorstores/tencentvectordb)
+
+```python
+from langchain_community.vectorstores import TencentVectorDB
+```
+
+## Chat loader
+
+### WeChat
+
+>[WeChat](https://www.wechat.com/) or `Weixin` in Chinese is a Chinese 
+> instant messaging, social media, and mobile payment app developed by `Tencent`.
+
+See a [usage example](/docs/integrations/chat_loaders/wechat).
+

langchain_md_files/integrations/providers/tensorflow_datasets.mdx

@@ -0,0 +1,31 @@
+# TensorFlow Datasets
+
+>[TensorFlow Datasets](https://www.tensorflow.org/datasets) is a collection of datasets ready to use, 
+> with TensorFlow or other Python ML frameworks, such as Jax. All datasets are exposed 
+> as [tf.data.Datasets](https://www.tensorflow.org/api_docs/python/tf/data/Dataset), 
+> enabling easy-to-use and high-performance input pipelines. To get started see 
+> the [guide](https://www.tensorflow.org/datasets/overview) and 
+> the [list of datasets](https://www.tensorflow.org/datasets/catalog/overview#all_datasets).
+
+
+
+## Installation and Setup
+
+You need to install `tensorflow` and `tensorflow-datasets` python packages.
+
+```bash
+pip install tensorflow
+```
+
+```bash
+pip install tensorflow-dataset
+```
+
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/tensorflow_datasets).
+
+```python
+from langchain_community.document_loaders import TensorflowDatasetLoader
+```

langchain_md_files/integrations/providers/tidb.mdx

@@ -0,0 +1,38 @@
+# TiDB
+
+> [TiDB Cloud](https://www.pingcap.com/tidb-serverless), is a comprehensive Database-as-a-Service (DBaaS) solution,
+> that provides dedicated and serverless options. `TiDB Serverless` is now integrating 
+> a built-in vector search into the MySQL landscape. With this enhancement, you can seamlessly 
+> develop AI applications using `TiDB Serverless` without the need for a new database or additional 
+> technical stacks. Create a free TiDB Serverless cluster and start using the vector search feature at https://pingcap.com/ai.
+
+
+## Installation and Setup
+
+You have to get the connection details for the TiDB database. 
+Visit the [TiDB Cloud](https://tidbcloud.com/) to get the connection details.
+
+```bash
+## Document loader
+
+```python
+from langchain_community.document_loaders import TiDBLoader
+```
+
+Please refer the details [here](/docs/integrations/document_loaders/tidb).
+
+## Vector store
+
+```python
+from langchain_community.vectorstores import TiDBVectorStore
+```
+Please refer the details [here](/docs/integrations/vectorstores/tidb_vector).
+
+
+## Memory
+
+```python
+from langchain_community.chat_message_histories import TiDBChatMessageHistory
+```
+
+Please refer the details [here](/docs/integrations/memory/tidb_chat_message_history).

langchain_md_files/integrations/providers/tigergraph.mdx

@@ -0,0 +1,25 @@
+# TigerGraph
+
+>[TigerGraph](https://www.tigergraph.com/tigergraph-db/) is a natively distributed and high-performance graph database.
+> The storage of data in a graph format of vertices and edges leads to rich relationships, 
+> ideal for grouding LLM responses.
+
+## Installation and Setup
+
+Follow instructions [how to connect to the `TigerGraph` database](https://docs.tigergraph.com/pytigergraph/current/getting-started/connection).
+
+Install the Python SDK:
+
+```bash
+pip install pyTigerGraph
+```
+
+## Graph store
+
+### TigerGraph
+
+See a [usage example](/docs/integrations/graphs/tigergraph).
+
+```python
+from langchain_community.graphs import TigerGraph
+```