934adcc146427eab1ef3e2190ed8ffadfa25ab182e0dff5f3f1a80993fb577fa

langchain_md_files/integrations/providers/tigris.mdx

@@ -0,0 +1,19 @@
+# Tigris
+
+> [Tigris](https://tigrisdata.com) is an open-source Serverless NoSQL Database and Search Platform designed to simplify building high-performance vector search applications.
+> `Tigris` eliminates the infrastructure complexity of managing, operating, and synchronizing multiple tools, allowing you to focus on building great applications instead.
+
+## Installation and Setup
+
+
+```bash
+pip install tigrisdb openapi-schema-pydantic
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/tigris).
+
+```python
+from langchain_community.vectorstores import Tigris
+```

langchain_md_files/integrations/providers/tomarkdown.mdx

@@ -0,0 +1,16 @@
+# 2Markdown
+
+>[2markdown](https://2markdown.com/) service transforms website content into structured markdown files.
+
+
+## Installation and Setup
+
+We need the `API key`. See [instructions how to get it](https://2markdown.com/login).
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/tomarkdown).
+
+```python
+from langchain_community.document_loaders import ToMarkdownLoader
+```

langchain_md_files/integrations/providers/trello.mdx

@@ -0,0 +1,22 @@
+# Trello
+
+>[Trello](https://www.atlassian.com/software/trello) is a web-based project management and collaboration tool that allows individuals and teams to organize and track their tasks and projects. It provides a visual interface known as a "board" where users can create lists and cards to represent their tasks and activities.
+>The TrelloLoader allows us to load cards from a `Trello` board.
+
+
+## Installation and Setup
+
+```bash
+pip install py-trello beautifulsoup4
+```
+
+See [setup instructions](/docs/integrations/document_loaders/trello).
+
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/trello).
+
+```python
+from langchain_community.document_loaders import TrelloLoader
+```

langchain_md_files/integrations/providers/trubrics.mdx

@@ -0,0 +1,24 @@
+# Trubrics
+
+
+>[Trubrics](https://trubrics.com) is an LLM user analytics platform that lets you collect, analyse and manage user
+prompts & feedback on AI models.
+>
+>Check out [Trubrics repo](https://github.com/trubrics/trubrics-sdk) for more information on `Trubrics`.
+
+## Installation and Setup
+
+We need to install the  `trubrics` Python package:
+
+```bash
+pip install trubrics
+```
+
+
+## Callbacks
+
+See a [usage example](/docs/integrations/callbacks/trubrics).
+
+```python
+from langchain.callbacks import TrubricsCallbackHandler
+```

langchain_md_files/integrations/providers/trulens.mdx

@@ -0,0 +1,82 @@
+# TruLens
+
+>[TruLens](https://trulens.org) is an [open-source](https://github.com/truera/trulens) package that provides instrumentation and evaluation tools for large language model (LLM) based applications.
+
+This page covers how to use [TruLens](https://trulens.org) to evaluate and track LLM apps built on langchain.
+
+
+## Installation and Setup
+
+Install the `trulens-eval` python package.
+
+```bash
+pip install trulens-eval
+```
+
+## Quickstart
+
+See the integration details in the [TruLens documentation](https://www.trulens.org/trulens_eval/getting_started/quickstarts/langchain_quickstart/).
+
+### Tracking
+
+Once you've created your LLM chain, you can use TruLens for evaluation and tracking. 
+TruLens has a number of [out-of-the-box Feedback Functions](https://www.trulens.org/trulens_eval/evaluation/feedback_functions/), 
+and is also an extensible framework for LLM evaluation.
+
+Create the feedback functions:
+
+```python
+from trulens_eval.feedback import Feedback, Huggingface, 
+
+# Initialize HuggingFace-based feedback function collection class:
+hugs = Huggingface()
+openai = OpenAI()
+
+# Define a language match feedback function using HuggingFace.
+lang_match = Feedback(hugs.language_match).on_input_output()
+# By default this will check language match on the main app input and main app
+# output.
+
+# Question/answer relevance between overall question and answer.
+qa_relevance = Feedback(openai.relevance).on_input_output()
+# By default this will evaluate feedback on main app input and main app output.
+
+# Toxicity of input
+toxicity = Feedback(openai.toxicity).on_input()
+```
+
+### Chains
+
+After you've set up Feedback Function(s) for evaluating your LLM, you can wrap your application with 
+TruChain to get detailed tracing, logging and evaluation of your LLM app.
+
+Note: See code for the `chain` creation is in 
+the [TruLens documentation](https://www.trulens.org/trulens_eval/getting_started/quickstarts/langchain_quickstart/).
+
+```python
+from trulens_eval import TruChain
+
+# wrap your chain with TruChain
+truchain = TruChain(
+    chain,
+    app_id='Chain1_ChatApplication',
+    feedbacks=[lang_match, qa_relevance, toxicity]
+)
+# Note: any `feedbacks` specified here will be evaluated and logged whenever the chain is used.
+truchain("que hora es?")
+```
+
+### Evaluation
+
+Now you can explore your LLM-based application!
+
+Doing so will help you understand how your LLM application is performing at a glance. As you iterate new versions of your LLM application, you can compare their performance across all of the different quality metrics you've set up. You'll also be able to view evaluations at a record level, and explore the chain metadata for each record.
+
+```python
+from trulens_eval import Tru
+
+tru = Tru()
+tru.run_dashboard() # open a Streamlit app to explore
+```
+
+For more information on TruLens, visit [trulens.org](https://www.trulens.org/)

langchain_md_files/integrations/providers/twitter.mdx

@@ -0,0 +1,25 @@
+# Twitter
+
+>[Twitter](https://twitter.com/) is an online social media and social networking service.
+
+
+## Installation and Setup
+
+```bash
+pip install tweepy
+```
+
+We must initialize the loader with the `Twitter API` token, and we need to set up the Twitter `username`.
+
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/twitter).
+
+```python
+from langchain_community.document_loaders import TwitterTweetLoader
+```
+
+## Chat loader
+
+See a [usage example](/docs/integrations/chat_loaders/twitter).

langchain_md_files/integrations/providers/typesense.mdx

@@ -0,0 +1,22 @@
+# Typesense
+
+> [Typesense](https://typesense.org) is an open-source, in-memory search engine, that you can either 
+> [self-host](https://typesense.org/docs/guide/install-typesense.html#option-2-local-machine-self-hosting) or run 
+> on [Typesense Cloud](https://cloud.typesense.org/).
+> `Typesense` focuses on performance by storing the entire index in RAM (with a backup on disk) and also 
+> focuses on providing an out-of-the-box developer experience by simplifying available options and setting good defaults.
+
+## Installation and Setup
+
+
+```bash
+pip install typesense openapi-schema-pydantic
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/typesense).
+
+```python
+from langchain_community.vectorstores import Typesense
+```

langchain_md_files/integrations/providers/unstructured.mdx

@@ -0,0 +1,234 @@
+# Unstructured
+
+>The `unstructured` package from
+[Unstructured.IO](https://www.unstructured.io/) extracts clean text from raw source documents like
+PDFs and Word documents.
+This page covers how to use the [`unstructured`](https://github.com/Unstructured-IO/unstructured)
+ecosystem within LangChain.
+
+## Installation and Setup
+
+If you are using a loader that runs locally, use the following steps to get `unstructured` and its
+dependencies running.
+
+- For the smallest installation footprint and to take advantage of features not available in the
+  open-source `unstructured` package, install the Python SDK with `pip install unstructured-client`
+  along with `pip install langchain-unstructured` to use the `UnstructuredLoader` and partition
+  remotely against the Unstructured API. This loader lives
+  in a LangChain partner repo instead of the `langchain-community` repo and you will need an
+  `api_key`, which you can generate a free key [here](https://unstructured.io/api-key/).
+    - Unstructured's documentation for the sdk can be found here:
+      https://docs.unstructured.io/api-reference/api-services/sdk
+
+- To run everything locally, install the open-source python package with `pip install unstructured`
+  along with `pip install langchain-community` and use the same `UnstructuredLoader` as mentioned above.
+    - You can install document specific dependencies with extras, e.g. `pip install "unstructured[docx]"`.
+    - To install the dependencies for all document types, use `pip install "unstructured[all-docs]"`.
+- Install the following system dependencies if they are not already available on your system with e.g. `brew install` for Mac.
+  Depending on what document types you're parsing, you may not need all of these.
+    - `libmagic-dev` (filetype detection)
+    - `poppler-utils` (images and PDFs)
+    - `tesseract-ocr`(images and PDFs)
+    - `qpdf` (PDFs)
+    - `libreoffice` (MS Office docs)
+    - `pandoc` (EPUBs)
+- When running locally, Unstructured also recommends using Docker [by following this
+  guide](https://docs.unstructured.io/open-source/installation/docker-installation) to ensure all
+  system dependencies are installed correctly.
+
+The Unstructured API requires API keys to make requests.
+You can request an API key [here](https://unstructured.io/api-key-hosted) and start using it today!
+Checkout the README [here](https://github.com/Unstructured-IO/unstructured-api) here to get started making API calls.
+We'd love to hear your feedback, let us know how it goes in our [community slack](https://join.slack.com/t/unstructuredw-kbe4326/shared_invite/zt-1x7cgo0pg-PTptXWylzPQF9xZolzCnwQ).
+And stay tuned for improvements to both quality and performance!
+Check out the instructions
+[here](https://github.com/Unstructured-IO/unstructured-api#dizzy-instructions-for-using-the-docker-image) if you'd like to self-host the Unstructured API or run it locally.
+
+
+## Data Loaders
+
+The primary usage of `Unstructured` is in data loaders.
+
+### UnstructuredLoader
+
+See a [usage example](/docs/integrations/document_loaders/unstructured_file) to see how you can use
+this loader for both partitioning locally and remotely with the serverless Unstructured API.
+
+```python
+from langchain_unstructured import UnstructuredLoader
+```
+
+### UnstructuredCHMLoader
+
+`CHM` means `Microsoft Compiled HTML Help`.
+
+```python
+from langchain_community.document_loaders import UnstructuredCHMLoader
+```
+
+### UnstructuredCSVLoader
+
+A `comma-separated values` (`CSV`) file is a delimited text file that uses 
+a comma to separate values. Each line of the file is a data record. 
+Each record consists of one or more fields, separated by commas.
+
+See a [usage example](/docs/integrations/document_loaders/csv#unstructuredcsvloader).
+
+```python
+from langchain_community.document_loaders import UnstructuredCSVLoader
+```
+
+### UnstructuredEmailLoader
+
+See a [usage example](/docs/integrations/document_loaders/email).
+
+```python
+from langchain_community.document_loaders import UnstructuredEmailLoader
+```
+
+### UnstructuredEPubLoader
+
+[EPUB](https://en.wikipedia.org/wiki/EPUB) is an `e-book file format` that uses 
+the “.epub” file extension. The term is short for electronic publication and 
+is sometimes styled `ePub`. `EPUB` is supported by many e-readers, and compatible 
+software is available for most smartphones, tablets, and computers.
+
+See a [usage example](/docs/integrations/document_loaders/epub).
+
+```python
+from langchain_community.document_loaders import UnstructuredEPubLoader
+```
+
+### UnstructuredExcelLoader
+
+See a [usage example](/docs/integrations/document_loaders/microsoft_excel).
+
+```python
+from langchain_community.document_loaders import UnstructuredExcelLoader
+```
+
+### UnstructuredFileIOLoader
+
+See a [usage example](/docs/integrations/document_loaders/google_drive#passing-in-optional-file-loaders).
+
+```python
+from langchain_community.document_loaders import UnstructuredFileIOLoader
+```
+
+### UnstructuredHTMLLoader
+
+See a [usage example](/docs/how_to/document_loader_html).
+
+```python
+from langchain_community.document_loaders import UnstructuredHTMLLoader
+```
+
+### UnstructuredImageLoader
+
+See a [usage example](/docs/integrations/document_loaders/image).
+
+```python
+from langchain_community.document_loaders import UnstructuredImageLoader
+```
+
+### UnstructuredMarkdownLoader
+
+See a [usage example](/docs/integrations/vectorstores/starrocks).
+
+```python
+from langchain_community.document_loaders import UnstructuredMarkdownLoader
+```
+
+### UnstructuredODTLoader
+
+The `Open Document Format for Office Applications (ODF)`, also known as `OpenDocument`, 
+is an open file format for word processing documents, spreadsheets, presentations 
+and graphics and using ZIP-compressed XML files. It was developed with the aim of 
+providing an open, XML-based file format specification for office applications.
+
+See a [usage example](/docs/integrations/document_loaders/odt).
+
+```python
+from langchain_community.document_loaders import UnstructuredODTLoader
+```
+
+### UnstructuredOrgModeLoader
+
+An [Org Mode](https://en.wikipedia.org/wiki/Org-mode) document is a document editing, formatting, and organizing mode, designed for notes, planning, and authoring within the free software text editor Emacs.
+
+See a [usage example](/docs/integrations/document_loaders/org_mode).
+
+```python
+from langchain_community.document_loaders import UnstructuredOrgModeLoader
+```
+
+### UnstructuredPDFLoader
+
+See a [usage example](/docs/how_to/document_loader_pdf#using-unstructured).
+
+```python
+from langchain_community.document_loaders import UnstructuredPDFLoader
+```
+
+### UnstructuredPowerPointLoader
+
+See a [usage example](/docs/integrations/document_loaders/microsoft_powerpoint).
+
+```python
+from langchain_community.document_loaders import UnstructuredPowerPointLoader
+```
+
+### UnstructuredRSTLoader
+
+A `reStructured Text` (`RST`) file is a file format for textual data 
+used primarily in the Python programming language community for technical documentation.
+
+See a [usage example](/docs/integrations/document_loaders/rst).
+
+```python
+from langchain_community.document_loaders import UnstructuredRSTLoader
+```
+
+### UnstructuredRTFLoader
+
+See a usage example in the API documentation.
+
+```python
+from langchain_community.document_loaders import UnstructuredRTFLoader
+```
+
+### UnstructuredTSVLoader
+
+A `tab-separated values` (`TSV`) file is a simple, text-based file format for storing tabular data.
+Records are separated by newlines, and values within a record are separated by tab characters.
+
+See a [usage example](/docs/integrations/document_loaders/tsv).
+
+```python
+from langchain_community.document_loaders import UnstructuredTSVLoader
+```
+
+### UnstructuredURLLoader
+
+See a [usage example](/docs/integrations/document_loaders/url).
+
+```python
+from langchain_community.document_loaders import UnstructuredURLLoader
+```
+
+### UnstructuredWordDocumentLoader
+
+See a [usage example](/docs/integrations/document_loaders/microsoft_word#using-unstructured).
+
+```python
+from langchain_community.document_loaders import UnstructuredWordDocumentLoader
+```
+
+### UnstructuredXMLLoader
+
+See a [usage example](/docs/integrations/document_loaders/xml).
+
+```python
+from langchain_community.document_loaders import UnstructuredXMLLoader
+```
+

langchain_md_files/integrations/providers/upstash.mdx

@@ -0,0 +1,221 @@
+Upstash offers developers serverless databases and messaging
+platforms to build powerful applications without having to worry 
+about the operational complexity of running databases at scale.
+
+One significant advantage of Upstash is that their databases support HTTP and all of their SDKs use HTTP.
+This means that you can run this in serverless platforms, edge or any platform that does not support TCP connections.
+
+Currently, there are two Upstash integrations available for LangChain: 
+Upstash Vector as a vector embedding database and Upstash Redis as a cache and memory store.
+
+# Upstash Vector
+
+Upstash Vector is a serverless vector database that can be used to store and query vectors.
+
+## Installation
+
+Create a new serverless vector database at the [Upstash Console](https://console.upstash.com/vector).
+Select your preferred distance metric and dimension count according to your model.
+
+
+Install the Upstash Vector Python SDK with `pip install upstash-vector`.
+The Upstash Vector integration in langchain is a wrapper for the Upstash Vector Python SDK. That's why the `upstash-vector` package is required.
+
+## Integrations
+
+Create a `UpstashVectorStore` object using credentials from the Upstash Console.
+You also need to pass in an `Embeddings` object which can turn text into vector embeddings.
+
+```python
+from langchain_community.vectorstores.upstash import UpstashVectorStore
+import os
+
+os.environ["UPSTASH_VECTOR_REST_URL"] = "<UPSTASH_VECTOR_REST_URL>"
+os.environ["UPSTASH_VECTOR_REST_TOKEN"] = "<UPSTASH_VECTOR_REST_TOKEN>"
+
+store = UpstashVectorStore(
+    embedding=embeddings
+)
+```
+
+An alternative way of `UpstashVectorStore` is to pass `embedding=True`. This is a unique
+feature of the `UpstashVectorStore` thanks to the ability of the Upstash Vector indexes
+to have an associated embedding model. In this configuration, documents we want to insert or
+queries we want to search for are simply sent to Upstash Vector as text. In the background,
+Upstash Vector embeds these text and executes the request with these embeddings. To use this
+feature, [create an Upstash Vector index by selecting a model](https://upstash.com/docs/vector/features/embeddingmodels#using-a-model)
+and simply pass `embedding=True`:
+
+```python
+from langchain_community.vectorstores.upstash import UpstashVectorStore
+import os
+
+os.environ["UPSTASH_VECTOR_REST_URL"] = "<UPSTASH_VECTOR_REST_URL>"
+os.environ["UPSTASH_VECTOR_REST_TOKEN"] = "<UPSTASH_VECTOR_REST_TOKEN>"
+
+store = UpstashVectorStore(
+    embedding=True
+)
+```
+
+See [Upstash Vector documentation](https://upstash.com/docs/vector/features/embeddingmodels)
+for more detail on embedding models.
+
+## Namespaces
+You can use namespaces to partition your data in the index. Namespaces are useful when you want to query over huge amount of data, and you want to partition the data to make the queries faster. When you use namespaces, there won't be post-filtering on the results which will make the query results more precise.
+
+```python
+from langchain_community.vectorstores.upstash import UpstashVectorStore
+import os
+
+os.environ["UPSTASH_VECTOR_REST_URL"] = "<UPSTASH_VECTOR_REST_URL>"
+os.environ["UPSTASH_VECTOR_REST_TOKEN"] = "<UPSTASH_VECTOR_REST_TOKEN>"
+
+store = UpstashVectorStore(
+    embedding=embeddings
+    namespace="my_namespace"
+)
+```
+
+### Inserting Vectors
+
+```python
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_community.document_loaders import TextLoader
+from langchain_openai import OpenAIEmbeddings
+
+loader = TextLoader("../../modules/state_of_the_union.txt")
+documents = loader.load()
+text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+docs = text_splitter.split_documents(documents)
+
+# Create a new embeddings object
+embeddings = OpenAIEmbeddings()
+
+# Create a new UpstashVectorStore object
+store = UpstashVectorStore(
+    embedding=embeddings
+)
+
+# Insert the document embeddings into the store
+store.add_documents(docs)
+```
+
+When inserting documents, first they are embedded using the `Embeddings` object.
+
+Most embedding models can embed multiple documents at once, so the documents are batched and embedded in parallel.
+The size of the batch can be controlled using the `embedding_chunk_size` parameter.
+
+The embedded vectors are then stored in the Upstash Vector database. When they are sent, multiple vectors are batched together to reduce the number of HTTP requests.
+The size of the batch can be controlled using the `batch_size` parameter. Upstash Vector has a limit of 1000 vectors per batch in the free tier.
+
+```python
+store.add_documents(
+    documents,
+    batch_size=100,
+    embedding_chunk_size=200
+)
+```
+
+### Querying Vectors
+
+Vectors can be queried using a text query or another vector.
+
+The returned value is a list of Document objects.
+
+```python
+result = store.similarity_search(
+    "The United States of America",
+    k=5
+)
+```
+
+Or using a vector:
+
+```python
+vector = embeddings.embed_query("Hello world")
+
+result = store.similarity_search_by_vector(
+    vector,
+    k=5
+)
+```
+
+When searching, you can also utilize the `filter` parameter which will allow you to filter by metadata:
+
+```python
+result = store.similarity_search(
+    "The United States of America",
+    k=5,
+    filter="type = 'country'"
+)
+```
+
+See [Upstash Vector documentation](https://upstash.com/docs/vector/features/filtering)
+for more details on metadata filtering.
+
+### Deleting Vectors
+
+Vectors can be deleted by their IDs.
+
+```python
+store.delete(["id1", "id2"])
+```
+
+### Getting information about the store
+
+You can get information about your database like the distance metric dimension using the info function.
+
+When an insert happens, the database an indexing takes place. While this is happening new vectors can not be queried. `pendingVectorCount` represents the number of vector that are currently being indexed. 
+
+```python
+info = store.info()
+print(info)
+
+# Output:
+# {'vectorCount': 44, 'pendingVectorCount': 0, 'indexSize': 2642412, 'dimension': 1536, 'similarityFunction': 'COSINE'}
+```
+
+# Upstash Redis
+
+This page covers how to use [Upstash Redis](https://upstash.com/redis) with LangChain.
+
+## Installation and Setup
+- Upstash Redis Python SDK can be installed with `pip install upstash-redis`
+- A globally distributed, low-latency and highly available database can be created at the [Upstash Console](https://console.upstash.com)
+
+
+## Integrations
+All of Upstash-LangChain integrations are based on `upstash-redis` Python SDK being utilized as wrappers for LangChain.
+This SDK utilizes Upstash Redis DB by giving UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN parameters from the console.
+
+
+### Cache
+
+[Upstash Redis](https://upstash.com/redis) can be used as a cache for LLM prompts and responses.
+
+To import this cache:
+```python
+from langchain.cache import UpstashRedisCache
+```
+
+To use with your LLMs:
+```python
+import langchain
+from upstash_redis import Redis
+
+URL = "<UPSTASH_REDIS_REST_URL>"
+TOKEN = "<UPSTASH_REDIS_REST_TOKEN>"
+
+langchain.llm_cache = UpstashRedisCache(redis_=Redis(url=URL, token=TOKEN))
+```
+
+### Memory
+
+See a [usage example](/docs/integrations/memory/upstash_redis_chat_message_history).
+
+```python
+from langchain_community.chat_message_histories import (
+    UpstashRedisChatMessageHistory,
+)
+```

langchain_md_files/integrations/providers/usearch.mdx

@@ -0,0 +1,25 @@
+# USearch
+>[USearch](https://unum-cloud.github.io/usearch/) is a Smaller & Faster Single-File Vector Search Engine.
+
+>`USearch's` base functionality is identical to `FAISS`, and the interface should look 
+> familiar if you have ever investigated Approximate Nearest Neighbors search. 
+> `USearch` and `FAISS` both employ `HNSW` algorithm, but they differ significantly 
+> in their design principles. `USearch` is compact and broadly compatible with FAISS without 
+> sacrificing performance, with a primary focus on user-defined metrics and fewer dependencies.
+> 
+## Installation and Setup
+
+We need to install `usearch` python package.
+
+```bash
+pip install usearch
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/usearch).
+
+```python
+from langchain_community.vectorstores import USearch
+```
+

langchain_md_files/integrations/providers/vdms.mdx

@@ -0,0 +1,62 @@
+# VDMS
+
+> [VDMS](https://github.com/IntelLabs/vdms/blob/master/README.md) is a storage solution for efficient access
+> of big-”visual”-data that aims to achieve cloud scale by searching for relevant visual data via visual metadata
+> stored as a graph and enabling machine friendly enhancements to visual data for faster access.
+
+## Installation and Setup
+
+### Install Client
+
+```bash
+pip install vdms
+```
+
+### Install Database
+
+There are two ways to get started with VDMS:
+
+#### Install VDMS on your local machine via docker
+```bash
+    docker run -d -p 55555:55555 intellabs/vdms:latest
+```
+
+#### Install VDMS directly on your local machine
+Please see [installation instructions](https://github.com/IntelLabs/vdms/blob/master/INSTALL.md).
+
+
+
+## VectorStore
+
+The vector store is a simple wrapper around VDMS. It provides a simple interface to store and retrieve data.
+
+```python
+from langchain_community.document_loaders import TextLoader
+from langchain.text_splitter import CharacterTextSplitter
+
+loader = TextLoader("./state_of_the_union.txt")
+documents = loader.load()
+text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=0)
+docs = text_splitter.split_documents(documents)
+
+from langchain_community.vectorstores import VDMS
+from langchain_community.vectorstores.vdms import VDMS_Client
+from langchain_huggingface import HuggingFaceEmbeddings
+
+client = VDMS_Client("localhost", 55555)
+vectorstore = VDMS.from_documents(
+    docs,
+    client=client,
+    collection_name="langchain-demo",
+    embedding_function=HuggingFaceEmbeddings(),
+    engine="FaissFlat"
+    distance_strategy="L2",
+)
+
+query = "What did the president say about Ketanji Brown Jackson"
+results = vectorstore.similarity_search(query)
+```
+
+For a more detailed walkthrough of the VDMS wrapper, see [this notebook](/docs/integrations/vectorstores/vdms)
+
+

langchain_md_files/integrations/providers/vectara/index.mdx

@@ -0,0 +1,182 @@
+# Vectara
+
+>[Vectara](https://vectara.com/) provides a Trusted Generative AI platform, allowing organizations to rapidly create a ChatGPT-like experience (an AI assistant) 
+> which is grounded in the data, documents, and knowledge that they have (technically, it is Retrieval-Augmented-Generation-as-a-service).
+
+**Vectara Overview:**
+`Vectara` is RAG-as-a-service, providing all the components of RAG behind an easy-to-use API, including:
+1. A way to extract text from files (PDF, PPT, DOCX, etc)
+2. ML-based chunking that provides state of the art performance.
+3. The [Boomerang](https://vectara.com/how-boomerang-takes-retrieval-augmented-generation-to-the-next-level-via-grounded-generation/) embeddings model.
+4. Its own internal vector database where text chunks and embedding vectors are stored.
+5. A query service that automatically encodes the query into embedding, and retrieves the most relevant text segments
+(including support for [Hybrid Search](https://docs.vectara.com/docs/api-reference/search-apis/lexical-matching) and 
+[MMR](https://vectara.com/get-diverse-results-and-comprehensive-summaries-with-vectaras-mmr-reranker/))
+7. An LLM to for creating a [generative summary](https://docs.vectara.com/docs/learn/grounded-generation/grounded-generation-overview), based on the retrieved documents (context), including citations.
+
+For more information:
+- [Documentation](https://docs.vectara.com/docs/)
+- [API Playground](https://docs.vectara.com/docs/rest-api/)
+- [Quickstart](https://docs.vectara.com/docs/quickstart)
+
+## Installation and Setup
+
+To use `Vectara` with LangChain no special installation steps are required. 
+To get started, [sign up](https://vectara.com/integrations/langchain) for a free Vectara account (if you don't already have one), 
+and follow the [quickstart](https://docs.vectara.com/docs/quickstart) guide to create a corpus and an API key. 
+Once you have these, you can provide them as arguments to the Vectara `vectorstore`, or you can set them as environment variables.
+
+- export `VECTARA_CUSTOMER_ID`="your_customer_id"
+- export `VECTARA_CORPUS_ID`="your_corpus_id"
+- export `VECTARA_API_KEY`="your-vectara-api-key"
+
+## Vectara as a Vector Store
+
+There exists a wrapper around the Vectara platform, allowing you to use it as a `vectorstore` in LangChain:
+
+To import this vectorstore:
+```python
+from langchain_community.vectorstores import Vectara
+```
+
+To create an instance of the Vectara vectorstore:
+```python
+vectara = Vectara(
+    vectara_customer_id=customer_id, 
+    vectara_corpus_id=corpus_id, 
+    vectara_api_key=api_key
+)
+```
+The `customer_id`, `corpus_id` and `api_key` are optional, and if they are not supplied will be read from 
+the environment variables `VECTARA_CUSTOMER_ID`, `VECTARA_CORPUS_ID` and `VECTARA_API_KEY`, respectively.
+
+### Adding Texts or Files
+
+After you have the vectorstore, you can `add_texts` or `add_documents` as per the standard `VectorStore` interface, for example:
+
+```python
+vectara.add_texts(["to be or not to be", "that is the question"])
+```
+
+Since Vectara supports file-upload in the platform, we also added the ability to upload files (PDF, TXT, HTML, PPT, DOC, etc) directly. 
+When using this method, each file is uploaded directly to the Vectara backend, processed and chunked optimally there, so you don't have to use the LangChain document loader or chunking mechanism.
+
+As an example:
+
+```python
+vectara.add_files(["path/to/file1.pdf", "path/to/file2.pdf",...])
+```
+
+Of course you do not have to add any data, and instead just connect to an existing Vectara corpus where data may already be indexed.
+
+### Querying the VectorStore
+
+To query the Vectara vectorstore, you can use the `similarity_search` method (or `similarity_search_with_score`), which takes a query string and returns a list of results:
+```python
+results = vectara.similarity_search_with_score("what is LangChain?")
+```
+The results are returned as a list of relevant documents, and a relevance score of each document.
+
+In this case, we used the default retrieval parameters, but you can also specify the following additional arguments in `similarity_search` or `similarity_search_with_score`:
+- `k`: number of results to return (defaults to 5)
+- `lambda_val`: the [lexical matching](https://docs.vectara.com/docs/api-reference/search-apis/lexical-matching) factor for hybrid search (defaults to 0.025)
+- `filter`: a [filter](https://docs.vectara.com/docs/common-use-cases/filtering-by-metadata/filter-overview) to apply to the results (default None)
+- `n_sentence_context`: number of sentences to include before/after the actual matching segment when returning results. This defaults to 2.
+- `rerank_config`: can be used to specify reranker for thr results
+   - `reranker`: mmr, rerank_multilingual_v1 or none. Note that "rerank_multilingual_v1" is a Scale only feature
+   - `rerank_k`: number of results to use for reranking
+   - `mmr_diversity_bias`: 0 = no diversity, 1 = full diversity. This is the lambda parameter in the MMR formula and is in the range 0...1
+
+To get results without the relevance score, you can simply use the 'similarity_search' method:
+```python   
+results = vectara.similarity_search("what is LangChain?")
+```
+
+## Vectara for Retrieval Augmented Generation (RAG)
+
+Vectara provides a full RAG pipeline, including generative summarization. To use it as a complete RAG solution, you can use the `as_rag` method.
+There are a few additional parameters that can be specified in the `VectaraQueryConfig` object to control retrieval and summarization:
+* k: number of results to return
+* lambda_val: the lexical matching factor for hybrid search
+* summary_config (optional): can be used to request an LLM summary in RAG
+   - is_enabled: True or False
+   - max_results: number of results to use for summary generation
+   - response_lang: language of the response summary, in ISO 639-2 format (e.g. 'en', 'fr', 'de', etc)
+* rerank_config (optional): can be used to specify Vectara Reranker of the results
+   - reranker: mmr, rerank_multilingual_v1 or none
+   - rerank_k: number of results to use for reranking
+   - mmr_diversity_bias: 0 = no diversity, 1 = full diversity. 
+     This is the lambda parameter in the MMR formula and is in the range 0...1
+
+For example:
+
+```python
+summary_config = SummaryConfig(is_enabled=True, max_results=7, response_lang='eng')
+rerank_config = RerankConfig(reranker="mmr", rerank_k=50, mmr_diversity_bias=0.2)
+config = VectaraQueryConfig(k=10, lambda_val=0.005, rerank_config=rerank_config, summary_config=summary_config)
+```
+Then you can use the `as_rag` method to create a RAG pipeline:
+
+```python
+query_str = "what did Biden say?"
+
+rag = vectara.as_rag(config)
+rag.invoke(query_str)['answer']
+```
+
+The `as_rag` method returns a `VectaraRAG` object, which behaves just like any LangChain Runnable, including the `invoke` or `stream` methods.
+
+## Vectara Chat
+
+The RAG functionality can be used to create a chatbot. For example, you can create a simple chatbot that responds to user input:
+
+```python
+summary_config = SummaryConfig(is_enabled=True, max_results=7, response_lang='eng')
+rerank_config = RerankConfig(reranker="mmr", rerank_k=50, mmr_diversity_bias=0.2)
+config = VectaraQueryConfig(k=10, lambda_val=0.005, rerank_config=rerank_config, summary_config=summary_config)
+
+query_str = "what did Biden say?"
+bot = vectara.as_chat(config)
+bot.invoke(query_str)['answer']
+```
+
+The main difference is the following: with `as_chat` Vectara internally tracks the chat history and conditions each response on the full chat history.
+There is no need to keep that history locally to LangChain, as Vectara will manage it internally.
+
+## Vectara as a LangChain retriever only
+
+If you want to use Vectara as a retriever only, you can use the `as_retriever` method, which returns a `VectaraRetriever` object.
+```python
+retriever = vectara.as_retriever(config=config)
+retriever.invoke(query_str)
+```
+
+Like with as_rag, you provide a `VectaraQueryConfig` object to control the retrieval parameters.
+In most cases you would not enable the summary_config, but it is left as an option for backwards compatibility. 
+If no summary is requested, the response will be a list of relevant documents, each with a relevance score.
+If a summary is requested, the response will be a list of relevant documents as before, plus an additional document that includes the generative summary.
+
+## Hallucination Detection score
+
+Vectara created [HHEM](https://huggingface.co/vectara/hallucination_evaluation_model) - an open source model that can be used to evaluate RAG responses for factual consistency. 
+As part of the Vectara RAG, the "Factual Consistency Score" (or FCS), which is an improved version of the open source HHEM is made available via the API. 
+This is automatically included in the output of the RAG pipeline
+
+```python
+summary_config = SummaryConfig(is_enabled=True, max_results=7, response_lang='eng')
+rerank_config = RerankConfig(reranker="mmr", rerank_k=50, mmr_diversity_bias=0.2)
+config = VectaraQueryConfig(k=10, lambda_val=0.005, rerank_config=rerank_config, summary_config=summary_config)
+
+rag = vectara.as_rag(config)
+resp = rag.invoke(query_str)
+print(resp['answer'])
+print(f"Vectara FCS = {resp['fcs']}")
+```
+
+## Example Notebooks
+
+For a more detailed examples of using Vectara with LangChain, see the following example notebooks:
+* [this notebook](/docs/integrations/vectorstores/vectara) shows how to use Vectara: with full RAG or just as a retriever.
+* [this notebook](/docs/integrations/retrievers/self_query/vectara_self_query) shows the self-query capability with Vectara.
+* [this notebook](/docs/integrations/providers/vectara/vectara_chat) shows how to build a chatbot with Langchain and Vectara
+

langchain_md_files/integrations/providers/vespa.mdx

@@ -0,0 +1,21 @@
+# Vespa
+
+>[Vespa](https://vespa.ai/) is a fully featured search engine and vector database. 
+> It supports vector search (ANN), lexical search, and search in structured data, all in the same query.
+ 
+## Installation and Setup
+
+
+```bash
+pip install pyvespa
+```
+
+
+
+## Retriever
+
+See a [usage example](/docs/integrations/retrievers/vespa).
+
+```python
+from langchain.retrievers import VespaRetriever
+```

langchain_md_files/integrations/providers/vlite.mdx

@@ -0,0 +1,31 @@
+# vlite
+
+This page covers how to use [vlite](https://github.com/sdan/vlite) within LangChain. vlite is a simple and fast vector database for storing and retrieving embeddings.
+
+## Installation and Setup
+
+To install vlite, run the following command:
+
+```bash
+pip install vlite
+```
+
+For PDF OCR support, install the `vlite[ocr]` extra:
+
+```bash
+pip install vlite[ocr]
+```
+
+## VectorStore
+
+vlite provides a wrapper around its vector database, allowing you to use it as a vectorstore for semantic search and example selection.
+
+To import the vlite vectorstore:
+
+```python
+from langchain_community.vectorstores import vlite
+```
+
+### Usage
+
+For a more detailed walkthrough of the vlite wrapper, see [this notebook](/docs/integrations/vectorstores/vlite).

langchain_md_files/integrations/providers/voyageai.mdx

@@ -0,0 +1,32 @@
+# VoyageAI
+
+All functionality related to VoyageAI
+
+>[VoyageAI](https://www.voyageai.com/) Voyage AI builds embedding models, customized for your domain and company, for better retrieval quality.
+
+## Installation and Setup
+
+Install the integration package with
+```bash
+pip install langchain-voyageai
+```
+
+Get a VoyageAI API key and set it as an environment variable (`VOYAGE_API_KEY`)
+
+
+## Text Embedding Model
+
+See a [usage example](/docs/integrations/text_embedding/voyageai)
+
+```python
+from langchain_voyageai import VoyageAIEmbeddings
+```
+
+
+## Reranking
+
+See a [usage example](/docs/integrations/document_transformers/voyageai-reranker)
+
+```python
+from langchain_voyageai import VoyageAIRerank
+```

langchain_md_files/integrations/providers/weather.mdx

@@ -0,0 +1,21 @@
+# Weather
+
+>[OpenWeatherMap](https://openweathermap.org/) is an open-source weather service provider.
+
+
+
+## Installation and Setup
+
+```bash
+pip install pyowm
+```
+
+We must set up the `OpenWeatherMap API token`.
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/weather).
+
+```python
+from langchain_community.document_loaders import WeatherDataLoader
+```

langchain_md_files/integrations/providers/weaviate.mdx

@@ -0,0 +1,38 @@
+# Weaviate
+
+>[Weaviate](https://weaviate.io/) is an open-source vector database. It allows you to store data objects and vector embeddings from
+>your favorite ML models, and scale seamlessly into billions of data objects.
+
+
+What is `Weaviate`?
+- Weaviate is an open-source ​database of the type ​vector search engine.
+- Weaviate allows you to store JSON documents in a class property-like fashion while attaching machine learning vectors to these documents to represent them in vector space.
+- Weaviate can be used stand-alone (aka bring your vectors) or with a variety of modules that can do the vectorization for you and extend the core capabilities.
+- Weaviate has a GraphQL-API to access your data easily.
+- We aim to bring your vector search set up to production to query in mere milliseconds (check our [open-source benchmarks](https://weaviate.io/developers/weaviate/current/benchmarks/) to see if Weaviate fits your use case).
+- Get to know Weaviate in the [basics getting started guide](https://weaviate.io/developers/weaviate/current/core-knowledge/basics.html) in under five minutes.
+
+**Weaviate in detail:**
+
+`Weaviate` is a low-latency vector search engine with out-of-the-box support for different media types (text, images, etc.). It offers Semantic Search, Question-Answer Extraction, Classification, Customizable Models (PyTorch/TensorFlow/Keras), etc. Built from scratch in Go, Weaviate stores both objects and vectors, allowing for combining vector search with structured filtering and the fault tolerance of a cloud-native database. It is all accessible through GraphQL, REST, and various client-side programming languages.
+
+## Installation and Setup
+
+Install the Python SDK:
+
+```bash
+pip install langchain-weaviate
+```
+
+
+## Vector Store
+
+There exists a wrapper around `Weaviate` indexes, allowing you to use it as a vectorstore,
+whether for semantic search or example selection.
+
+To import this vectorstore:
+```python
+from langchain_weaviate import WeaviateVectorStore
+```
+
+For a more detailed walkthrough of the Weaviate wrapper, see [this notebook](/docs/integrations/vectorstores/weaviate)

langchain_md_files/integrations/providers/whatsapp.mdx

@@ -0,0 +1,18 @@
+# WhatsApp
+
+>[WhatsApp](https://www.whatsapp.com/) (also called `WhatsApp Messenger`) is a freeware, cross-platform, centralized instant messaging (IM) and voice-over-IP (VoIP) service. It allows users to send text and voice messages, make voice and video calls, and share images, documents, user locations, and other content.
+
+
+## Installation and Setup
+
+There isn't any special setup for it.
+
+
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/whatsapp_chat).
+
+```python
+from langchain_community.document_loaders import WhatsAppChatLoader
+```

langchain_md_files/integrations/providers/wikipedia.mdx

@@ -0,0 +1,28 @@
+# Wikipedia
+
+>[Wikipedia](https://wikipedia.org/) is a multilingual free online encyclopedia written and maintained by a community of volunteers, known as Wikipedians, through open collaboration and using a wiki-based editing system called MediaWiki. `Wikipedia` is the largest and most-read reference work in history.
+
+
+## Installation and Setup
+
+```bash
+pip install wikipedia
+```
+
+
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/wikipedia).
+
+```python
+from langchain_community.document_loaders import WikipediaLoader
+```
+
+## Retriever
+
+See a [usage example](/docs/integrations/retrievers/wikipedia).
+
+```python
+from langchain.retrievers import WikipediaRetriever
+```

langchain_md_files/integrations/providers/wolfram_alpha.mdx

@@ -0,0 +1,39 @@
+# Wolfram Alpha
+
+>[WolframAlpha](https://en.wikipedia.org/wiki/WolframAlpha) is an answer engine developed by `Wolfram Research`. 
+> It answers factual queries by computing answers from externally sourced data.
+
+This page covers how to use the `Wolfram Alpha API` within LangChain.
+
+## Installation and Setup
+- Install requirements with 
+```bash
+pip install wolframalpha
+```
+- Go to wolfram alpha and sign up for a developer account [here](https://developer.wolframalpha.com/)
+- Create an app and get your `APP ID`
+- Set your APP ID as an environment variable `WOLFRAM_ALPHA_APPID`
+
+
+## Wrappers
+
+### Utility
+
+There exists a WolframAlphaAPIWrapper utility which wraps this API. To import this utility:
+
+```python
+from langchain_community.utilities.wolfram_alpha import WolframAlphaAPIWrapper
+```
+
+For a more detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/wolfram_alpha).
+
+### 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(["wolfram-alpha"])
+```
+
+For more information on tools, see [this page](/docs/how_to/tools_builtin).

langchain_md_files/integrations/providers/writer.mdx

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

langchain_md_files/integrations/providers/xata.mdx

@@ -0,0 +1,36 @@
+# Xata
+
+> [Xata](https://xata.io) is a serverless data platform, based on `PostgreSQL`. 
+> It provides a Python SDK for interacting with your database, and a UI 
+> for managing your data.
+> `Xata` has a native vector type, which can be added to any table, and 
+> supports similarity search. LangChain inserts vectors directly to `Xata`, 
+> and queries it for the nearest neighbors of a given vector, so that you can
+> use all the LangChain Embeddings integrations with `Xata`.
+
+
+## Installation and Setup
+
+
+We need to install `xata` python package.
+
+```bash
+pip install xata==1.0.0a7 
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/xata).
+
+```python
+from langchain_community.vectorstores import XataVectorStore
+```
+
+## Memory
+
+See a [usage example](/docs/integrations/memory/xata_chat_message_history).
+
+```python
+from langchain_community.chat_message_histories import XataChatMessageHistory
+```
+

langchain_md_files/integrations/providers/xinference.mdx

@@ -0,0 +1,102 @@
+# Xorbits Inference (Xinference)
+
+This page demonstrates how to use [Xinference](https://github.com/xorbitsai/inference)
+with LangChain.
+
+`Xinference` is a powerful and versatile library designed to serve LLMs, 
+speech recognition models, and multimodal models, even on your laptop. 
+With Xorbits Inference, you can effortlessly deploy and serve your or 
+state-of-the-art built-in models using just a single command.
+
+## Installation and Setup
+
+Xinference can be installed via pip from PyPI: 
+
+```bash
+pip install "xinference[all]"
+```
+
+## LLM
+
+Xinference supports various models compatible with GGML, including chatglm, baichuan, whisper, 
+vicuna, and orca. To view the builtin models, run the command:
+
+```bash
+xinference list --all
+```
+
+
+### Wrapper for Xinference
+
+You can start a local instance of Xinference by running:
+
+```bash
+xinference
+```
+
+You can also deploy Xinference in a distributed cluster. To do so, first start an Xinference supervisor
+on the server you want to run it:
+
+```bash
+xinference-supervisor -H "${supervisor_host}"
+```
+
+
+Then, start the Xinference workers on each of the other servers where you want to run them on:
+
+```bash
+xinference-worker -e "http://${supervisor_host}:9997"
+```
+
+You can also start a local instance of Xinference by running:
+
+```bash
+xinference
+```
+
+Once Xinference is running, an endpoint will be accessible for model management via CLI or 
+Xinference client. 
+
+For local deployment, the endpoint will be http://localhost:9997. 
+
+
+For cluster deployment, the endpoint will be http://${supervisor_host}:9997.
+
+
+Then, you need to launch a model. You can specify the model names and other attributes 
+including model_size_in_billions and quantization. You can use command line interface (CLI) to 
+do it. For example, 
+
+```bash
+xinference launch -n orca -s 3 -q q4_0
+```
+
+A model uid will be returned.
+
+Example usage:
+
+```python
+from langchain_community.llms import Xinference
+
+llm = Xinference(
+    server_url="http://0.0.0.0:9997",
+    model_uid = {model_uid} # replace model_uid with the model UID return from launching the model
+)
+
+llm(
+    prompt="Q: where can we visit in the capital of France? A:",
+    generate_config={"max_tokens": 1024, "stream": True},
+)
+
+```
+
+### Usage
+
+For more information and detailed examples, refer to the
+[example for xinference LLMs](/docs/integrations/llms/xinference)
+
+### Embeddings
+
+Xinference also supports embedding queries and documents. See
+[example for xinference embeddings](/docs/integrations/text_embedding/xinference) 
+for a more detailed demo.

langchain_md_files/integrations/providers/yandex.mdx

@@ -0,0 +1,33 @@
+# Yandex
+
+All functionality related to Yandex Cloud
+
+>[Yandex Cloud](https://cloud.yandex.com/en/) is a public cloud platform. 
+
+## Installation and Setup
+
+Yandex Cloud SDK can be installed via pip from PyPI: 
+
+```bash
+pip install yandexcloud
+```
+
+## LLMs
+
+### YandexGPT
+
+See a [usage example](/docs/integrations/llms/yandex).
+
+```python
+from langchain_community.llms import YandexGPT
+```
+
+## Chat models
+
+### YandexGPT
+
+See a [usage example](/docs/integrations/chat/yandex).
+
+```python
+from langchain_community.chat_models import ChatYandexGPT
+```

langchain_md_files/integrations/providers/yeagerai.mdx

@@ -0,0 +1,43 @@
+# Yeager.ai
+
+This page covers how to use [Yeager.ai](https://yeager.ai) to generate LangChain tools and agents.
+
+## What is Yeager.ai?
+Yeager.ai is an ecosystem designed to simplify the process of creating AI agents and tools. 
+
+It features yAgents, a No-code LangChain Agent Builder, which enables users to build, test, and deploy AI solutions with ease. Leveraging the LangChain framework, yAgents allows seamless integration with various language models and resources, making it suitable for developers, researchers, and AI enthusiasts across diverse applications.
+
+## yAgents
+Low code generative agent designed to help you build, prototype, and deploy Langchain tools with ease. 
+
+### How to use?
+```
+pip install yeagerai-agent
+yeagerai-agent
+```
+Go to http://127.0.0.1:7860
+
+This will install the necessary dependencies and set up yAgents on your system. After the first run, yAgents will create a .env file where you can input your OpenAI API key. You can do the same directly from the Gradio interface under the tab "Settings".
+
+`OPENAI_API_KEY=<your_openai_api_key_here>`
+
+We recommend using GPT-4,. However, the tool can also work with GPT-3 if the problem is broken down sufficiently.
+
+### Creating and Executing Tools with yAgents
+yAgents makes it easy to create and execute AI-powered tools. Here's a brief overview of the process:
+1. Create a tool: To create a tool, provide a natural language prompt to yAgents. The prompt should clearly describe the tool's purpose and functionality. For example:
+`create a tool that returns the n-th prime number`
+
+2. Load the tool into the toolkit: To load a tool into yAgents, simply provide a command to yAgents that says so. For example:
+`load the tool that you just created it into your toolkit`
+
+3. Execute the tool: To run a tool or agent, simply provide a command to yAgents that includes the name of the tool and any required parameters. For example:
+`generate the 50th prime number`
+
+You can see a video of how it works [here](https://www.youtube.com/watch?v=KA5hCM3RaWE).
+
+As you become more familiar with yAgents, you can create more advanced tools and agents to automate your work and enhance your productivity.
+
+For more information, see [yAgents' Github](https://github.com/yeagerai/yeagerai-agent) or our [docs](https://yeagerai.gitbook.io/docs/general/welcome-to-yeager.ai) 
+
+

langchain_md_files/integrations/providers/yi.mdx

@@ -0,0 +1,23 @@
+# 01.AI
+
+>[01.AI](https://www.lingyiwanwu.com/en), founded by Dr. Kai-Fu Lee, is a global company at the forefront of AI 2.0. They offer cutting-edge large language models, including the Yi series, which range from 6B to hundreds of billions of parameters. 01.AI also provides multimodal models, an open API platform, and open-source options like Yi-34B/9B/6B and Yi-VL.
+
+## Installation and Setup
+
+Register and get an API key from either the China site [here](https://platform.lingyiwanwu.com/apikeys) or the global site [here](https://platform.01.ai/apikeys).
+
+## LLMs
+
+See a [usage example](/docs/integrations/llms/yi).
+
+```python
+from langchain_community.llms import YiLLM
+```
+
+## Chat models
+
+See a [usage example](/docs/integrations/chat/yi).
+
+```python
+from langchain_community.chat_models import ChatYi
+```

langchain_md_files/integrations/providers/youtube.mdx

@@ -0,0 +1,22 @@
+# YouTube
+
+>[YouTube](https://www.youtube.com/) is an online video sharing and social media platform by Google.
+> We download the `YouTube` transcripts and video information.
+
+## Installation and Setup
+
+```bash
+pip install youtube-transcript-api
+pip install pytube
+```
+See a [usage example](/docs/integrations/document_loaders/youtube_transcript).
+
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/youtube_transcript).
+
+```python
+from langchain_community.document_loaders import YoutubeLoader
+from langchain_community.document_loaders import GoogleApiYoutubeLoader
+```

langchain_md_files/integrations/providers/zep.mdx

@@ -0,0 +1,120 @@
+# Zep
+> Recall, understand, and extract data from chat histories. Power personalized AI experiences.
+
+>[Zep](https://www.getzep.com) is a long-term memory service for AI Assistant apps.
+> With Zep, you can provide AI assistants with the ability to recall past conversations, no matter how distant,
+> while also reducing hallucinations, latency, and cost.
+
+## How Zep works
+
+Zep persists and recalls chat histories, and automatically generates summaries and other artifacts from these chat histories.
+It also embeds messages and summaries, enabling you to search Zep for relevant context from past conversations.
+Zep does all of this asynchronously, ensuring these operations don't impact your user's chat experience.
+Data is persisted to database, allowing you to scale out when growth demands.
+
+Zep also provides a simple, easy to use abstraction for document vector search called Document Collections.
+This is designed to complement Zep's core memory features, but is not designed to be a general purpose vector database.
+
+Zep allows you to be more intentional about constructing your prompt:
+- automatically adding a few recent messages, with the number customized for your app;
+- a summary of recent conversations prior to the messages above;
+- and/or contextually relevant summaries or messages surfaced from the entire chat session.
+- and/or relevant Business data from Zep Document Collections.
+
+## What is Zep Cloud?
+[Zep Cloud](https://www.getzep.com) is a managed service with Zep Open Source at its core.
+In addition to Zep Open Source's memory management features, Zep Cloud offers:
+- **Fact Extraction**: Automatically build fact tables from conversations, without having to define a data schema upfront.
+- **Dialog Classification**: Instantly and accurately classify chat dialog. Understand user intent and emotion, segment users, and more. Route chains based on semantic context, and trigger events.
+- **Structured Data Extraction**: Quickly extract business data from chat conversations using a schema you define. Understand what your Assistant should ask for next in order to complete its task.
+
+
+
+## Zep Open Source
+Zep offers an open source version with a self-hosted option.
+Please refer to the [Zep Open Source](https://github.com/getzep/zep) repo for more information.
+You can also find Zep Open Source compatible [Retriever](/docs/integrations/retrievers/zep_memorystore), [Vector Store](/docs/integrations/vectorstores/zep) and [Memory](/docs/integrations/memory/zep_memory) examples
+
+## Zep Cloud Installation and Setup
+
+[Zep Cloud Docs](https://help.getzep.com)
+
+1. Install the Zep Cloud SDK:
+
+```bash
+pip install zep_cloud
+```
+or
+```bash
+poetry add zep_cloud
+```
+
+## Memory
+
+Zep's Memory API persists your users' chat history and metadata to a [Session](https://help.getzep.com/chat-history-memory/sessions), enriches the memory, and
+enables vector similarity search over historical chat messages and dialog summaries.
+
+Zep offers several approaches to populating prompts with context from historical conversations.
+
+### Perpetual Memory
+This is the default memory type.
+Salient facts from the dialog are extracted and stored in a Fact Table.
+This is updated in real-time as new messages are added to the Session.
+Every time you call the Memory API to get a Memory, Zep returns the Fact Table, the most recent messages (per your Message Window setting), and a summary of the most recent messages prior to the Message Window.
+The combination of the Fact Table, summary, and the most recent messages in a prompts provides both factual context and nuance to the LLM.
+
+### Summary Retriever Memory
+Returns the most recent messages and a summary of past messages relevant to the current conversation,
+enabling you to provide your Assistant with helpful context from past conversations
+
+### Message Window Buffer Memory
+Returns the most recent N messages from the current conversation.
+
+Additionally, Zep enables vector similarity searches for Messages or Summaries stored within its system.
+
+This feature lets you populate prompts with past conversations that are contextually similar to a specific query,
+organizing the results by a similarity Score.
+
+`ZepCloudChatMessageHistory` and `ZepCloudMemory` classes can be imported to interact with Zep Cloud APIs.
+
+`ZepCloudChatMessageHistory` is compatible with `RunnableWithMessageHistory`.
+```python
+from langchain_community.chat_message_histories import ZepCloudChatMessageHistory
+```
+
+See a [Perpetual Memory Example here](/docs/integrations/memory/zep_cloud_chat_message_history).
+
+You can use `ZepCloudMemory` together with agents that support Memory.
+```python
+from langchain_community.memory import ZepCloudMemory
+```
+
+See a [Memory RAG Example here](/docs/integrations/memory/zep_memory_cloud).
+
+## Retriever
+
+Zep's Memory Retriever is a LangChain Retriever that enables you to retrieve messages from a Zep Session and use them to construct your prompt.
+
+The Retriever supports searching over both individual messages and summaries of conversations. The latter is useful for providing rich, but succinct context to the LLM as to relevant past conversations.
+
+Zep's Memory Retriever supports both similarity search and [Maximum Marginal Relevance (MMR) reranking](https://help.getzep.com/working-with-search#how-zeps-mmr-re-ranking-works). MMR search is useful for ensuring that the retrieved messages are diverse and not too similar to each other
+
+See a [usage example](/docs/integrations/retrievers/zep_cloud_memorystore).
+
+```python
+from langchain_community.retrievers import ZepCloudRetriever
+```
+
+## Vector store
+
+Zep's [Document VectorStore API](https://help.getzep.com/document-collections) enables you to store and retrieve documents using vector similarity search. Zep doesn't require you to understand
+distance functions, types of embeddings, or indexing best practices. You just pass in your chunked documents, and Zep handles the rest.
+
+Zep supports both similarity search and [Maximum Marginal Relevance (MMR) reranking](https://help.getzep.com/working-with-search#how-zeps-mmr-re-ranking-works).
+MMR search is useful for ensuring that the retrieved documents are diverse and not too similar to each other.
+
+```python
+from langchain_community.vectorstores import ZepCloudVectorStore
+```
+
+See a [usage example](/docs/integrations/vectorstores/zep_cloud).

langchain_md_files/integrations/providers/zhipuai.mdx

@@ -0,0 +1,18 @@
+# Zhipu AI
+
+>[Zhipu AI](https://www.zhipuai.cn/en/aboutus), originating from the technological 
+> advancements of `Tsinghua University's Computer Science Department`, 
+> is an artificial intelligence company with the mission of teaching machines 
+> to think like humans. Its world-leading AI team has developed the cutting-edge 
+> large language and multimodal models and built the high-precision billion-scale 
+> knowledge graphs, the combination of which uniquely empowers us to create a powerful 
+> data- and knowledge-driven cognitive engine towards artificial general intelligence.
+
+
+## Chat models
+
+See a [usage example](/docs/integrations/chat/zhipuai).
+
+```python
+from langchain_community.chat_models import ChatZhipuAI
+```

langchain_md_files/integrations/providers/zilliz.mdx

@@ -0,0 +1,22 @@
+# Zilliz
+
+>[Zilliz Cloud](https://zilliz.com/doc/quick_start) is a fully managed service on cloud for `LF AI Milvus®`,
+
+
+## Installation and Setup
+
+Install the Python SDK:
+```bash
+pip install pymilvus
+```
+
+## Vectorstore
+
+A wrapper around Zilliz indexes allows you to use it as a vectorstore,
+whether for semantic search or example selection.
+
+```python
+from langchain_community.vectorstores import Milvus
+```
+
+For a more detailed walkthrough of the Miluvs wrapper, see [this notebook](/docs/integrations/vectorstores/zilliz)

langchain_md_files/integrations/retrievers/index.mdx

@@ -0,0 +1,37 @@
+---
+sidebar_position: 0
+sidebar_class_name: hidden
+---
+
+import {CategoryTable, IndexTable} from '@theme/FeatureTables'
+
+# Retrievers
+
+A [retriever](/docs/concepts/#retrievers) is an interface that returns documents given an unstructured query.
+It is more general than a vector store.
+A retriever does not need to be able to store documents, only to return (or retrieve) them.
+Retrievers can be created from vector stores, but are also broad enough to include [Wikipedia search](/docs/integrations/retrievers/wikipedia/) and [Amazon Kendra](/docs/integrations/retrievers/amazon_kendra_retriever/).
+
+Retrievers accept a string query as input and return a list of [Documents](https://python.langchain.com/v0.2/api_reference/core/documents/langchain_core.documents.base.Document.html) as output.
+
+For specifics on how to use retrievers, see the [relevant how-to guides here](/docs/how_to/#retrievers).
+
+Note that all [vector stores](/docs/concepts/#vector-stores) can be [cast to retrievers](/docs/how_to/vectorstore_retriever/).
+Refer to the vector store [integration docs](/docs/integrations/vectorstores/) for available vector stores.
+This page lists custom retrievers, implemented via subclassing [BaseRetriever](/docs/how_to/custom_retriever/).
+
+## Bring-your-own documents
+
+The below retrievers allow you to index and search a custom corpus of documents.
+
+<CategoryTable category="document_retrievers" />
+
+## External index
+
+The below retrievers will search over an external index (e.g., constructed from Internet data or similar).
+
+<CategoryTable category="external_retrievers" />
+
+## All retrievers
+
+<IndexTable />

langchain_md_files/integrations/retrievers/self_query/index.mdx

@@ -0,0 +1,11 @@
+---
+sidebar-position: 0
+---
+
+# Self-querying retrievers
+
+Learn about how the self-querying retriever works [here](/docs/how_to/self_query).
+
+import DocCardList from "@theme/DocCardList";
+
+<DocCardList />

langchain_md_files/integrations/text_embedding/index.mdx

@@ -0,0 +1,18 @@
+---
+sidebar_position: 0
+sidebar_class_name: hidden
+---
+
+# Embedding models
+
+import { CategoryTable, IndexTable } from "@theme/FeatureTables";
+
+[Embedding models](/docs/concepts#embedding-models) create a vector representation of a piece of text.
+
+This page documents integrations with various model providers that allow you to use embeddings in LangChain.
+
+<CategoryTable category="text_embedding" />
+
+## All embedding models
+
+<IndexTable />

langchain_md_files/integrations/vectorstores/index.mdx

@@ -0,0 +1,17 @@
+---
+sidebar_position: 0
+sidebar_class_name: hidden
+---
+
+# Vectorstores
+
+import { CategoryTable, IndexTable } from "@theme/FeatureTables";
+
+A [vector store](/docs/concepts/#vector-stores) stores [embedded](/docs/concepts/#embedding-models) data and performs similarity search.
+
+<CategoryTable category="vectorstores" />
+
+## All Vectorstores
+
+<IndexTable />
+

langchain_md_files/introduction.mdx

@@ -0,0 +1,98 @@
+---
+sidebar_position: 0
+sidebar_class_name: hidden
+---
+
+# Introduction
+
+**LangChain** is a framework for developing applications powered by large language models (LLMs).
+
+LangChain simplifies every stage of the LLM application lifecycle:
+- **Development**: Build your applications using LangChain's open-source [building blocks](/docs/concepts#langchain-expression-language-lcel), [components](/docs/concepts), and [third-party integrations](/docs/integrations/platforms/).
+Use [LangGraph](/docs/concepts/#langgraph) to build stateful agents with first-class streaming and human-in-the-loop support.
+- **Productionization**: Use [LangSmith](https://docs.smith.langchain.com/) to inspect, monitor and evaluate your chains, so that you can continuously optimize and deploy with confidence.
+- **Deployment**: Turn your LangGraph applications into production-ready APIs and Assistants with [LangGraph Cloud](https://langchain-ai.github.io/langgraph/cloud/).
+
+import ThemedImage from '@theme/ThemedImage';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+
+<ThemedImage
+  alt="Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers."
+  sources={{
+    light: useBaseUrl('/svg/langchain_stack_062024.svg'),
+    dark: useBaseUrl('/svg/langchain_stack_062024_dark.svg'),
+  }}
+  style={{ width: "100%" }}
+  title="LangChain Framework Overview"
+/>
+
+Concretely, the framework consists of the following open-source libraries:
+
+- **`langchain-core`**: Base abstractions and LangChain Expression Language.
+- **`langchain-community`**: Third party integrations.
+  - Partner packages (e.g. **`langchain-openai`**, **`langchain-anthropic`**, etc.): Some integrations have been further split into their own lightweight packages that only depend on **`langchain-core`**.
+- **`langchain`**: Chains, agents, and retrieval strategies that make up an application's cognitive architecture.
+- **[LangGraph](https://langchain-ai.github.io/langgraph)**: Build robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph. Integrates smoothly with LangChain, but can be used without it.
+- **[LangServe](/docs/langserve)**: Deploy LangChain chains as REST APIs.
+- **[LangSmith](https://docs.smith.langchain.com)**: A developer platform that lets you debug, test, evaluate, and monitor LLM applications.
+
+
+:::note
+
+These docs focus on the Python LangChain library. [Head here](https://js.langchain.com) for docs on the JavaScript LangChain library.
+
+:::
+
+## [Tutorials](/docs/tutorials)
+
+If you're looking to build something specific or are more of a hands-on learner, check out our [tutorials section](/docs/tutorials).
+This is the best place to get started.
+
+These are the best ones to get started with:
+
+- [Build a Simple LLM Application](/docs/tutorials/llm_chain)
+- [Build a Chatbot](/docs/tutorials/chatbot)
+- [Build an Agent](/docs/tutorials/agents)
+- [Introduction to LangGraph](https://langchain-ai.github.io/langgraph/tutorials/introduction/)
+
+Explore the full list of LangChain tutorials [here](/docs/tutorials), and check out other [LangGraph tutorials here](https://langchain-ai.github.io/langgraph/tutorials/).
+
+
+## [How-to guides](/docs/how_to)
+
+[Here](/docs/how_to) you’ll find short answers to “How do I….?” types of questions.
+These how-to guides don’t cover topics in depth – you’ll find that material in the [Tutorials](/docs/tutorials) and the [API Reference](https://python.langchain.com/v0.2/api_reference/).
+However, these guides will help you quickly accomplish common tasks.
+
+Check out [LangGraph-specific how-tos here](https://langchain-ai.github.io/langgraph/how-tos/).
+
+## [Conceptual guide](/docs/concepts)
+
+Introductions to all the key parts of LangChain you’ll need to know! [Here](/docs/concepts) you'll find high level explanations of all LangChain concepts.
+
+For a deeper dive into LangGraph concepts, check out [this page](https://langchain-ai.github.io/langgraph/concepts/).
+
+## [API reference](https://python.langchain.com/v0.2/api_reference/)
+Head to the reference section for full documentation of all classes and methods in the LangChain Python packages.
+
+## Ecosystem
+
+### [🦜🛠️ LangSmith](https://docs.smith.langchain.com)
+Trace and evaluate your language model applications and intelligent agents to help you move from prototype to production.
+
+### [🦜🕸️ LangGraph](https://langchain-ai.github.io/langgraph)
+Build stateful, multi-actor applications with LLMs. Integrates smoothly with LangChain, but can be used without it.
+
+## Additional resources
+
+### [Versions](/docs/versions/overview/)
+See what changed in v0.2, learn how to migrate legacy code, and read up on our release/versioning policies, and more.
+
+### [Security](/docs/security)
+Read up on [security](/docs/security) best practices to make sure you're developing safely with LangChain.
+
+### [Integrations](/docs/integrations/providers/)
+LangChain is part of a rich ecosystem of tools that integrate with our framework and build on top of it. Check out our growing list of [integrations](/docs/integrations/providers/).
+
+### [Contributing](/docs/contributing)
+Check out the developer's guide for guidelines on contributing and help getting your dev environment set up.

langchain_md_files/people.mdx

@@ -0,0 +1,46 @@
+---
+hide_table_of_contents: true
+---
+
+import People from "@theme/People";
+
+# People
+
+There are some incredible humans from all over the world who have been instrumental in helping the LangChain community flourish 🌐!
+
+This page highlights a few of those folks who have dedicated their time to the open-source repo in the form of direct contributions and reviews.
+
+## Top reviewers
+
+As LangChain has grown, the amount of surface area that maintainers cover has grown as well.
+
+Thank you to the following folks who have gone above and beyond in reviewing incoming PRs 🙏!
+
+<People type="top_reviewers"></People>
+
+## Top recent contributors
+
+The list below contains contributors who have had the most PRs merged in the last three months, weighted (imperfectly) by impact.
+
+Thank you all so much for your time and efforts in making LangChain better ❤️!
+
+<People type="top_recent_contributors" count="20"></People>
+
+## Core maintainers
+
+Hello there 👋!
+
+We're LangChain's core maintainers. If you've spent time in the community, you've probably crossed paths
+with at least one of us already. 
+
+<People type="maintainers"></People>
+
+## Top all-time contributors
+
+And finally, this is an all-time list of all-stars who have made significant contributions to the framework 🌟:
+
+<People type="top_contributors"></People>
+
+We're so thankful for your support!
+
+And one more thank you to [@tiangolo](https://github.com/tiangolo) for inspiration via FastAPI's [excellent people page](https://fastapi.tiangolo.com/fastapi-people).

langchain_md_files/tutorials/index.mdx

@@ -0,0 +1,54 @@
+---
+sidebar_position: 0
+sidebar_class_name: hidden
+---
+# Tutorials
+
+New to LangChain or to LLM app development in general? Read this material to quickly get up and running.
+
+## Basics
+- [Build a Simple LLM Application with LCEL](/docs/tutorials/llm_chain)
+- [Build a Chatbot](/docs/tutorials/chatbot)
+- [Build vector stores and retrievers](/docs/tutorials/retrievers)
+- [Build an Agent](/docs/tutorials/agents)
+
+## Working with external knowledge
+- [Build a Retrieval Augmented Generation (RAG) Application](/docs/tutorials/rag)
+- [Build a Conversational RAG Application](/docs/tutorials/qa_chat_history)
+- [Build a Question/Answering system over SQL data](/docs/tutorials/sql_qa)
+- [Build a Query Analysis System](/docs/tutorials/query_analysis)
+- [Build a local RAG application](/docs/tutorials/local_rag)
+- [Build a Question Answering application over a Graph Database](/docs/tutorials/graph)
+- [Build a PDF ingestion and Question/Answering system](/docs/tutorials/pdf_qa/)
+
+## Specialized tasks
+- [Build an Extraction Chain](/docs/tutorials/extraction)
+- [Generate synthetic data](/docs/tutorials/data_generation)
+- [Classify text into labels](/docs/tutorials/classification)
+- [Summarize text](/docs/tutorials/summarization)
+
+## LangGraph
+
+LangGraph is an extension of LangChain aimed at
+building robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
+
+LangGraph documentation is currently hosted on a separate site.
+You can peruse [LangGraph tutorials here](https://langchain-ai.github.io/langgraph/tutorials/).
+
+## LangSmith
+
+LangSmith allows you to closely trace, monitor and evaluate your LLM application.
+It seamlessly integrates with LangChain, and you can use it to inspect and debug individual steps of your chains as you build.
+
+LangSmith documentation is hosted on a separate site.
+You can peruse [LangSmith tutorials here](https://docs.smith.langchain.com/tutorials/).
+
+### Evaluation
+
+LangSmith helps you evaluate the performance of your LLM applications. The below tutorial is a great way to get started:
+
+- [Evaluate your LLM application](https://docs.smith.langchain.com/tutorials/Developers/evaluation)
+
+## More
+
+For more tutorials, see our [cookbook section](https://github.com/langchain-ai/langchain/tree/master/cookbook).

langchain_md_files/versions/overview.mdx

@@ -0,0 +1,103 @@
+---
+sidebar_position: 0
+sidebar_label: Overview of v0.2
+---
+
+# Overview of LangChain v0.2
+
+## What’s new in LangChain?
+
+The following features have been added during the development of 0.1.x:
+
+- Better streaming support via the [Event Streaming API](https://python.langchain.com/docs/expression_language/streaming/#using-stream-events).
+- [Standardized tool calling support](https://blog.langchain.dev/tool-calling-with-langchain/)
+- A standardized interface for [structuring output](https://github.com/langchain-ai/langchain/discussions/18154)
+- [@chain decorator](https://python.langchain.com/docs/expression_language/how_to/decorator/) to more easily create **RunnableLambdas**
+- https://python.langchain.com/docs/expression_language/how_to/inspect/
+- In Python, better async support for many core abstractions (thank you [@cbornet](https://github.com/cbornet)!!)
+- Include response metadata in `AIMessage` to make it easy to access raw output from the underlying models
+- Tooling to visualize [your runnables](https://python.langchain.com/docs/expression_language/how_to/inspect/) or [your langgraph app](https://github.com/langchain-ai/langgraph/blob/main/examples/visualization.ipynb)
+- Interoperability of chat message histories across most providers
+- [Over 20+ partner packages in python](https://python.langchain.com/docs/integrations/platforms/) for popular integrations
+
+
+## What’s coming to LangChain?
+
+- We’ve been working hard on [langgraph](https://langchain-ai.github.io/langgraph/). We will be building more capabilities on top of it and focusing on making it the go-to framework for agent architectures.
+- Vectorstores V2! We’ll be revisiting our vectorstores abstractions to help improve usability and reliability.
+- Better documentation and versioned docs!
+- We’re planning a breaking release (0.3.0) sometime between July-September to [upgrade to full support of Pydantic 2](https://github.com/langchain-ai/langchain/discussions/19339), and will drop support for Pydantic 1 (including objects originating from the `v1` namespace of Pydantic 2).
+
+## What changed?
+
+Due to the rapidly evolving field, LangChain has also evolved rapidly.
+
+This document serves to outline at a high level what has changed and why.
+
+### TLDR
+
+**As of 0.2.0:**
+
+- This release completes the work that we started with release 0.1.0 by removing the dependency of `langchain` on `langchain-community`.
+- `langchain` package no longer requires `langchain-community` . Instead `langchain-community` will now depend on `langchain-core` and `langchain` .
+- User code that still relies on deprecated imports from `langchain` will continue to work as long `langchain_community` is installed. These imports will start raising errors in release 0.4.x.
+
+**As of 0.1.0:**
+
+- `langchain` was split into the following component packages: `langchain-core`, `langchain`, `langchain-community`, `langchain-[partner]` to improve the usability of langchain code in production settings. You can read more about it on our [blog](https://blog.langchain.dev/langchain-v0-1-0/).
+
+### Ecosystem organization
+
+By the release of 0.1.0, LangChain had grown to a large ecosystem with many integrations and a large community.
+
+To improve the usability of LangChain in production, we split the single `langchain` package into multiple packages. This allowed us to create a good foundation architecture for the LangChain ecosystem and improve the usability of `langchain` in production.
+
+Here is the high level break down of the Eco-system:
+
+- **langchain-core**:  contains core abstractions involving LangChain Runnables, tooling for observability, and base implementations of important abstractions (e.g., Chat Models).
+- **langchain:** contains generic code that is built using interfaces defined in `langchain-core`. This package is for code that generalizes well across different implementations of specific interfaces. For example, `create_tool_calling_agent` works across chat models that support [tool calling capabilities](https://blog.langchain.dev/tool-calling-with-langchain/).
+- **langchain-community**: community maintained 3rd party integrations. Contains integrations based on interfaces defined in **langchain-core**. Maintained by the LangChain community.
+- **Partner Packages (e.g., langchain-[partner])**: Partner packages are packages dedicated to especially popular integrations (e.g., `langchain-openai`, `langchain-anthropic` etc.). The dedicated packages generally benefit from better reliability and support.
+- `langgraph`: Build robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
+- `langserve`: Deploy LangChain chains as REST APIs.
+
+
+In the 0.1.0 release, `langchain-community` was retained as required a dependency of `langchain`.
+
+This allowed imports of vectorstores, chat models, and other integrations to continue working through `langchain`
+rather than forcing users to update all of their imports to `langchain-community`.
+
+For the 0.2.0 release, we’re removing the dependency of `langchain` on `langchain-community`. This is something we’ve been planning to do since the 0.1 release because we believe this is the right package architecture.
+
+Old imports will continue to work as long as `langchain-community` is installed. These imports will be removed in the 0.4.0 release.
+
+To understand why we think breaking the dependency of `langchain` on `langchain-community` is best we should understand what each package is meant to do.
+
+`langchain` is meant to contain high-level chains and agent architectures. The logic in these should be specified at the level of abstractions like `ChatModel` and `Retriever`, and should not be specific to any one integration. This has two main benefits:
+
+1. `langchain` is fairly lightweight. Here is the full list of required dependencies (after the split)
+
+    ```toml
+    python = ">=3.8.1,<4.0"
+    langchain-core = "^0.2.0"
+    langchain-text-splitters = ">=0.0.1,<0.1"
+    langsmith = "^0.1.17"
+    pydantic = ">=1,<3"
+    SQLAlchemy = ">=1.4,<3"
+    requests = "^2"
+    PyYAML = ">=5.3"
+    numpy = "^1"
+    aiohttp = "^3.8.3"
+    tenacity = "^8.1.0"
+    jsonpatch = "^1.33"
+    ```
+
+2. `langchain` chains/agents are largely integration-agnostic, which makes it easy to experiment with different integrations and future-proofs your code should there be issues with one specific integration.
+
+There is also a third less tangible benefit which is that being integration-agnostic forces us to find only those very generic abstractions and architectures which generalize well across integrations. Given how general the abilities of the foundational tech are, and how quickly the space is moving, having generic architectures is a good way of future-proofing your applications.
+
+`langchain-community` is intended to have all integration-specific components that are not yet being maintained in separate `langchain-{partner}` packages. Today this is still the majority of integrations and a lot of code. This code is primarily contributed by the community, while `langchain` is largely written by core maintainers. All of these integrations use optional dependencies and conditional imports, which prevents dependency bloat and conflicts but means compatible dependency versions are not made explicit. Given the volume of integrations in `langchain-community` and the speed at which integrations change, it’s very hard to follow semver versioning, and we currently don’t.
+
+All of which is to say that there’s no large benefits to `langchain` depending on `langchain-community` and some obvious downsides: the functionality in `langchain` should be integration agnostic anyways, `langchain-community` can’t be properly versioned, and depending on `langchain-community` increases the [vulnerability surface](https://github.com/langchain-ai/langchain/discussions/19083) of `langchain`.
+
+For more context about the reason for the organization please see our blog: https://blog.langchain.dev/langchain-v0-1-0/

langchain_md_files/versions/release_policy.mdx

@@ -0,0 +1,102 @@
+---
+sidebar_position: 2
+sidebar_label: Release policy
+---
+
+# LangChain release policy
+
+The LangChain ecosystem is composed of different component packages (e.g., `langchain-core`, `langchain`, `langchain-community`, `langgraph`, `langserve`, partner packages etc.)
+
+## Versioning
+
+### `langchain`, `langchain-core`, and integration packages
+
+`langchain`, `langchain-core`, `langchain-text-splitters`, and integration packages (`langchain-openai`, `langchain-anthropic`, etc.) follow [semantic versioning](https://semver.org/) in the format of 0.**Y**.**Z**. The packages are under rapid development, and so are currently versioning the packages with a major version of 0.
+
+Minor version increases will occur for:
+
+- Breaking changes for any public interfaces *not* marked as `beta`.
+
+Patch version increases will occur for:
+
+- Bug fixes,
+- New features,
+- Any changes to private interfaces,
+- Any changes to `beta` features.
+
+When upgrading between minor versions, users should review the list of breaking changes and deprecations.
+
+From time to time, we will version packages as **release candidates**. These are versions that are intended to be released as stable versions, but we want to get feedback from the community before doing so. Release candidates will be versioned as 0.**Y**.**Z**rc**N**. For example, 0.2.0rc1. If no issues are found, the release candidate will be released as a stable version with the same version number. If issues are found, we will release a new release candidate with an incremented `N` value (e.g., 0.2.0rc2).
+
+### `langchain-community`
+
+`langchain-community` is currently on version `0.2.x`.
+
+Minor version increases will occur for:
+
+- Updates to the major/minor versions of required `langchain-x` dependencies. E.g., when updating the required version of `langchain-core` from `^0.2.x` to `0.3.0`.
+
+Patch version increases will occur for:
+
+- Bug fixes,
+- New features,
+- Any changes to private interfaces,
+- Any changes to `beta` features,
+- Breaking changes to integrations to reflect breaking changes in the third-party service.
+
+Whenever possible we will avoid making breaking changes in patch versions.
+However, if an external API makes a breaking change then breaking changes to the corresponding `langchain-community` integration can occur in a patch version.
+
+### `langchain-experimental`
+
+`langchain-experimental` is currently on version `0.0.x`. All changes will be accompanied with patch version increases.
+
+## Release cadence
+
+We expect to space out **minor** releases (e.g., from 0.2.x to 0.3.0) of `langchain` and `langchain-core` by at least 2-3 months, as such releases may contain breaking changes.
+
+Patch versions are released frequently, up to a few times per week, as they contain bug fixes and new features.
+
+## API stability
+
+The development of LLM applications is a rapidly evolving field, and we are constantly learning from our users and the community. As such, we expect that the APIs in `langchain` and `langchain-core` will continue to evolve to better serve the needs of our users.
+
+Even though both `langchain` and `langchain-core` are currently in a pre-1.0 state, we are committed to maintaining API stability in these packages.
+
+- Breaking changes to the public API will result in a minor version bump (the second digit)
+- Any bug fixes or new features will result in a patch version bump (the third digit)
+
+We will generally try to avoid making unnecessary changes, and will provide a deprecation policy for features that are being removed.
+
+### Stability of other packages
+
+The stability of other packages in the LangChain ecosystem may vary:
+
+- `langchain-community` is a community maintained package that contains 3rd party integrations. While we do our best to review and test changes in `langchain-community`, `langchain-community` is expected to experience more breaking changes than `langchain` and `langchain-core` as it contains many community contributions.
+- Partner packages may follow different stability and versioning policies, and users should refer to the documentation of those packages for more information; however, in general these packages are expected to be stable.
+
+### What is a "API stability"?
+
+API stability means:
+
+- All the public APIs (everything in this documentation) will not be moved or renamed without providing backwards-compatible aliases.
+- If new features are added to these APIs – which is quite possible – they will not break or change the meaning of existing methods. In other words, "stable" does not (necessarily) mean "complete."
+- If, for some reason, an API declared stable must be removed or replaced, it will be declared deprecated but will remain in the API for at least two minor releases. Warnings will be issued when the deprecated method is called.
+
+### **APIs marked as internal**
+
+Certain APIs are explicitly marked as “internal” in a couple of ways:
+
+- Some documentation refers to internals and mentions them as such. If the documentation says that something is internal, it may change.
+- Functions, methods, and other objects prefixed by a leading underscore (**`_`**). This is the standard Python convention of indicating that something is private; if any method starts with a single **`_`**, it’s an internal API.
+    - **Exception:** Certain methods are prefixed with `_` , but do not contain an implementation. These methods are *meant* to be overridden by sub-classes that provide the implementation. Such methods are generally part of the **Public API** of LangChain.
+
+## Deprecation policy
+
+We will generally avoid deprecating features until a better alternative is available.
+
+When a feature is deprecated, it will continue to work in the current and next minor version of `langchain` and `langchain-core`. After that, the feature will be removed.
+
+Since we're expecting to space out minor releases by at least 2-3 months, this means that a feature can be removed within 2-6 months of being deprecated.
+
+In some situations, we may allow the feature to remain in the code base for longer periods of time, if it's not causing issues in the packages, to reduce the burden on users.

langchain_md_files/versions/v0_2/deprecations.mdx

@@ -0,0 +1,902 @@
+---
+sidebar_position: 3
+sidebar_label: Changes
+keywords: [retrievalqa, llmchain, conversationalretrievalchain]
+---
+
+# Deprecations and Breaking Changes
+
+This code contains a list of deprecations and removals in the `langchain` and `langchain-core` packages.
+
+New features and improvements are not listed here. See the [overview](/docs/versions/overview/) for a summary of what's new in this release.
+
+## Breaking changes
+
+As of release 0.2.0, `langchain` is required to be integration-agnostic. This means that code in `langchain`  should not by default instantiate any specific chat models, llms, embedding models, vectorstores etc; instead, the user will be required to specify those explicitly.
+
+The following functions and classes require an explicit LLM to be passed as an argument:
+
+- `langchain.agents.agent_toolkits.vectorstore.toolkit.VectorStoreToolkit`
+- `langchain.agents.agent_toolkits.vectorstore.toolkit.VectorStoreRouterToolkit`
+- `langchain.chains.openai_functions.get_openapi_chain`
+- `langchain.chains.router.MultiRetrievalQAChain.from_retrievers`
+- `langchain.indexes.VectorStoreIndexWrapper.query`
+- `langchain.indexes.VectorStoreIndexWrapper.query_with_sources`
+- `langchain.indexes.VectorStoreIndexWrapper.aquery_with_sources`
+- `langchain.chains.flare.FlareChain`
+
+
+The following classes now require passing an explicit Embedding model as an argument:
+
+- `langchain.indexes.VectostoreIndexCreator`
+
+The following code has been removed:
+
+- `langchain.natbot.NatBotChain.from_default` removed in favor of the `from_llm` class method.
+
+Behavior was changed for the following code:
+
+
+### @tool decorator
+
+`@tool` decorator now assigns the function doc-string as the tool description. Previously, the `@tool` decorator
+using to prepend the function signature.
+
+Before 0.2.0:
+
+```python
+@tool
+def my_tool(x: str) -> str:
+    """Some description."""
+    return "something"
+
+print(my_tool.description)
+```
+
+Would result in: `my_tool: (x: str) -> str - Some description.`
+
+As of 0.2.0:
+
+It will result in: `Some description.`
+
+## Code that moved to another package
+
+Code that was moved from `langchain` into another package (e.g, `langchain-community`)
+
+If you try to import it from `langchain`, the import will keep on working, but will raise a deprecation warning. The warning will provide a replacement import statement.
+
+ ```shell
+ python -c "from langchain.document_loaders.markdown import UnstructuredMarkdownLoader"
+```
+
+ ```shell
+ LangChainDeprecationWarning: Importing UnstructuredMarkdownLoader from langchain.document_loaders is deprecated. Please replace deprecated imports:
+
+ >> from langchain.document_loaders import UnstructuredMarkdownLoader
+
+ with new imports of:
+
+ >> from langchain_community.document_loaders import UnstructuredMarkdownLoader
+```
+
+We will continue supporting the imports in `langchain` until release 0.4 as long as the relevant package where the code lives is installed. (e.g., as long as `langchain_community` is installed.)
+
+However, we advise for users to not rely on these imports and instead migrate to the new imports. To help with this process, we’re releasing a migration script via the LangChain CLI. See further instructions in migration guide.
+
+## Code targeted for removal
+
+Code that has better alternatives available and will eventually be removed, so there’s only a single way to do things. (e.g., `predict_messages` method in ChatModels has been deprecated in favor of `invoke`).
+
+### astream events V1
+
+If you are using `astream_events`, please review how to [migrate to astream events v2](/docs/versions/v0_2/migrating_astream_events).
+
+### langchain_core
+
+#### try_load_from_hub
+
+
+In module: `utils.loading`
+Deprecated: 0.1.30
+Removal: 0.3.0
+
+
+Alternative: Using the hwchase17/langchain-hub repo for prompts is deprecated. Please use https://smith.langchain.com/hub instead.
+
+
+#### BaseLanguageModel.predict
+
+
+In module: `language_models.base`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### BaseLanguageModel.predict_messages
+
+
+In module: `language_models.base`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### BaseLanguageModel.apredict
+
+
+In module: `language_models.base`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: ainvoke
+
+
+#### BaseLanguageModel.apredict_messages
+
+
+In module: `language_models.base`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: ainvoke
+
+
+#### RunTypeEnum
+
+
+In module: `tracers.schemas`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: Use string instead.
+
+
+#### TracerSessionV1Base
+
+
+In module: `tracers.schemas`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### TracerSessionV1Create
+
+
+In module: `tracers.schemas`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### TracerSessionV1
+
+
+In module: `tracers.schemas`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### TracerSessionBase
+
+
+In module: `tracers.schemas`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### TracerSession
+
+
+In module: `tracers.schemas`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### BaseRun
+
+
+In module: `tracers.schemas`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: Run
+
+
+#### LLMRun
+
+
+In module: `tracers.schemas`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: Run
+
+
+#### ChainRun
+
+
+In module: `tracers.schemas`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: Run
+
+
+#### ToolRun
+
+
+In module: `tracers.schemas`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: Run
+
+
+#### BaseChatModel.__call__
+
+
+In module: `language_models.chat_models`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### BaseChatModel.call_as_llm
+
+
+In module: `language_models.chat_models`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### BaseChatModel.predict
+
+
+In module: `language_models.chat_models`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### BaseChatModel.predict_messages
+
+
+In module: `language_models.chat_models`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### BaseChatModel.apredict
+
+
+In module: `language_models.chat_models`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: ainvoke
+
+
+#### BaseChatModel.apredict_messages
+
+
+In module: `language_models.chat_models`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: ainvoke
+
+
+#### BaseLLM.__call__
+
+
+In module: `language_models.llms`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### BaseLLM.predict
+
+
+In module: `language_models.llms`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### BaseLLM.predict_messages
+
+
+In module: `language_models.llms`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### BaseLLM.apredict
+
+
+In module: `language_models.llms`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: ainvoke
+
+
+#### BaseLLM.apredict_messages
+
+
+In module: `language_models.llms`
+Deprecated: 0.1.7
+Removal: 0.3.0
+
+
+Alternative: ainvoke
+
+
+#### BaseRetriever.get_relevant_documents
+
+
+In module: `retrievers`
+Deprecated: 0.1.46
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### BaseRetriever.aget_relevant_documents
+
+
+In module: `retrievers`
+Deprecated: 0.1.46
+Removal: 0.3.0
+
+
+Alternative: ainvoke
+
+
+#### ChatPromptTemplate.from_role_strings
+
+
+In module: `prompts.chat`
+Deprecated: 0.0.1
+Removal:
+
+
+Alternative: from_messages classmethod
+
+
+#### ChatPromptTemplate.from_strings
+
+
+In module: `prompts.chat`
+Deprecated: 0.0.1
+Removal:
+
+
+Alternative: from_messages classmethod
+
+
+#### BaseTool.__call__
+
+
+In module: `tools`
+Deprecated: 0.1.47
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### convert_pydantic_to_openai_function
+
+
+In module: `utils.function_calling`
+Deprecated: 0.1.16
+Removal: 0.3.0
+
+
+Alternative: langchain_core.utils.function_calling.convert_to_openai_function()
+
+
+#### convert_pydantic_to_openai_tool
+
+
+In module: `utils.function_calling`
+Deprecated: 0.1.16
+Removal: 0.3.0
+
+
+Alternative: langchain_core.utils.function_calling.convert_to_openai_tool()
+
+
+#### convert_python_function_to_openai_function
+
+
+In module: `utils.function_calling`
+Deprecated: 0.1.16
+Removal: 0.3.0
+
+
+Alternative: langchain_core.utils.function_calling.convert_to_openai_function()
+
+
+#### format_tool_to_openai_function
+
+
+In module: `utils.function_calling`
+Deprecated: 0.1.16
+Removal: 0.3.0
+
+
+Alternative: langchain_core.utils.function_calling.convert_to_openai_function()
+
+
+#### format_tool_to_openai_tool
+
+
+In module: `utils.function_calling`
+Deprecated: 0.1.16
+Removal: 0.3.0
+
+
+Alternative: langchain_core.utils.function_calling.convert_to_openai_tool()
+
+
+### langchain
+
+
+#### AgentType
+
+
+In module: `agents.agent_types`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: Use [LangGraph](/docs/how_to/migrate_agent/) or new agent constructor methods like create_react_agent, create_json_agent, create_structured_chat_agent, etc.
+
+
+#### Chain.__call__
+
+
+In module: `chains.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### Chain.acall
+
+
+In module: `chains.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: ainvoke
+
+
+#### Chain.run
+
+
+In module: `chains.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: invoke
+
+
+#### Chain.arun
+
+
+In module: `chains.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: ainvoke
+
+
+#### Chain.apply
+
+
+In module: `chains.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: batch
+
+
+#### LLMChain
+
+
+In module: `chains.llm`
+Deprecated: 0.1.17
+Removal: 0.3.0
+
+
+Alternative: [RunnableSequence](/docs/how_to/sequence/), e.g., `prompt | llm`
+
+This [migration guide](/docs/versions/migrating_chains/llm_chain) has a side-by-side comparison.
+
+
+#### LLMSingleActionAgent
+
+
+In module: `agents.agent`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: Use [LangGraph](/docs/how_to/migrate_agent/) or new agent constructor methods like create_react_agent, create_json_agent, create_structured_chat_agent, etc.
+
+
+#### Agent
+
+
+In module: `agents.agent`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: Use [LangGraph](/docs/how_to/migrate_agent/) or new agent constructor methods like create_react_agent, create_json_agent, create_structured_chat_agent, etc.
+
+
+#### OpenAIFunctionsAgent
+
+
+In module: `agents.openai_functions_agent.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: create_openai_functions_agent
+
+
+#### ZeroShotAgent
+
+
+In module: `agents.mrkl.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: create_react_agent
+
+
+#### MRKLChain
+
+
+In module: `agents.mrkl.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### ConversationalAgent
+
+
+In module: `agents.conversational.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: create_react_agent
+
+
+#### ConversationalChatAgent
+
+
+In module: `agents.conversational_chat.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: create_json_chat_agent
+
+
+#### ChatAgent
+
+
+In module: `agents.chat.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: create_react_agent
+
+
+#### OpenAIMultiFunctionsAgent
+
+
+In module: `agents.openai_functions_multi_agent.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: create_openai_tools_agent
+
+
+#### ReActDocstoreAgent
+
+
+In module: `agents.react.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### DocstoreExplorer
+
+
+In module: `agents.react.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### ReActTextWorldAgent
+
+
+In module: `agents.react.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### ReActChain
+
+
+In module: `agents.react.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### SelfAskWithSearchAgent
+
+
+In module: `agents.self_ask_with_search.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: create_self_ask_with_search
+
+
+#### SelfAskWithSearchChain
+
+
+In module: `agents.self_ask_with_search.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### StructuredChatAgent
+
+
+In module: `agents.structured_chat.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: create_structured_chat_agent
+
+
+#### RetrievalQA
+
+
+In module: `chains.retrieval_qa.base`
+Deprecated: 0.1.17
+Removal: 0.3.0
+
+
+Alternative: [create_retrieval_chain](https://python.langchain.com/v0.2/api_reference/langchain/chains/langchain.chains.retrieval.create_retrieval_chain.html#langchain-chains-retrieval-create-retrieval-chain)
+This [migration guide](/docs/versions/migrating_chains/retrieval_qa) has a side-by-side comparison.
+
+
+#### load_agent_from_config
+
+
+In module: `agents.loading`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### load_agent
+
+
+In module: `agents.loading`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative:
+
+
+#### initialize_agent
+
+
+In module: `agents.initialize`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: Use [LangGraph](/docs/how_to/migrate_agent/) or new agent constructor methods like create_react_agent, create_json_agent, create_structured_chat_agent, etc.
+
+
+#### XMLAgent
+
+
+In module: `agents.xml.base`
+Deprecated: 0.1.0
+Removal: 0.3.0
+
+
+Alternative: create_xml_agent
+
+
+#### CohereRerank
+
+
+In module: `retrievers.document_compressors.cohere_rerank`
+Deprecated: 0.0.30
+Removal: 0.3.0
+
+
+Alternative: langchain_cohere.CohereRerank
+
+
+#### ConversationalRetrievalChain
+
+
+In module: `chains.conversational_retrieval.base`
+Deprecated: 0.1.17
+Removal: 0.3.0
+
+
+Alternative: [create_history_aware_retriever](https://python.langchain.com/v0.2/api_reference/langchain/chains/langchain.chains.history_aware_retriever.create_history_aware_retriever.html) together with [create_retrieval_chain](https://python.langchain.com/v0.2/api_reference/langchain/chains/langchain.chains.retrieval.create_retrieval_chain.html#langchain-chains-retrieval-create-retrieval-chain) (see example in docstring)
+This [migration guide](/docs/versions/migrating_chains/conversation_retrieval_chain) has a side-by-side comparison.
+
+
+#### create_extraction_chain_pydantic
+
+
+In module: `chains.openai_tools.extraction`
+Deprecated: 0.1.14
+Removal: 0.3.0
+
+
+Alternative: [with_structured_output](/docs/how_to/structured_output/#the-with_structured_output-method) method on chat models that support tool calling.
+
+
+#### create_openai_fn_runnable
+
+
+In module: `chains.structured_output.base`
+Deprecated: 0.1.14
+Removal: 0.3.0
+
+
+Alternative: [with_structured_output](/docs/how_to/structured_output/#the-with_structured_output-method) method on chat models that support tool calling.
+
+
+#### create_structured_output_runnable
+
+
+In module: `chains.structured_output.base`
+Deprecated: 0.1.17
+Removal: 0.3.0
+
+
+Alternative: [with_structured_output](/docs/how_to/structured_output/#the-with_structured_output-method) method on chat models that support tool calling.
+
+
+#### create_openai_fn_chain
+
+
+In module: `chains.openai_functions.base`
+Deprecated: 0.1.1
+Removal: 0.3.0
+
+
+Alternative: create_openai_fn_runnable
+
+
+#### create_structured_output_chain
+
+
+In module: `chains.openai_functions.base`
+Deprecated: 0.1.1
+Removal: 0.3.0
+
+Alternative: ChatOpenAI.with_structured_output
+
+
+#### create_extraction_chain
+
+
+In module: `chains.openai_functions.extraction`
+Deprecated: 0.1.14
+Removal: 0.3.0
+
+
+Alternative: [with_structured_output](/docs/how_to/structured_output/#the-with_structured_output-method) method on chat models that support tool calling.
+
+
+#### create_extraction_chain_pydantic
+
+
+In module: `chains.openai_functions.extraction`
+Deprecated: 0.1.14
+Removal: 0.3.0
+
+
+Alternative: [with_structured_output](/docs/how_to/structured_output/#the-with_structured_output-method) method on chat models that support tool calling.

langchain_md_files/versions/v0_2/index.mdx

@@ -0,0 +1,93 @@
+---
+sidebar_position: 1
+---
+
+# Migrating to LangChain v0.2
+
+
+
+LangChain v0.2 was released in May 2024. This release includes a number of [breaking changes and deprecations](/docs/versions/v0_2/deprecations). This document contains a guide on upgrading to 0.2.x.
+
+:::note Reference
+
+- [Breaking Changes & Deprecations](/docs/versions/v0_2/deprecations)
+- [Migrating legacy chains to LCEL](/docs/versions/migrating_chains)
+- [Migrating to Astream Events v2](/docs/versions/v0_2/migrating_astream_events)
+
+:::
+
+# Migration
+
+This documentation will help you upgrade your code to LangChain `0.2.x.`. To prepare for migration, we first recommend you take the following steps:
+
+1. Install the 0.2.x versions of langchain-core, langchain and upgrade to recent versions of other packages that you may be using. (e.g. langgraph, langchain-community, langchain-openai, etc.)
+2. Verify that your code runs properly with the new packages (e.g., unit tests pass).
+3. Install a recent version of `langchain-cli` , and use the tool to replace old imports used by your code with the new imports. (See instructions below.)
+4. Manually resolve any remaining deprecation warnings.
+5. Re-run unit tests.
+6. If you are using `astream_events`, please review how to [migrate to astream events v2](/docs/versions/v0_2/migrating_astream_events).
+
+## Upgrade to new imports
+
+We created a tool to help migrate your code. This tool is still in **beta** and may not cover all cases, but
+we hope that it will help you migrate your code more quickly.
+
+The migration script has the following limitations:
+
+1. It’s limited to helping users move from old imports to new imports. It does not help address other deprecations.
+2. It can’t handle imports that involve `as` .
+3. New imports are always placed in global scope, even if the old import that was replaced was located inside some local scope (e..g, function body).
+4. It will likely miss some deprecated imports.
+
+Here is an example of the import changes that the migration script can help apply automatically:
+
+
+| From Package        | To Package               | Deprecated Import                                                  | New Import                                                          |
+|---------------------|--------------------------|--------------------------------------------------------------------|---------------------------------------------------------------------|
+| langchain           | langchain-community      | from langchain.vectorstores import InMemoryVectorStore             | from langchain_community.vectorstores import InMemoryVectorStore    |
+| langchain-community | langchain_openai         | from langchain_community.chat_models import ChatOpenAI             | from langchain_openai import ChatOpenAI                             |
+| langchain-community | langchain-core           | from langchain_community.document_loaders import Blob              | from langchain_core.document_loaders import Blob                    |
+| langchain           | langchain-core           | from langchain.schema.document import Document                     | from langchain_core.documents import Document                       |
+| langchain           | langchain-text-splitters | from langchain.text_splitter import RecursiveCharacterTextSplitter | from langchain_text_splitters import RecursiveCharacterTextSplitter |
+
+
+## Installation
+
+```bash
+pip install langchain-cli
+langchain-cli --version # <-- Make sure the version is at least 0.0.22
+```
+
+## Usage
+
+Given that the migration script is not perfect, you should make sure you have a backup of your code first (e.g., using version control like `git`).
+
+You will need to run the migration script **twice** as it only applies one import replacement per run.
+
+For example, say your code still uses `from langchain.chat_models import ChatOpenAI`:
+
+After the first run, you’ll get: `from langchain_community.chat_models import ChatOpenAI`
+After the second run, you’ll get: `from langchain_openai import ChatOpenAI`
+
+```bash
+# Run a first time
+# Will replace from langchain.chat_models import ChatOpenAI
+langchain-cli migrate --diff [path to code] # Preview
+langchain-cli migrate [path to code] # Apply
+
+# Run a second time to apply more import replacements
+langchain-cli migrate --diff [path to code] # Preview
+langchain-cli migrate [path to code] # Apply
+```
+
+### Other options
+
+```bash
+# See help menu
+langchain-cli migrate --help
+# Preview Changes without applying
+langchain-cli migrate --diff [path to code]
+# Run on code including ipython notebooks
+# Apply all import updates except for updates from langchain to langchain-core
+langchain-cli migrate --disable langchain_to_core --include-ipynb [path to code]
+```

langchain_md_files/versions/v0_2/migrating_astream_events.mdx

@@ -0,0 +1,118 @@
+---
+sidebar_position: 2
+sidebar_label: astream_events v2
+---
+
+# Migrating to Astream Events v2
+
+We've added a `v2` of the astream_events API with the release of `0.2.x`. You can see this [PR](https://github.com/langchain-ai/langchain/pull/21638) for more details.
+
+The `v2` version is a re-write of the `v1` version, and should be more efficient, with more consistent output for the events. The `v1` version of the API will be deprecated in favor of the `v2` version and will be removed in  `0.4.0`.
+
+Below is a list of changes between the `v1` and `v2` versions of the API.
+
+
+### output for `on_chat_model_end`
+
+In `v1`, the outputs associated with `on_chat_model_end` changed depending on whether the
+chat model was run as a root level runnable or as part of a chain.
+
+As a root level runnable the output was:
+
+```python
+"data": {"output": AIMessageChunk(content="hello world!", id='some id')}
+```
+
+As part of a chain the output was:
+
+```
+            "data": {
+                "output": {
+                    "generations": [
+                        [
+                            {
+                                "generation_info": None,
+                                "message": AIMessageChunk(
+                                    content="hello world!", id=AnyStr()
+                                ),
+                                "text": "hello world!",
+                                "type": "ChatGenerationChunk",
+                            }
+                        ]
+                    ],
+                    "llm_output": None,
+                }
+            },
+```
+
+
+As of `v2`, the output will always be the simpler representation:
+
+```python
+"data": {"output": AIMessageChunk(content="hello world!", id='some id')}
+```
+
+:::note
+Non chat models (i.e., regular LLMs) are will be consistently associated with the more verbose format for now.
+:::
+
+### output for `on_retriever_end`
+
+`on_retriever_end` output will always return a list of `Documents`.
+
+Before:
+```python
+{
+    "data": {
+        "output": [
+            Document(...),
+            Document(...),
+            ...
+        ]
+    }
+}
+```
+
+### Removed `on_retriever_stream`
+
+The `on_retriever_stream` event was an artifact of the implementation and has been removed.
+
+Full information associated with the event is already available in the `on_retriever_end` event.
+
+Please use `on_retriever_end` instead.
+
+### Removed `on_tool_stream`
+
+The `on_tool_stream` event was an artifact of the implementation and has been removed.
+
+Full information associated with the event is already available in the `on_tool_end` event.
+
+Please use `on_tool_end` instead.
+
+### Propagating Names
+
+Names of runnables have been updated to be more consistent.
+
+```python
+model = GenericFakeChatModel(messages=infinite_cycle).configurable_fields(
+    messages=ConfigurableField(
+        id="messages",
+        name="Messages",
+        description="Messages return by the LLM",
+    )
+)
+```
+
+In `v1`, the event name was `RunnableConfigurableFields`.
+
+In `v2`, the event name is `GenericFakeChatModel`.
+
+If you're filtering by event names, check if you need to update your filters.
+
+### RunnableRetry
+
+Usage of [RunnableRetry](https://python.langchain.com/v0.2/api_reference/core/runnables/langchain_core.runnables.retry.RunnableRetry.html)
+within an LCEL chain being streamed generated an incorrect `on_chain_end` event in `v1` corresponding
+to the failed runnable invocation that was being retried. This event has been removed in `v2`.
+
+No action is required for this change.

openai-cookbook_md_files/How_to_build_an_agent_with_the_node_sdk.mdx

@@ -0,0 +1,492 @@
+# How to build an agent with the Node.js SDK
+
+OpenAI functions enable your app to take action based on user inputs. This means that it can, e.g., search the web, send emails, or book tickets on behalf of your users, making it more powerful than a regular chatbot.
+
+In this tutorial, you will build an app that uses OpenAI functions along with the latest version of the Node.js SDK. The app runs in the browser, so you only need a code editor and, e.g., VS Code Live Server to follow along locally. Alternatively, write your code directly in the browser via [this code playground at Scrimba.](https://scrimba.com/scrim/c6r3LkU9)
+
+## What you will build
+
+Our app is a simple agent that helps you find activities in your area.
+It has access to two functions, `getLocation()` and `getCurrentWeather()`,
+which means it can figure out where you’re located and what the weather
+is at the moment.
+
+At this point, it's important to understand that
+OpenAI doesn't execute any code for you. It just tells your app which
+functions it should use in a given scenario, and then leaves it up to
+your app to invoke them.
+
+Once our agent knows your location and the weather, it'll use GPT’s
+internal knowledge to suggest suitable local activities for you.
+
+## Importing the SDK and authenticating with OpenAI
+
+We start by importing the OpenAI SDK at the top of our JavaScript file and authenticate with our API key, which we have stored as an environment variable.
+
+```js
+import OpenAI from "openai";
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+  dangerouslyAllowBrowser: true,
+});
+```
+
+Since we're running our code in a browser environment at Scrimba, we also need to set `dangerouslyAllowBrowser: true` to confirm we understand the risks involved with client-side API requests. Please note that you should move these requests over to a Node server in a production app.
+
+## Creating our two functions
+
+Next, we'll create the two functions. The first one - `getLocation` -
+uses the [IP API](https://ipapi.co/) to get the location of the
+user.
+
+```js
+async function getLocation() {
+  const response = await fetch("https://ipapi.co/json/");
+  const locationData = await response.json();
+  return locationData;
+}
+```
+
+The IP API returns a bunch of data about your location, including your
+latitude and longitude, which we’ll use as arguments in the second
+function `getCurrentWeather`. It uses the [Open Meteo
+API](https://open-meteo.com/) to get the current weather data, like
+this:
+
+```js
+async function getCurrentWeather(latitude, longitude) {
+  const url = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&hourly=apparent_temperature`;
+  const response = await fetch(url);
+  const weatherData = await response.json();
+  return weatherData;
+}
+```
+
+## Describing our functions for OpenAI
+
+For OpenAI to understand the purpose of these functions, we need to
+describe them using a specific schema. We'll create an array called
+`tools` that contains one object per function. Each object
+will have two keys: `type`, `function`, and the `function` key has 
+three subkeys: `name`, `description`, and `parameters`.
+
+```js
+const tools = [
+  {
+    type: "function",
+    function: {
+      name: "getCurrentWeather",
+      description: "Get the current weather in a given location",
+      parameters: {
+        type: "object",
+        properties: {
+          latitude: {
+            type: "string",
+          },
+          longitude: {
+            type: "string",
+          },
+        },
+        required: ["longitude", "latitude"],
+      },
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "getLocation",
+      description: "Get the user's location based on their IP address",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+    }
+  },
+];
+```
+
+## Setting up the messages array
+
+We also need to define a `messages` array. This will keep track of all of the messages back and forth between our app and OpenAI.
+
+The first object in the array should always have the `role` property set to `"system"`, which tells OpenAI that this is how we want it to behave.
+
+```js
+const messages = [
+  {
+    role: "system",
+    content:
+      "You are a helpful assistant. Only use the functions you have been provided with.",
+  },
+];
+```
+
+## Creating the agent function
+
+We are now ready to build the logic of our app, which lives in the
+`agent` function. It is asynchronous and takes one argument: the
+`userInput`.
+
+We start by pushing the `userInput` to the messages array. This time, we set the `role` to `"user"`, so that OpenAI knows that this is the input from the user.
+
+```js
+async function agent(userInput) {
+  messages.push({
+    role: "user",
+    content: userInput,
+  });
+  const response = await openai.chat.completions.create({
+    model: "gpt-4",
+    messages: messages,
+    tools: tools,
+  });
+  console.log(response);
+}
+```
+
+Next, we'll send a request to the Chat completions endpoint via the
+`chat.completions.create()` method in the Node SDK. This method takes a
+configuration object as an argument. In it, we'll specify three
+properties:
+
+- `model` - Decides which AI model we want to use (in our case,
+  GPT-4).
+- `messages` - The entire history of messages between the user and the
+  AI up until this point.
+- `tools` - A list of tools the model may call. Currently, only 
+  functions are supported as a tool., we'll we use the `tools` array we 
+  created earlier.
+
+## Running our app with a simple input
+
+Let's try to run the `agent` with an input that requires a function call to give a suitable reply.
+
+```js
+agent("Where am I located right now?");
+```
+
+When we run the code above, we see the response from OpenAI logged out
+to the console like this:
+
+```js
+{
+    id: "chatcmpl-84ojoEJtyGnR6jRHK2Dl4zTtwsa7O",
+    object: "chat.completion",
+    created: 1696159040,
+    model: "gpt-4-0613",
+    choices: [{
+        index: 0,
+        message: {
+            role: "assistant",
+            content: null,
+            tool_calls: [
+              id: "call_CBwbo9qoXUn1kTR5pPuv6vR1",
+              type: "function",
+              function: {
+                name: "getLocation",
+                arguments: "{}"
+              }
+            ]
+        },
+        logprobs: null,
+        finish_reason: "tool_calls" // OpenAI wants us to call a function
+    }],
+    usage: {
+        prompt_tokens: 134,
+        completion_tokens: 6,
+        total_tokens: 140
+    }
+     system_fingerprint: null
+}
+```
+
+This response tells us that we should call one of our functions, as it contains the following key: `finish_reason: "tool_calls"`.
+
+The name of the function can be found in the
+`response.choices[0].message.tool_calls[0].function.name` key, which is set to
+`"getLocation"`.
+
+## Turning the OpenAI response into a function call
+
+Now that we have the name of the function as a string, we'll need to
+translate that into a function call. To help us with that, we'll gather
+both of our functions in an object called `availableTools`:
+
+```js
+const availableTools = {
+  getCurrentWeather,
+  getLocation,
+};
+```
+
+This is handy because we'll be able to access the `getLocation` function
+via bracket notation and the string we got back from OpenAI, like this:
+`availableTools["getLocation"]`.
+
+```js
+const { finish_reason, message } = response.choices[0];
+
+if (finish_reason === "tool_calls" && message.tool_calls) {
+  const functionName = message.tool_calls[0].function.name;
+  const functionToCall = availableTools[functionName];
+  const functionArgs = JSON.parse(message.tool_calls[0].function.arguments);
+  const functionArgsArr = Object.values(functionArgs);
+  const functionResponse = await functionToCall.apply(null, functionArgsArr);
+  console.log(functionResponse);
+}
+```
+
+We're also grabbing ahold of any arguments OpenAI wants us to pass into
+the function: `message.tool_calls[0].function.arguments`.
+However, we won't need any arguments for this first function call.
+
+If we run the code again with the same input
+(`"Where am I located right now?"`), we'll see that `functionResponse`
+is an object filled with location about where the user is located right
+now. In my case, that is Oslo, Norway.
+
+```js
+{ip: "193.212.60.170", network: "193.212.60.0/23", version: "IPv4", city: "Oslo", region: "Oslo County", region_code: "03", country: "NO", country_name: "Norway", country_code: "NO", country_code_iso3: "NOR", country_capital: "Oslo", country_tld: ".no", continent_code: "EU", in_eu: false, postal: "0026", latitude: 59.955, longitude: 10.859, timezone: "Europe/Oslo", utc_offset: "+0200", country_calling_code: "+47", currency: "NOK", currency_name: "Krone", languages: "no,nb,nn,se,fi", country_area: 324220, country_population: 5314336, asn: "AS2119", org: "Telenor Norge AS"}
+```
+
+We'll add this data to a new item in the `messages` array, where we also
+specify the name of the function we called.
+
+```js
+messages.push({
+  role: "function",
+  name: functionName,
+  content: `The result of the last function was this: ${JSON.stringify(
+    functionResponse
+  )}
+  `,
+});
+```
+
+Notice that the `role` is set to `"function"`. This tells OpenAI
+that the `content` parameter contains the result of the function call
+and not the input from the user.
+
+At this point, we need to send a new request to OpenAI with this updated
+`messages` array. However, we don’t want to hard code a new function
+call, as our agent might need to go back and forth between itself and
+GPT several times until it has found the final answer for the user.
+
+This can be solved in several different ways, e.g. recursion, a
+while-loop, or a for-loop. We'll use a good old for-loop for the sake of
+simplicity.
+
+## Creating the loop
+
+At the top of the `agent` function, we'll create a loop that lets us run
+the entire procedure up to five times.
+
+If we get back `finish_reason: "tool_calls"` from GPT, we'll just
+push the result of the function call to the `messages` array and jump to
+the next iteration of the loop, triggering a new request.
+
+If we get `finish_reason: "stop"` back, then GPT has found a suitable
+answer, so we'll return the function and cancel the loop.
+
+```js
+for (let i = 0; i < 5; i++) {
+  const response = await openai.chat.completions.create({
+    model: "gpt-4",
+    messages: messages,
+    tools: tools,
+  });
+  const { finish_reason, message } = response.choices[0];
+
+  if (finish_reason === "tool_calls" && message.tool_calls) {
+    const functionName = message.tool_calls[0].function.name;
+    const functionToCall = availableTools[functionName];
+    const functionArgs = JSON.parse(message.tool_calls[0].function.arguments);
+    const functionArgsArr = Object.values(functionArgs);
+    const functionResponse = await functionToCall.apply(null, functionArgsArr);
+
+    messages.push({
+      role: "function",
+      name: functionName,
+      content: `
+          The result of the last function was this: ${JSON.stringify(
+            functionResponse
+          )}
+          `,
+    });
+  } else if (finish_reason === "stop") {
+    messages.push(message);
+    return message.content;
+  }
+}
+return "The maximum number of iterations has been met without a suitable answer. Please try again with a more specific input.";
+```
+
+If we don't see a `finish_reason: "stop"` within our five iterations,
+we'll return a message saying we couldn’t find a suitable answer.
+
+## Running the final app
+
+At this point, we are ready to try our app! I'll ask the agent to
+suggest some activities based on my location and the current weather.
+
+```js
+const response = await agent(
+  "Please suggest some activities based on my location and the current weather."
+);
+console.log(response);
+```
+
+Here's what we see in the console (formatted to make it easier to read):
+
+```js
+Based on your current location in Oslo, Norway and the weather (15°C and snowy),
+here are some activity suggestions:
+
+1. A visit to the Oslo Winter Park for skiing or snowboarding.
+2. Enjoy a cosy day at a local café or restaurant.
+3. Visit one of Oslo's many museums. The Fram Museum or Viking Ship Museum offer interesting insights into Norway’s seafaring history.
+4. Take a stroll in the snowy streets and enjoy the beautiful winter landscape.
+5. Enjoy a nice book by the fireplace in a local library.
+6. Take a fjord sightseeing cruise to enjoy the snowy landscapes.
+
+Always remember to bundle up and stay warm. Enjoy your day!
+```
+
+If we peak under the hood, and log out `response.choices[0].message` in
+each iteration of the loop, we'll see that GPT has instructed us to use
+both our functions before coming up with an answer.
+
+First, it tells us to call the `getLocation` function. Then it tells us
+to call the `getCurrentWeather` function with
+`"longitude": "10.859", "latitude": "59.955"` passed in as the
+arguments. This is data it got back from the first function call we did.
+
+```js
+{"role":"assistant","content":null,"tool_calls":[{"id":"call_Cn1KH8mtHQ2AMbyNwNJTweEP","type":"function","function":{"name":"getLocation","arguments":"{}"}}]}
+{"role":"assistant","content":null,"tool_calls":[{"id":"call_uc1oozJfGTvYEfIzzcsfXfOl","type":"function","function":{"name":"getCurrentWeather","arguments":"{\n\"latitude\": \"10.859\",\n\"longitude\": \"59.955\"\n}"}}]}
+```
+
+You've now built an AI agent using OpenAI functions and the Node.js SDK! If you're looking for an extra challenge, consider enhancing this app. For example, you could add a function that fetches up-to-date information on events and activities in the user's location.
+
+Happy coding!
+
+<details>
+<summary>Complete code</summary>
+
+```js
+import OpenAI from "openai";
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+  dangerouslyAllowBrowser: true,
+});
+
+async function getLocation() {
+  const response = await fetch("https://ipapi.co/json/");
+  const locationData = await response.json();
+  return locationData;
+}
+
+async function getCurrentWeather(latitude, longitude) {
+  const url = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&hourly=apparent_temperature`;
+  const response = await fetch(url);
+  const weatherData = await response.json();
+  return weatherData;
+}
+
+const tools = [
+  {
+    type: "function",
+    function: {
+      name: "getCurrentWeather",
+      description: "Get the current weather in a given location",
+      parameters: {
+        type: "object",
+        properties: {
+          latitude: {
+            type: "string",
+          },
+          longitude: {
+            type: "string",
+          },
+        },
+        required: ["longitude", "latitude"],
+      },
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "getLocation",
+      description: "Get the user's location based on their IP address",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+    }
+  },
+];
+
+const availableTools = {
+  getCurrentWeather,
+  getLocation,
+};
+
+const messages = [
+  {
+    role: "system",
+    content: `You are a helpful assistant. Only use the functions you have been provided with.`,
+  },
+];
+
+async function agent(userInput) {
+  messages.push({
+    role: "user",
+    content: userInput,
+  });
+
+  for (let i = 0; i < 5; i++) {
+    const response = await openai.chat.completions.create({
+      model: "gpt-4",
+      messages: messages,
+      tools: tools,
+    });
+
+    const { finish_reason, message } = response.choices[0];
+
+    if (finish_reason === "tool_calls" && message.tool_calls) {
+      const functionName = message.tool_calls[0].function.name;
+      const functionToCall = availableTools[functionName];
+      const functionArgs = JSON.parse(message.tool_calls[0].function.arguments);
+      const functionArgsArr = Object.values(functionArgs);
+      const functionResponse = await functionToCall.apply(
+        null,
+        functionArgsArr
+      );
+
+      messages.push({
+        role: "function",
+        name: functionName,
+        content: `
+                The result of the last function was this: ${JSON.stringify(
+                  functionResponse
+                )}
+                `,
+      });
+    } else if (finish_reason === "stop") {
+      messages.push(message);
+      return message.content;
+    }
+  }
+  return "The maximum number of iterations has been met without a suitable answer. Please try again with a more specific input.";
+}
+
+const response = await agent(
+  "Please suggest some activities based on my location and the weather."
+);
+
+console.log("response:", response);
+```
+
+</details>

openai-cookbook_md_files/vector_databases/supabase/semantic-search.mdx

@@ -0,0 +1,276 @@
+# Semantic search using Supabase Vector
+
+The purpose of this guide is to demonstrate how to store OpenAI embeddings in [Supabase Vector](https://supabase.com/docs/guides/ai) (Postgres + pgvector) for the purposes of semantic search.
+
+[Supabase](https://supabase.com/docs) is an open-source Firebase alternative built on top of [Postgres](https://en.wikipedia.org/wiki/PostgreSQL), a production-grade SQL database. Since Supabase Vector is built on [pgvector](https://github.com/pgvector/pgvector), you can store your embeddings within the same database that holds the rest of your application data. When combined with pgvector's indexing algorithms, vector search remains [fast at large scales](https://supabase.com/blog/increase-performance-pgvector-hnsw).
+
+Supabase adds an ecosystem of services and tools to make app development as quick as possible (such as an [auto-generated REST API](https://postgrest.org/)). We'll use these services to store and query embeddings within Postgres.
+
+This guide covers:
+
+1. [Setting up your database](#setup-database)
+2. [Creating a SQL table](#create-a-vector-table) that can store vector data
+3. [Generating OpenAI embeddings](#generate-openai-embeddings) using OpenAI's JavaScript client
+4. [Storing the embeddings](#store-embeddings-in-database) in your SQL table using the Supabase JavaScript client
+5. [Performing semantic search](#semantic-search) over the embeddings using a Postgres function and the Supabase JavaScript client
+
+## Setup database
+
+First head over to https://database.new to provision your Supabase database. This will create a Postgres database on the Supabase cloud platform. Alternatively, you can follow the [local development](https://supabase.com/docs/guides/cli/getting-started) options if you prefer to run your database locally using Docker.
+
+In the studio, jump to the [SQL editor](https://supabase.com/dashboard/project/_/sql/new) and execute the following SQL to enable pgvector:
+
+```sql
+-- Enable the pgvector extension
+create extension if not exists vector;
+```
+
+> In a production application, the best practice is to use [database migrations](https://supabase.com/docs/guides/cli/local-development#database-migrations) so that all SQL operations are managed within source control. To keep things simple in this guide, we'll execute queries directly in the SQL Editor. If you are building a production app, feel free to move these into a database migration.
+
+## Create a vector table
+
+Next we'll create a table to store documents and embeddings. In the SQL Editor, run:
+
+```sql
+create table documents (
+  id bigint primary key generated always as identity,
+  content text not null,
+  embedding vector (1536) not null
+);
+```
+
+Since Supabase is built on Postgres, we're just using regular SQL here. You can modify this table however you like to better fit your application. If you have existing database tables, you can simply add a new `vector` column to the appropriate table.
+
+The important piece to understand is the `vector` data type, which is a new data type that became available when we enabled the pgvector extension earlier. The size of the vector (1536 here) represents the number of dimensions in the embedding. Since we're using OpenAI's `text-embedding-3-small` model in this example, we set the vector size to 1536.
+
+Let's go ahead and create a vector index on this table so that future queries remain performant as the table grows:
+
+```sql
+create index on documents using hnsw (embedding vector_ip_ops);
+```
+
+This index uses the [HNSW](https://supabase.com/docs/guides/ai/vector-indexes/hnsw-indexes) algorithm to index vectors stored in the `embedding` column, and specifically when using the inner product operator (`<#>`). We'll explain more about this operator later when we implement our match function.
+
+Let's also follow security best practices by enabling row level security on the table:
+
+```sql
+alter table documents enable row level security;
+```
+
+This will prevent unauthorized access to this table through the auto-generated REST API (more on this shortly).
+
+## Generate OpenAI embeddings
+
+This guide uses JavaScript to generate embeddings, but you can easily modify it to use any [language supported by OpenAI](https://platform.openai.com/docs/libraries).
+
+If you are using JavaScript, feel free to use whichever server-side JavaScript runtime that you prefer (Node.js, Deno, Supabase Edge Functions).
+
+If you're using Node.js, first install `openai` as a dependency:
+
+```shell
+npm install openai
+```
+
+then import it:
+
+```js
+import OpenAI from "openai";
+```
+
+If you're using Deno or Supabase Edge Functions, you can import `openai` directly from a URL:
+
+```js
+import OpenAI from "https://esm.sh/openai@4";
+```
+
+> In this example we import from https://esm.sh which is a CDN that automatically fetches the respective NPM module for you and serves it over HTTP.
+
+Next we'll generate an OpenAI embedding using [`text-embedding-3-small`](https://platform.openai.com/docs/guides/embeddings/embedding-models):
+
+```js
+const openai = new OpenAI();
+
+const input = "The cat chases the mouse";
+
+const result = await openai.embeddings.create({
+  input,
+  model: "text-embedding-3-small",
+});
+
+const [{ embedding }] = result.data;
+```
+
+Remember that you will need an [OpenAI API key](https://platform.openai.com/api-keys) to interact with the OpenAI API. You can pass this as an environment variable called `OPENAI_API_KEY`, or manually set it when you instantiate your OpenAI client:
+
+```js
+const openai = new OpenAI({
+  apiKey: "<openai-api-key>",
+});
+```
+
+_**Remember:** Never hard-code API keys in your code. Best practice is to either store it in a `.env` file and load it using a library like [`dotenv`](https://github.com/motdotla/dotenv) or load it from an external key management system._
+
+## Store embeddings in database
+
+Supabase comes with an [auto-generated REST API](https://postgrest.org/) that dynamically builds REST endpoints for each of your tables. This means you don't need to establish a direct Postgres connection to your database - instead you can interact with it simply using by the REST API. This is especially useful in serverless environments that run short-lived processes where re-establishing a database connection every time can be expensive.
+
+Supabase comes with a number of [client libraries](https://supabase.com/docs#client-libraries) to simplify interaction with the REST API. In this guide we'll use the [JavaScript client library](https://supabase.com/docs/reference/javascript), but feel free to adjust this to your preferred language.
+
+If you're using Node.js, install `@supabase/supabase-js` as a dependency:
+
+```shell
+npm install @supabase/supabase-js
+```
+
+then import it:
+
+```js
+import { createClient } from "@supabase/supabase-js";
+```
+
+If you're using Deno or Supabase Edge Functions, you can import `@supabase/supabase-js` directly from a URL:
+
+```js
+import { createClient } from "https://esm.sh/@supabase/supabase-js@2";
+```
+
+Next we'll instantiate our Supabase client and configure it so that it points to your Supabase project. In this guide we'll store a reference to your Supabase URL and key in a `.env` file, but feel free to modify this based on how your application handles configuration.
+
+If you are using Node.js or Deno, add your Supabase URL and service role key to a `.env` file. If you are using the cloud platform, you can find these from your Supabase dashboard [settings page](https://supabase.com/dashboard/project/_/settings/api). If you're running Supabase locally, you can find these by running `npx supabase status` in a terminal.
+
+_.env_
+
+```
+SUPABASE_URL=<supabase-url>
+SUPABASE_SERVICE_ROLE_KEY=<supabase-service-role-key>
+```
+
+If you are using Supabase Edge Functions, these environment variables are automatically injected into your function for you so you can skip the above step.
+
+Next we'll pull these environment variables into our app.
+
+In Node.js, install the `dotenv` dependency:
+
+```shell
+npm install dotenv
+```
+
+And retrieve the environment variables from `process.env`:
+
+```js
+import { config } from "dotenv";
+
+// Load .env file
+config();
+
+const supabaseUrl = process.env["SUPABASE_URL"];
+const supabaseServiceRoleKey = process.env["SUPABASE_SERVICE_ROLE_KEY"];
+```
+
+In Deno, load the `.env` file using the `dotenv` standard library:
+
+```js
+import { load } from "https://deno.land/std@0.208.0/dotenv/mod.ts";
+
+// Load .env file
+const env = await load();
+
+const supabaseUrl = env["SUPABASE_URL"];
+const supabaseServiceRoleKey = env["SUPABASE_SERVICE_ROLE_KEY"];
+```
+
+In Supabase Edge Functions, simply load the injected environment variables directly:
+
+```js
+const supabaseUrl = Deno.env.get("SUPABASE_URL");
+const supabaseServiceRoleKey = Deno.env.get("SUPABASE_SERVICE_ROLE_KEY");
+```
+
+Next let's instantiate our `supabase` client:
+
+```js
+const supabase = createClient(supabaseUrl, supabaseServiceRoleKey, {
+  auth: { persistSession: false },
+});
+```
+
+From here we use the `supabase` client to insert our text and embedding (generated earlier) into the database:
+
+```js
+const { error } = await supabase.from("documents").insert({
+  content: input,
+  embedding,
+});
+```
+
+> In production, best practice would be to check the response `error` to see if there were any problems inserting the data and handle it accordingly.
+
+## Semantic search
+
+Finally let's perform semantic search over the embeddings in our database. At this point we'll assume your `documents` table has been filled with multiple records that we can search over.
+
+Let's create a match function in Postgres that performs the semantic search query. Execute the following in the [SQL Editor](https://supabase.com/dashboard/project/_/sql/new):
+
+```sql
+create function match_documents (
+  query_embedding vector (1536),
+  match_threshold float,
+)
+returns setof documents
+language plpgsql
+as $$
+begin
+  return query
+  select *
+  from documents
+  where documents.embedding <#> query_embedding < -match_threshold
+  order by documents.embedding <#> query_embedding;
+end;
+$$;
+```
+
+This function accepts a `query_embedding` which represents the embedding generated from the search query text (more on this shortly). It also accepts a `match_threshold` which specifies how similar the document embeddings have to be in order for `query_embedding` to count as a match.
+
+Inside the function we implement the query which does two things:
+
+- Filters the documents to only include those who's embeddings match within the above `match_threshold`. Since the `<#>` operator performs the negative inner product (versus positive inner product), we negate the similarity threshold before comparing. This means a `match_threshold` of 1 is most similar, and -1 is most dissimilar.
+- Orders the documents by negative inner product (`<#>`) ascending. This allows us to retrieve documents that match closest first.
+
+> Since OpenAI embeddings are normalized, we opted to use inner product (`<#>`) because it is slightly more performant than other operators like cosine distance (`<=>`). It is important to note though this only works because the embeddings are normalized - if they weren't, cosine distance should be used.
+
+Now we can call this function from our application using the `supabase.rpc()` method:
+
+```js
+const query = "What does the cat chase?";
+
+// First create an embedding on the query itself
+const result = await openai.embeddings.create({
+  input: query,
+  model: "text-embedding-3-small",
+});
+
+const [{ embedding }] = result.data;
+
+// Then use this embedding to search for matches
+const { data: documents, error: matchError } = await supabase
+  .rpc("match_documents", {
+    query_embedding: embedding,
+    match_threshold: 0.8,
+  })
+  .select("content")
+  .limit(5);
+```
+
+In this example, we set a match threshold to 0.8. Adjust this threshold based on what works best with your data.
+
+Note that since `match_documents` returns a set of `documents`, we can treat this `rpc()` like a regular table query. Specifically this means we can chain additional commands to this query, like `select()` and `limit()`. Here we select just the columns we care about from the `documents` table (`content`), and we limit the number of documents returned (max 5 in this example).
+
+At this point you have a list of documents that matched the query based on semantic relationship, ordered by most similar first.
+
+## Next steps
+
+You can use this example as the foundation for other semantic search techniques, like retrieval augmented generation (RAG).
+
+For more information on OpenAI embeddings, read the [Embedding](https://platform.openai.com/docs/guides/embeddings) docs.
+
+For more information on Supabase Vector, read the [AI & Vector](https://supabase.com/docs/guides/ai) docs.

trl_md_files/alignprop_trainer.mdx

@@ -0,0 +1,91 @@
+# Aligning Text-to-Image Diffusion Models with Reward Backpropagation
+
+## The why
+
+If your reward function is differentiable, directly backpropagating gradients from the reward models to the diffusion model is significantly more sample and compute efficient (25x) than doing policy gradient algorithm like DDPO.
+AlignProp does full backpropagation through time, which allows updating the earlier steps of denoising via reward backpropagation.
+
+<div style="text-align: center"><img src="https://align-prop.github.io/reward_tuning.png"/></div>
+
+
+## Getting started with `examples/scripts/alignprop.py`
+
+The `alignprop.py` script is a working example of using the `AlignProp` trainer to finetune a Stable Diffusion model. This example explicitly configures a small subset of the overall parameters associated with the config object (`AlignPropConfig`).
+
+**Note:** one A100 GPU is recommended to get this running. For lower memory setting, consider setting truncated_backprop_rand to False. With default settings this will do truncated backpropagation with K=1.
+
+Almost every configuration parameter has a default. There is only one commandline flag argument that is required of the user to get things up and running. The user is expected to have a [huggingface user access token](https://huggingface.co/docs/hub/security-tokens) that will be used to upload the model post finetuning to HuggingFace hub. The following bash command is to be entered to get things running
+
+```batch
+python alignprop.py --hf_user_access_token <token>
+```
+
+To obtain the documentation of `stable_diffusion_tuning.py`, please run `python stable_diffusion_tuning.py --help`
+
+The following are things to keep in mind (The code checks this for you as well) in general while configuring the trainer (beyond the use case of using the example script)
+
+- The configurable randomized truncation range (`--alignprop_config.truncated_rand_backprop_minmax=(0,50)`) the first number should be equal and greater to 0, while the second number should equal or less to the number of diffusion timesteps (sample_num_steps)
+- The configurable truncation backprop absolute step (`--alignprop_config.truncated_backprop_timestep=49`) the number should be less than the number of diffusion timesteps (sample_num_steps), it only matters when truncated_backprop_rand is set to False
+
+## Setting up the image logging hook function
+
+Expect the function to be given a dictionary with keys
+```python
+['image', 'prompt', 'prompt_metadata', 'rewards']
+
+```
+and `image`, `prompt`, `prompt_metadata`, `rewards`are batched.
+You are free to log however you want the use of `wandb` or `tensorboard` is recommended.
+
+### Key terms
+
+- `rewards` : The rewards/score is a numerical associated with the generated image and is key to steering the RL process
+- `prompt` : The prompt is the text that is used to generate the image
+- `prompt_metadata` : The prompt metadata is the metadata associated with the prompt. A situation where this will not be empty is when the reward model comprises of a [`FLAVA`](https://huggingface.co/docs/transformers/model_doc/flava) setup where questions and ground answers (linked to the generated image) are expected with the generated image (See here: https://github.com/kvablack/ddpo-pytorch/blob/main/ddpo_pytorch/rewards.py#L45)
+- `image` : The image generated by the Stable Diffusion model
+
+Example code for logging sampled images with `wandb` is given below.
+
+```python
+# for logging these images to wandb
+
+def image_outputs_hook(image_data, global_step, accelerate_logger):
+    # For the sake of this example, we only care about the last batch
+    # hence we extract the last element of the list
+    result = {}
+    images, prompts, rewards = [image_data['images'],image_data['prompts'],image_data['rewards']]
+    for i, image in enumerate(images):
+        pil = Image.fromarray(
+            (image.cpu().numpy().transpose(1, 2, 0) * 255).astype(np.uint8)
+        )
+        pil = pil.resize((256, 256))
+        result[f"{prompts[i]:.25} | {rewards[i]:.2f}"] = [pil]
+    accelerate_logger.log_images(
+        result,
+        step=global_step,
+    )
+
+```
+
+### Using the finetuned model
+
+Assuming you've done with all the epochs and have pushed up your model to the hub, you can use the finetuned model as follows
+
+```python
+from diffusers import StableDiffusionPipeline
+pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
+pipeline.to("cuda")
+
+pipeline.load_lora_weights('mihirpd/alignprop-trl-aesthetics')
+
+prompts = ["squirrel", "crab", "starfish", "whale","sponge", "plankton"]
+results = pipeline(prompts)
+
+for prompt, image in zip(prompts,results.images):
+    image.save(f"dump/{prompt}.png")
+```
+
+## Credits
+
+This work is heavily influenced by the repo [here](https://github.com/mihirp1998/AlignProp/) and the associated paper [Aligning Text-to-Image Diffusion Models with Reward Backpropagation
+ by Mihir Prabhudesai, Anirudh Goyal, Deepak Pathak, Katerina Fragkiadaki](https://huggingface.co/papers/2310.03739).

trl_md_files/bco_trainer.mdx

@@ -0,0 +1,139 @@
+# BCO Trainer
+
+TRL supports the Binary Classifier Optimization (BCO).
+The [BCO](https://huggingface.co/papers/2404.04656) authors train a binary classifier whose logit serves as a reward so that the classifier maps {prompt, chosen completion} pairs to 1 and {prompt, rejected completion} pairs to 0.
+For a full example have a look at  [`examples/scripts/bco.py`].
+
+## Expected dataset format
+
+The BCO trainer expects a very specific format for the dataset as it does not require pairwise preferences. Since the model will be trained to directly optimize examples that consist of a prompt, model completion, and a label to indicate whether the completion is "good" or "bad", we expect a dataset with the following columns:
+
+- `prompt`
+- `completion`
+- `label`
+
+for example:
+
+```
+bco_dataset_dict = {
+    "prompt": [
+        "Hey, hello",
+        "How are you",
+        "What is your name?",
+        "What is your name?",
+        "Which is the best programming language?",
+        "Which is the best programming language?",
+        "Which is the best programming language?",
+    ],
+    "completion": [
+        "hi nice to meet you",
+        "leave me alone",
+        "I don't have a name",
+        "My name is Mary",
+        "Python",
+        "C++",
+        "Java",
+    ],
+    "label": [
+        True,
+        False,
+        False,
+        True,
+        True,
+        False,
+        False,
+    ],
+}
+```
+
+where the `prompt` contains the context inputs, `completion` contains the corresponding responses and `label` contains the corresponding flag that indicates if the generated completion is desired (`True`) or undesired (`False`).
+A prompt can have multiple responses and this is reflected in the entries being repeated in the dictionary's value arrays. It is required that the dataset contains at least one desirable and one undesirable completion.
+
+
+## Expected model format
+The BCO trainer expects a model of `AutoModelForCausalLM`, compared to PPO that expects `AutoModelForCausalLMWithValueHead` for the value function.
+
+## Using the `BCOTrainer`
+
+For a detailed example have a look at the `examples/scripts/bco.py` script. At a high level we need to initialize the `BCOTrainer` with a `model` we wish to train and a reference `ref_model` which we will use to calculate the implicit rewards of the preferred and rejected response. 
+
+The `beta` refers to the hyperparameter of the implicit reward, and the dataset contains the 3 entries listed above. Note that the `model` and `ref_model` need to have the same architecture (ie decoder only or encoder-decoder).
+
+
+
+```py
+training_args = BCOConfig(
+    beta=0.1,
+)
+
+bco_trainer = BCOTrainer(
+    model,
+    model_ref,
+    args=training_args,
+    train_dataset=train_dataset,
+    tokenizer=tokenizer,
+)
+```
+After this one can then call:
+
+```py
+bco_trainer.train()
+```
+
+## Underlying Distribution matching (UDM)
+
+In practical scenarios, the thumbs-up and thumbs-down datasets are likely to have divergent underlying distributions of prompts.
+Consider an LLM deployed for user feedback: if the model excels in writing tasks but underperforms in coding, the thumbs-up dataset will be dominated by writing-related prompts, while the thumbs-down dataset will contain mostly coding-related prompts.  
+If the prompts in your desired and undesired datasets differ a lot, it is useful to enable UDM.  
+
+Choose an embedding model and tokenizer:
+
+```py
+embedding_model = AutoModel.from_pretrained(your_model_id)
+embedding_tokenizer = AutoTokenizer.from_pretrained(your_model_id)
+
+# customize this function depending on your embedding model
+def embed_prompt(input_ids, attention_mask, model):
+    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+    return outputs.last_hidden_state.mean(dim=1)
+
+embedding_model = Accelerator().prepare_model(self.embedding_model)
+embedding_func = partial(embed_prompt, model=embedding_model)
+```
+
+Set `prompt_sample_size` to defined how many prompts are selected to train the UDM classifier and start the training with the provided embedding function:
+
+```py
+training_args = BCOConfig(
+    beta=0.1,
+    prompt_sample_size=512,
+)
+
+bco_trainer = BCOTrainer(
+    model,
+    model_ref,
+    args=training_args,
+    train_dataset=train_dataset,
+    tokenizer=tokenizer,
+    embedding_func=embedding_func,
+    embedding_tokenizer=self.embedding_tokenizer,
+)
+
+bco_trainer.train()
+```
+
+### For Mixture of Experts Models: Enabling the auxiliary loss
+
+MOEs are the most efficient if the load is about equally distributed between experts.  
+To ensure that we train MOEs similarly during preference-tuning, it is beneficial to add the auxiliary loss from the load balancer to the final loss.  
+
+This option is enabled by setting `output_router_logits=True` in the model config (e.g. MixtralConfig).  
+To scale how much the auxiliary loss contributes to the total loss, use the hyperparameter `router_aux_loss_coef=...` (default: 0.001).
+
+## BCOTrainer
+
+[[autodoc]] BCOTrainer
+
+## BCOConfig
+
+[[autodoc]] BCOConfig

trl_md_files/best_of_n.mdx

@@ -0,0 +1,72 @@
+# Best of N sampling: Alternative ways to get better model output without RL based fine-tuning 
+
+Within the extras module is the `best-of-n` sampler class that serves as an alternative method of generating better model output.
+As to how it fares against the RL based fine-tuning, please look in the `examples` directory for a comparison example
+
+## Usage
+
+To get started quickly, instantiate an instance of the class with a model, a length sampler, a tokenizer and a callable that serves as a proxy reward pipeline that outputs reward scores for input queries
+
+```python
+
+from transformers import pipeline, AutoTokenizer
+from trl import AutoModelForCausalLMWithValueHead
+from trl.core import LengthSampler
+from trl.extras import BestOfNSampler
+
+ref_model = AutoModelForCausalLMWithValueHead.from_pretrained(ref_model_name)
+reward_pipe = pipeline("sentiment-analysis", model=reward_model, device=device)
+tokenizer = AutoTokenizer.from_pretrained(ref_model_name)
+tokenizer.pad_token = tokenizer.eos_token
+
+
+# callable that takes a list of raw text and returns a list of corresponding reward scores
+def queries_to_scores(list_of_strings):
+  return [output["score"] for output in reward_pipe(list_of_strings)]
+
+best_of_n = BestOfNSampler(model, tokenizer, queries_to_scores, length_sampler=output_length_sampler)
+
+
+```
+
+And assuming you have a list/tensor of tokenized queries, you can generate better output by calling the `generate` method
+
+```python
+
+best_of_n.generate(query_tensors, device=device, **gen_kwargs)
+
+```
+The default sample size is 4, but you can change it at the time of instance initialization like so
+
+```python
+
+best_of_n = BestOfNSampler(model, tokenizer, queries_to_scores, length_sampler=output_length_sampler, sample_size=8)
+
+```
+
+The default output is the result of taking the top scored output for each query, but you can change it to top 2 and so on by passing the `n_candidates` argument at the time of instance initialization
+
+```python
+
+best_of_n = BestOfNSampler(model, tokenizer, queries_to_scores, length_sampler=output_length_sampler, n_candidates=2)
+
+```
+
+There is the option of setting the generation settings (like `temperature`, `pad_token_id`) at the time of instance creation as opposed to when calling the `generate` method.
+This is done by passing a `GenerationConfig` from the `transformers` library at the time of initialization
+
+```python
+
+from transformers import GenerationConfig
+
+generation_config = GenerationConfig(min_length= -1, top_k=0.0, top_p= 1.0, do_sample= True, pad_token_id=tokenizer.eos_token_id)
+
+best_of_n = BestOfNSampler(model, tokenizer, queries_to_scores, length_sampler=output_length_sampler, generation_config=generation_config)
+
+best_of_n.generate(query_tensors, device=device)
+
+```
+
+Furthermore, at the time of initialization you can set the seed to control repeatability of the generation process and the number of samples to generate for each query
+
+

trl_md_files/callbacks.mdx

@@ -0,0 +1,13 @@
+# Callbacks
+
+## SyncRefModelCallback
+
+[[autodoc]] SyncRefModelCallback
+
+## RichProgressCallback
+
+[[autodoc]] RichProgressCallback
+
+## WinRateCallback
+
+[[autodoc]] WinRateCallback

trl_md_files/clis.mdx

@@ -0,0 +1,119 @@
+# Command Line Interfaces (CLIs)
+
+You can use TRL to fine-tune your Language Model with Supervised Fine-Tuning (SFT) or Direct Policy Optimization (DPO) or even chat with your model using the TRL CLIs.
+
+Currently supported CLIs are:
+
+- `trl sft`: fine-tune a LLM on a text/instruction dataset
+- `trl dpo`: fine-tune a LLM with DPO on a preference dataset 
+- `trl chat`: quickly spin up a LLM fine-tuned for chatting
+
+## Fine-tuning with the CLI
+
+Before getting started, pick up a Language Model from Hugging Face Hub. Supported models can be found with the filter "text-generation" within models. Also make sure to pick up a relevant dataset for your task.
+
+Before using the `sft` or `dpo` commands make sure to run:
+```bash
+accelerate config
+```
+and pick up the right configuration for your training setup (single / multi-GPU, DeepSpeed, etc.). Make sure to complete all steps of `accelerate config` before running any CLI command.
+
+We also recommend you passing a YAML config file to configure your training protocol. Below is a simple example of a YAML file that you can use for training your models with `trl sft` command.
+
+```yaml
+model_name_or_path:
+  trl-internal-testing/tiny-random-LlamaForCausalLM
+dataset_name:
+  imdb
+dataset_text_field:
+  text
+report_to:
+  none
+learning_rate:
+  0.0001
+lr_scheduler_type:
+  cosine
+```
+
+Save that config in a `.yaml` and get started immediately! An example CLI config is available as `examples/cli_configs/example_config.yaml`. Note you can overwrite the arguments from the config file by explicitly passing them to the CLI, e.g. from the root folder:
+
+```bash
+trl sft --config examples/cli_configs/example_config.yaml --output_dir test-trl-cli --lr_scheduler_type cosine_with_restarts
+```
+
+Will force-use `cosine_with_restarts` for `lr_scheduler_type`.
+
+### Supported Arguments 
+
+We do support all arguments from `transformers.TrainingArguments`, for loading your model, we support all arguments from `~trl.ModelConfig`:
+
+[[autodoc]] ModelConfig
+
+You can pass any of these arguments either to the CLI or the YAML file.
+
+### Supervised Fine-tuning (SFT)
+
+Follow the basic instructions above and run `trl sft --output_dir <output_dir> <*args>`: 
+
+```bash
+trl sft --model_name_or_path facebook/opt-125m --dataset_name imdb --output_dir opt-sft-imdb
+```
+
+The SFT CLI is based on the `examples/scripts/sft.py` script.
+
+### Direct Policy Optimization (DPO)
+
+To use the DPO CLI, you need to have a dataset in the TRL format such as 
+
+* TRL's Anthropic HH dataset: https://huggingface.co/datasets/trl-internal-testing/hh-rlhf-helpful-base-trl-style
+* TRL's OpenAI TL;DR summarization dataset: https://huggingface.co/datasets/trl-internal-testing/tldr-preference-trl-style
+
+These datasets always have at least three columns `prompt, chosen, rejected`:
+
+* `prompt` is a list of strings.
+* `chosen` is the chosen response in [chat format](https://huggingface.co/docs/transformers/main/en/chat_templating)
+* `rejected` is the rejected response [chat format](https://huggingface.co/docs/transformers/main/en/chat_templating) 
+
+
+To do a quick start, you can run the following command:
+
+```bash
+trl dpo --model_name_or_path facebook/opt-125m --output_dir trl-hh-rlhf --dataset_name trl-internal-testing/hh-rlhf-helpful-base-trl-style
+```
+
+
+The DPO CLI is based on the `examples/scripts/dpo.py` script.
+
+
+#### Custom preference dataset
+
+Format the dataset into TRL format (you can adapt the `examples/datasets/anthropic_hh.py`):
+
+```bash
+python examples/datasets/anthropic_hh.py --push_to_hub --hf_entity your-hf-org
+```
+
+## Chat interface
+
+The chat CLI lets you quickly load the model and talk to it. Simply run the following:
+
+```bash
+trl chat --model_name_or_path  Qwen/Qwen1.5-0.5B-Chat 
+```
+
+> [!TIP]
+> To use the chat CLI with the developer installation, you must run `make dev` 
+>
+
+Note that the chat interface relies on the tokenizer's [chat template](https://huggingface.co/docs/transformers/chat_templating) to format the inputs for the model. Make sure your tokenizer has a chat template defined.
+
+Besides talking to the model there are a few commands you can use:
+
+- **clear**: clears the current conversation and start a new one
+- **example {NAME}**: load example named `{NAME}` from the config and use it as the user input
+- **set {SETTING_NAME}={SETTING_VALUE};**: change the system prompt or generation settings (multiple settings are separated by a ';').
+- **reset**: same as clear but also resets the generation configs to defaults if they have been changed by **set**
+- **save {SAVE_NAME} (optional)**: save the current chat and settings to file by default to `./chat_history/{MODEL_NAME}/chat_{DATETIME}.yaml` or `{SAVE_NAME}` if provided
+- **exit**: closes the interface
+
+The default examples are defined in `examples/scripts/config/default_chat_config.yaml` but you can pass your own with `--config CONFIG_FILE` where you can also specify the default generation parameters.

trl_md_files/cpo_trainer.mdx

@@ -0,0 +1,113 @@
+# CPO Trainer
+
+Contrastive Preference Optimization (CPO) as introduced in the paper [Contrastive Preference Optimization: Pushing the Boundaries of LLM Performance in Machine Translation](https://huggingface.co/papers/2401.08417) by Haoran Xu, Amr Sharaf, Yunmo Chen, Weiting Tan, Lingfeng Shen, Benjamin Van Durme, Kenton Murray, and Young Jin Kim. At a high-level, CPO  trains models to
+avoid generating adequate, but not perfect translations in Machine Translation (MT) tasks. However, CPO is a general approximation to the DPO loss and can be applied to other domains like chat.
+
+CPO aims to mitigate two fundamental shortcomings of SFT. First, SFT’s methodology of minimizing the discrepancy between predicted outputs and gold-standard references inherently caps model performance at the quality level of the training data. Secondly, SFT lacks a mechanism to prevent the model from rejecting mistakes in translations. The CPO objective is derived from the DPO objective.
+
+## SimPO
+The [SimPO](https://huggingface.co/papers/2405.14734) method is also implemented in the `CPOTrainer`. SimPO is an alternative loss that adds a reward margin, allows for length normalization, and does not use BC regularization. To use this loss, we can use SimPO easily by turning on `loss_type="simpo"` and `cpo_alpha=0` in the `CPOConfig`.
+
+## CPO-SimPO
+We also offer the combined use of CPO and SimPO, which enables more stable training and improved performance. Learn more details at [CPO-SimPO Github](https://github.com/fe1ixxu/CPO_SIMPO). To use this method, simply enable SimPO by setting `loss_type="simpo"` and a non-zero `cpo_alpha` in the CPOConfig.
+
+## Expected dataset format
+
+The CPO trainer expects a format identical to the DPO trainer, which should include three entries. These entries should be named as follows:
+
+- `prompt`
+- `chosen`
+- `rejected`
+
+for example:
+
+```py
+cpo_dataset_dict = {
+    "prompt": [
+        "hello",
+        "how are you",
+        "What is your name?",
+        "What is your name?",
+        "Which is the best programming language?",
+        "Which is the best programming language?",
+        "Which is the best programming language?",
+    ],
+    "chosen": [
+        "hi nice to meet you",
+        "I am fine",
+        "My name is Mary",
+        "My name is Mary",
+        "Python",
+        "Python",
+        "Java",
+    ],
+    "rejected": [
+        "leave me alone",
+        "I am not fine",
+        "Whats it to you?",
+        "I dont have a name",
+        "Javascript",
+        "C++",
+        "C++",
+    ],
+}
+```
+where the `prompt` contains the context inputs, `chosen` contains the corresponding chosen responses and `rejected` contains the corresponding negative (rejected) responses. As can be seen a prompt can have multiple responses and this is reflected in the entries being repeated in the dictionary's value arrays.
+
+## Expected model format
+The CPO trainer expects a model of `AutoModelForCausalLM`, compared to PPO that expects `AutoModelForCausalLMWithValueHead` for the value function.
+
+## Using the `CPOTrainer`
+For a detailed example have a look at the `examples/scripts/cpo.py` script. At a high level we need to initialize the `CPOTrainer` with a `model` we wish to train. **Note that CPOTrainer eliminates the need to use the reference model, simplifying the optimization process.** The `beta` refers to the hyperparameter of the implicit reward, and the dataset contains the 3 entries listed above.
+
+```py
+cpo_config = CPOConfig(
+    beta=0.1,
+)
+
+cpo_trainer = CPOTrainer(
+    model,
+    args=cpo_config,
+    train_dataset=train_dataset,
+    tokenizer=tokenizer,
+)
+```
+After this one can then call:
+
+```py
+cpo_trainer.train()
+```
+
+## Loss functions
+
+Given the preference data, the `CPOTrainer` uses the sigmoid loss on the normalized likelihood via the `logsigmoid` to fit a logistic regression.
+
+The [RSO](https://huggingface.co/papers/2309.06657) authors propose to use a hinge loss on the normalized likelihood from the [SLiC](https://huggingface.co/papers/2305.10425) paper. The `CPOTrainer` can be switched to this loss via the `loss_type="hinge"` argument and the `beta` in this case is the reciprocal of the margin.
+
+The [IPO](https://huggingface.co/papers/2310.12036) authors provide a deeper theoretical understanding of the CPO algorithms and identify an issue with overfitting and propose an alternative loss which can be used via the `loss_type="ipo"` argument to the trainer. Note that the `beta`  parameter is the reciprocal of the gap between the log-likelihood ratios of the chosen vs the rejected completion pair and thus the smaller the `beta` the larger this gaps is. As per the paper the loss is averaged over log-likelihoods of the completion (unlike CPO which is summed only).
+
+### For Mixture of Experts Models: Enabling the auxiliary loss
+
+MOEs are the most efficient if the load is about equally distributed between experts.  
+To ensure that we train MOEs similarly during preference-tuning, it is beneficial to add the auxiliary loss from the load balancer to the final loss.  
+
+This option is enabled by setting `output_router_logits=True` in the model config (e.g. MixtralConfig).  
+To scale how much the auxiliary loss contributes to the total loss, use the hyperparameter `router_aux_loss_coef=...` (default: 0.001).
+
+## Logging
+
+While training and evaluating we record the following reward metrics:
+
+* `rewards/chosen`: the mean log probabilities of the policy model for the chosen responses scaled by beta
+* `rewards/rejected`: the mean log probabilities of the policy model for the rejected responses scaled by beta
+* `rewards/accuracies`: mean of how often the chosen rewards are > than the corresponding rejected rewards
+* `rewards/margins`: the mean difference between the chosen and corresponding rejected rewards
+* `nll_loss`: the mean negative log likelihood loss of the policy model for the chosen responses
+
+## CPOTrainer
+
+[[autodoc]] CPOTrainer
+
+## CPOConfig
+
+[[autodoc]] CPOConfig