Looking for the JS/TS version? Check out LangChain.js.
To help you ship LangChain apps to production faster, check out LangSmith. LangSmith is a unified developer platform for building, testing, and monitoring LLM applications.
uv add langchain-classicLegacy chains, langchain-community re-exports, indexing API, deprecated functionality, and more.
In most cases, you should be using the main langchain package.
For full documentation, see the API reference. For conceptual guides, tutorials, and examples on using LangChain, see the LangChain Docs.
See our Releases and Versioning policies.
As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
For detailed information on how to contribute, see the Contributing Guide.
A utility to experiment with and compare the performance of different models.
The types of the evaluators.
A base class for evaluators that use an LLM.
String evaluator interface.
Compare the output of two models (or two outputs of the same model).
Interface for evaluating agent trajectories.
A named tuple containing the score and reasoning for a trajectory.
Trajectory output parser.
A chain for evaluating ReAct style agents.
Compute a regex match between the prediction and the reference.
Distance metric to use.
Compute string distances between the prediction and the reference.
Compute string edit distances between two predictions.
A parser for the output of the PairwiseStringEvalChain.
Pairwise String Evaluation Chain.
Labeled Pairwise String Evaluation Chain.
A Criteria to evaluate.
A parser for the output of the CriteriaEvalChain.
LLM Chain for evaluating runs against criteria.
Criteria evaluation chain that requires references.
A parser for the output of the ScoreStringEvalChain.
A chain for scoring on a scale of 1-10 the output of a model.
A chain for scoring the output of a model on a scale of 1-10.
Embedding Distance Metric.
Embedding distance evaluation chain.
Use embedding distances to score semantic difference between two predictions.
LLM Chain for evaluating question answering.
LLM Chain for evaluating QA w/o GT based on context.
LLM Chain for evaluating QA using chain of thought reasoning.
LLM Chain for generating examples for question answering.
An evaluator that calculates the edit distance between JSON strings.
An evaluator that validates a JSON prediction against a JSON schema reference.
Evaluate whether the prediction is valid JSON.
Json Equality Evaluator.
Compute an exact match between the prediction and the reference.
Chat prompt template for the agent scratchpad.
Base Single Action Agent class.
Base Multi Action Agent class.
Base class for parsing agent output into agent action/finish.
Base class for parsing agent output into agent actions/finish.
Agent powered by Runnables.
Agent powered by Runnables.
Tool that just returns the query.
Agent that is using tools.
Tool that is run when invalid tool name is encountered by agent.
Iterator for AgentExecutor.
Output parser for the chat agent.
AgentFinish with run and thread metadata.
AgentAction with info needed to submit custom tool output to existing run.
Run an OpenAI Assistant.
MRKL Output parser for the chat agent.
Configuration for a chain to use in MRKL system.
Parses a message into agent action/finish.
Parses tool invocations and final answers from XML-formatted agent output.
Parses self-ask style LLM calls.
Parses tool invocations and final answers in JSON format.
Parses ReAct-style LLM calls that have a single tool input.
Parses ReAct-style LLM calls that have a single tool input in json format.
Parses a message into agent actions/finish.
Tool agent action.
Parses a message into agent actions/finish.
Output parser for the ReAct agent.
Output parser for the conversational agent.
Information about a VectorStore.
Toolkit for interacting with a VectorStore.
Toolkit for routing between Vector Stores.
Output parser for the structured chat agent.
Output parser with retries for the structured chat agent.
Output parser for the conversational agent.
Memory used to save agent output AND intermediate steps.
Enumerator of the types of search to perform.
Retriever that supports multiple embeddings per parent document.
Given a query, use an LLM to re-phrase it.
Retriever that wraps a base retriever and compresses the results.
Time Weighted Vector Store Retriever.
Retriever that ensembles the multiple retrievers.
Retriever that merges the results of multiple retrievers.
Output parser for a list of lines.
Given a query, use an LLM to write a set of queries.
Retrieve small chunks then retrieve their parent documents.
Parse outputs that could return a null string of some sort.
LLM Chain Extractor.
Filter that drops documents that aren't relevant to the query.
Document compressor that uses Zero-Shot Listwise Document Reranking.
Document compressor that uses CrossEncoder for reranking.
Embeddings Filter.
Document compressor that uses a pipeline of Transformers.
Self Query Retriever.
Wrapper around a VectorStore for easy access.
Logic for creating indexes.
Table used to keep track of when a key was last updated.
A SQL Alchemy based implementation of the record manager.
Parse the output of an LLM call using a regex.
Schema for a response from a structured output parser.
Parse the output of an LLM call to a structured output.
Parse an output that is one of a set of values.
Parse the output of an LLM call into a Dictionary using a regex.
Retry chain input for RetryOutputParser.
Retry chain input for RetryWithErrorOutputParser.
Wrap a parser and try to fix parsing errors.
Wrap a parser and try to fix parsing errors.
Parse the output of an LLM call to a datetime.
Parse YAML output using a Pydantic model.
Input for the retry chain of the OutputFixingParser.
Wrap a parser and try to fix parsing errors.
Parse the output of an LLM call to a boolean.
Combine multiple output parsers into one.
Parse an output using Pandas DataFrame format.
Simple Memory.
Combining multiple memories' data together.
Memory wrapper that is read-only and cannot be changed.
Conversation chat memory with token limit and vectordb backing.
Callback handler that returns an async iterator.
Callback handler that returns an async iterator.
Callback handler for streaming in agents.
Tracer that logs via the input Logger.
Chain that transforms the chain output.
Base class for prompt selectors.
Prompt collection that goes through conditionals.
Pass input through a moderation endpoint.
Chain where the outputs of one chain feed directly into next.
Simple chain where the outputs of one step feed directly into next.
Abstract base class for creating structured sequences of calls to components.
Interface for the combine_docs method.
Interface for the combine_docs method.
Base interface for chains combining documents.
Chain for interacting with Elasticsearch Database.
Question-answering with sources over an index.
Interface for loading the combine documents chain.
Question-answering with sources over a vector database.
Input type for ConversationalRetrievalChain.
Chain for chatting with an index.
Chain for chatting with a vector database.
A typed dictionary containing information about elements in the viewport.
A crawler for web pages.
Output parser that checks if the output is finished.
Chain that generates questions from uncertain spans.
Flare chain.
Chain that uses embeddings to route between options.
Multi Retrieval QA Chain.
Parser for output of router chain in the multi-prompt chain.
A route to a destination chain.
Chain that outputs the name of a destination chain and the inputs to it.
Use a single chain to route an input to one of multiple candidate chains.
Input for a SQL Chain.
Input for a SQL Chain.
Raise an ImportError if APIChain is used without langchain_community.
Information about a data source attribute.
A date in ISO 8601 format (YYYY-MM-DD).
A datetime in ISO 8601 format (YYYY-MM-DDTHH:MM:SS).
Transform a query string into an intermediate representation.
Output parser that parses a structured query.
Interface for loading the combine documents chain.
Generate hypothetical document for query, and then embed that.
Class for a constitutional principle.
Class representing a single statement.
A question and its answer as a list of facts.
An answer to the question, with sources.
Interface for loading the combine documents chain.
Interface for caching results from embedding models.
Configuration for a given run evaluator.
Configuration for a run evaluator that only requires a single key.
Configuration for a run evaluation.
Configuration for a reference-free criteria evaluator.
Configuration for a labeled (with references) criteria evaluator.
Configuration for an embedding distance evaluator.
Configuration for a string distance evaluator.
Configuration for a QA evaluator.
Configuration for a context-based QA evaluator.
Configuration for a context-based QA evaluator.
Configuration for a json validity evaluator.
Configuration for a json equality evaluator.
Configuration for an exact match string evaluator.
Configuration for a regex match string evaluator.
Configuration for a score string evaluator.
Configuration for a labeled score string evaluator.
A simple progress bar for the console.
Extract items to evaluate from the run object.
Extract items to evaluate from the run object.
Extract items to evaluate from the run object from a chain.
Map an input to the tool.
Map an example, or row in the dataset, to the inputs of an evaluation.
Evaluate Run and optional examples.
Raised when the input format is invalid.
A dictionary of the results of a single test run.
Your architecture raised an error.
Input for a chat model.
A function description for ChatOpenAI.
A runnable that routes to the selected function.
BaseStore interface that works on the local file system.
Wraps a store with key and value encoders/decoders.
Abstract base class for memory in Chains.
Base class for single action agents.
Agent that calls the language model and deciding the action.
An enum for agent types.
Chat Agent.
Agent for the MRKL chain.
Chain that implements the MRKL system.
Agent for the ReAct chain.
Class to assist with exploration of a document store.
Agent for the ReAct TextWorld chain.
[Deprecated] Chain that implements the ReAct paper.
An agent that holds a conversation in addition to using tools.
Structured Chat Agent.
Agent that uses XML tags.
Agent driven by OpenAIs function powered API.
Agent for the self-ask-with-search paper.
[Deprecated] Chain that does self-ask with search.
An agent designed to hold a conversation in addition to using tools.
An Agent driven by OpenAIs function powered API.
Document compressor that uses Cohere Rerank API.
Mixin for summarizer.
Continually summarizes the conversation history.
Vector Store Retriever Memory.
Conversation chat memory with token limit.
A basic memory implementation that simply stores the conversation history.
A basic memory implementation that simply stores the conversation history.
Abstract base class for chat memory.
Abstract base class for Entity store.
In-memory Entity store.
Upstash Redis backed Entity store.
Redis-backed Entity store.
SQLite-backed Entity store with safe query construction.
Entity extractor & summarizer memory.
Buffer with summarizer for storing conversation memory.
Use to keep track of the last k turns of a conversation.
Chain to run queries against LLMs.
Map-reduce chain.
Combining documents by mapping a chain over them, then combining results.
Combine documents by recursively reducing them.
Combine documents by doing a first pass and then refining on more documents.
Combining documents by mapping a chain over them, then reranking results.
Chain that combines documents by stuffing into context.
Chain that splits documents, then analyzes it in pieces.
Question answering chain with sources over documents.
Question answering with sources over documents.
Chain that interprets a prompt and executes python code to do math.
Chain for having a conversation based on retrieved documents.
Implement an LLM driven browser.
Chain for question-answering with self-verification.
Base class for question-answering chains.
Chain for question-answering against an index.
Chain for question-answering against a vector database.
A multi-route chain that uses an LLM router chain to choose amongst prompts.
A router chain that uses an LLM chain to perform routing.
Chain for question-answering with self-verification.
Chain to have a conversation and load context from memory.
Base class for question-answer generation chains.
Chain for applying constitutional principles.
Chain for making a simple request to an API endpoint.
An instance of a runnable stored in the LangChain Hub.
Get information about the LangChain runtime environment.
Load a dataset from the LangChainDatasets on HuggingFace.
Load the requested evaluation chain specified by a string.
Load evaluators specified by a list of evaluator types.
Resolve the criteria for the pairwise evaluator.
Resolve the criteria to evaluate.
Resolve the criteria for the pairwise evaluator.
Validate tools for single input.
Convert (AgentAction, tool output) tuples into FunctionMessages.
Format the intermediate steps as XML.
Convert (AgentAction, tool output) tuples into ToolMessage objects.
Construct the scratchpad that lets the agent continue its thought process.
Construct the scratchpad that lets the agent continue its thought process.
Parse an AI message potentially containing tool_calls.
Parse an AI message potentially containing tool_calls.
Create an agent that uses tools.
Create an agent that uses ReAct prompting.
A convenience method for creating a conversational retrieval agent.
Create an agent aimed at supporting tools with multiple inputs.
Create an agent that uses XML to format its logic.
Create an agent that uses self-ask with search prompting.
Create an agent that uses JSON to format its logic, build for Chat Models.
Create an agent that uses OpenAI tools.
Create an agent that uses OpenAI function calling.
Yield unique elements of an iterable based on a key function.
Return the compression chain input.
Return the compression chain input.
Load an output parser.
Get the prompt input key.
Callback Handler that writes to a Streamlit app.
Create retrieval chain that retrieves documents and then passes them on.
Check if the language model is a LLM.
Check if the language model is a chat model.
Import error for load_llm.
Import error for load_llm_from_config.
Return another example given a list of examples for a prompt.
Create a chain that takes conversation history and returns documents.
Split Document objects to subsets that each meet a cumulative len. constraint.
Execute a collapse function on a set of documents and merge their metadatas.
Execute a collapse function on a set of documents and merge their metadatas.
Create a chain for passing a list of Documents to a model.
Get the appropriate function output parser given the user functions.
Create a chain that generates SQL queries.
Dummy decorator for when lark is not installed.
Return a parser for the query language.
Fix invalid filter directive.
Construct examples from input-output pairs.
Create query construction prompt.
Load a query constructor runnable chain.
Load summarizing chain.
Create a citation fuzzy match Runnable.
Return the kwargs for the LLMChain constructor.
Get the major version of Pydantic.
Generate a random name.
Run on dataset.
Run on dataset.
Determine if running within IPython or Jupyter.
Create a function that helps retrieve objects from their new locations.
Create a store for LangChain serializable objects from a bytes store.
Create a store for langchain Document objects from a bytes store.
Push an object to the hub and returns the URL it can be viewed at in a browser.
Pull an object from the hub and returns it as a LangChain object.
Load agent from Config Dict.
Unified method for loading an agent from LangChainHub or local fs.
Load an agent executor given tools and LLM.
Construct a VectorStore agent from an LLM and tools.
Construct a VectorStore router agent from an LLM and tools.
Load chain from Config Dict.
Unified method for loading a chain from LangChainHub or local fs.
Create a runnable sequence that uses OpenAI functions.
Create a runnable for extracting structured outputs.
Load a question answering with sources chain.
Load a query constructor chain.
Creates a chain that extracts information from a passage.
OpenAPI spec to OpenAI function JSON Schema.
Create a chain for querying an API from a OpenAPI spec.
Create a citation fuzzy match chain.
Create a question answering chain with structure.
Create a question answering chain that returns an answer with sources.
Create tagging chain from schema.
Create tagging chain from Pydantic schema.
Creates a chain that extracts information from a passage.
Creates a chain that extracts information from a passage using Pydantic schema.
[Legacy] Create an LLM chain that uses OpenAI functions.
[Legacy] Create an LLMChain that uses an OpenAI function to get a structured output.
Load question answering chain.
Initialize a chat model from any supported provider using a unified interface.
Initialize an embeddings model from a model name and optional provider.
Main entrypoint into package.
Interface with the LangChain Hub.
Kept for backwards compatibility.
DEPRECATED: Kept for backwards compatibility.
Experiment with different models.
DEPRECATED: Kept for backwards compatibility.
For backwards compatibility.
Deprecated module for BaseLanguageModel class, kept for backwards compatibility.
For backwards compatibility.
Keep here for backwards compatibility.
DEPRECATED: Kept for backwards compatibility.
Keep here for backwards compatibility.
Global values and configuration that apply to all of LangChain.
Memory maintains Chain state, incorporating context from past runs.
Evaluation chains for grading LLM and Chain outputs.
Interfaces to be implemented by general evaluators.
Loading datasets and evaluators.
Chains for evaluating ReAct style agents.
Prompt for trajectory evaluation chain.
A chain for evaluating ReAct style agents.
String distance evaluators.
String distance evaluators based on the RapidFuzz library.
Comparison evaluators.
Prompts for comparing the outputs of two models for a given question.
Base classes for comparing the output of two models.
Criteria or rubric based evaluators.
Scoring evaluators.
Prompts for scoring the outputs of a models for a given question.
Base classes for scoring the output of a model on a scale of 1-10.
Evaluators that measure embedding distances.
A chain for comparing the output of two models using embeddings.
Chains and utils related to evaluating question answering functionality.
LLM Chains for evaluating question answering.
LLM Chain for generating examples for question answering.
Evaluators for parsing strings.
Document Loaders are classes to load Documents.
LLMs.
This module provides backward-compatible exports of core language model classes.
Agent is a class that uses an LLM to choose a sequence of actions to take.
Chain that takes in an input and produces an action and action input.
Functionality for loading agents.
Module definitions of agent types together with corresponding agents.
Interface for tools.
Load agent.
Attempt to implement MRKL systems as described in arxiv.org/pdf/2205.00445.pdf.
Attempt to implement MRKL systems as described in arxiv.org/pdf/2205.00445.pdf.
Logic for formatting intermediate steps into an agent scratchpad.
Parsing utils to go from string to AgentAction or Agent Finish.
Implements the ReAct paper from https://arxiv.org/pdf/2210.03629.pdf.
Chain that implements the ReAct paper from https://arxiv.org/pdf/2210.03629.pdf.
An agent designed to hold a conversation in addition to using tools.
An agent designed to hold a conversation in addition to using tools.
Agent toolkits contain integrations with various resources and services.
GitLab Toolkit.
Gmail toolkit.
SQL agent.
NASA Toolkit.
Jira Toolkit.
Agent toolkit for interacting with vector stores.
Toolkit for interacting with a vector store.
VectorStore agent.
Office365 toolkit.
OpenAPI spec agent.
GitHub Toolkit.
Json agent.
Spark SQL agent.
Zapier Toolkit.
Slack toolkit.
AINetwork toolkit.
Steam Toolkit.
Local file management toolkit.
Power BI agent.
MultiOn Toolkit.
Playwright browser toolkit.
Module implements an agent that uses OpenAI's APIs function enabled API.
Chain that does self ask with search.
Chain that does self-ask with search.
An agent designed to hold a conversation in addition to using tools.
An agent designed to hold a conversation in addition to using tools.
Memory used to save agent output AND intermediate steps.
Module implements an agent that uses OpenAI's APIs function enabled API.
Retriever class returns Documents given a text query.
Ensemble Retriever.
DocumentFilter that uses an LLM chain to extract the relevant parts of documents.
Filter that uses an LLM to drop documents that aren't relevant to the query.
Filter that uses an LLM to rerank documents listwise and select top-k.
Retriever that generates and executes structured queries over its own data source.
Indexes.
Vectorstore stubs for the indexing api.
Graphs provide a natural language interface to graph databases.
Relevant prompts for constructing indexes.
OutputParser classes parse the output of an LLM call.
Chat Loaders load chat messages from common communications platforms.
Memory maintains Chain state, incorporating context from past runs.
Class for a VectorStore-backed memory object.
Deprecated as of LangChain v0.3.4 and will be removed in LangChain v1.0.0.
Class for a conversation memory buffer with older messages stored in a vectorstore .
Callback handlers allow listening to events in LangChain.
Callback Handler streams to stdout on new llm token.
Callback Handler streams to stdout on new llm token.
Base callback handler that can be used to handle callbacks in langchain.
Tracers that record execution of LangChain runs.
A tracer that runs evaluators over completed runs.
A Tracer implementation that records to LangChain endpoint.
Base interfaces for tracing runs.
Chains are easily reusable components linked together.
Chain that runs an arbitrary python function.
Chain that just formats a prompt and calls an LLM.
Pass input through a moderation endpoint.
Functionality for loading chains.
Map-reduce chain.
Chain pipeline where the outputs of one step feed directly into next.
Base interface that all chains should implement.
Different ways to combine documents.
Combining documents by mapping a chain over them first, then combining results.
Combine many documents together by recursively reducing them.
Combine documents by doing a first pass and then refining on more documents.
Combining documents by mapping a chain over them first, then reranking results.
Chain that combines documents by stuffing into context.
Base interface for chains combining documents.
Chain for interacting with Elasticsearch Database.
Load question answering with sources chains.
Question-answering with sources over an index.
Load question answering with sources chains.
Question-answering with sources over a vector database.
Question answering with sources over documents.
Chain that interprets a prompt and executes python code to do math.
Chain that interprets a prompt and executes python code to do math.
Chain for chatting with a vector database.
Chain for chatting with a vector database.
Implement a GPT-3 driven browser.
Implement an LLM driven browser.
Adapted from https://github.com/jzbjyb/FLARE.
Summarization checker chain for verifying accuracy of text generation.
Chain for summarization with self-verification.
Chain for question-answering against a vector database.
Chain for question-answering against a vector database.
Prompt for the router chain in the multi-retrieval qa chain.
Prompt for the router chain in the multi-prompt chain.
Use a single chain to route an input to one of multiple retrieval qa chains.
Use a single chain to route an input to one of multiple llm chains.
Base classes for LLM-powered router chains.
Base classes for chain routing.
Chain for interacting with SQL Database.
Chain that makes API calls and summarizes the responses to answer a question.
Chain that makes API calls and summarizes the responses to answer a question.
Chain that tries to verify assumptions before answering a question.
Chain for question-answering with self-verification.
Internal representation of a structured query language.
LLM Chain for turning a user text query into a structured query.
Load summarizing chains.
Chain that carries on a conversation from a prompt plus history.
Memory modules for conversation prompts.
Chain that carries on a conversation and calls an LLM.
Hypothetical Document Embeddings.
Hypothetical Document Embeddings.
Constitutional AI.
Constitutional principles.
Models for the Constitutional AI chain.
Chain for applying constitutional principles to the outputs of another chain.
Methods for creating chains that use OpenAI function-calling APIs.
Load question answering chains.
Serialization and deserialization.
Utilities are the integrations with third-part systems and packages.
Shims for asyncio features that may be missing from older python versions.
For backwards compatibility.
Schemas are the LangChain Base Classes and Interfaces.
LangChain Runnable and the LangChain Expression Language (LCEL).
Graphs provide a natural language interface to graph databases.
Chat Models are a variation on language models.
Docstores are classes to store and load Documents.
Tools are classes that an Agent uses to interact with the world.
Different methods for rendering Tools to be passed to LLMs.
SceneXplain API toolkit.
PubMed API toolkit.
Metaphor Search API toolkit.
GitLab Tool.
Golden API toolkit.
Shell tool.
Bing Search API toolkit.
Google Trends API Toolkit.
Edenai Tools.
Google Cloud Tools.
Unsupervised learning based memorization.
Gmail tools.
Google Jobs API Toolkit.
OpenWeatherMap API toolkit.
Google Lens API Toolkit.
Sleep tool.
DuckDuckGo Search API toolkit.
Jira Tool.
This module provides dynamic access to deprecated Jira tools.
Simple tool wrapper around VectorDBQA chain.
Tools for interacting with the user.
O365 tools.
Utility functions for parsing an OpenAPI spec. Kept for backwards compat.
GitHub Tool.
Merriam-Webster API toolkit.
Eleven Labs Services Tools.
Tools for interacting with a JSON file.
This module provides dynamic access to deprecated JSON tools in LangChain.
Tools for making requests to an API endpoint.
Tools for interacting with Spark SQL.
Zapier Tool.
This module provides dynamic access to deprecated Zapier tools in LangChain.
Tools for interacting with a SQL database.
For backwards compatibility.
Google Search API Toolkit.
Wolfram Alpha API toolkit.
Google Scholar API Toolkit.
Arxiv API toolkit.
DataForSeo API Toolkit.
Google Finance API Toolkit.
Google Places API Toolkit.
Tool to generate an image.
Azure Cognitive Services Tools.
Tools for interacting with a GraphQL API.
StackExchange API toolkit.
Slack tools.
Amadeus tools.
Tavily Search API toolkit.
Tool for asking for human input.
Steam API toolkit.
File Management Tools.
Tools for interacting with a PowerBI dataset.
MutliOn Client API tools.
Wikipedia API toolkit.
Browser tools and toolkit.
Utility functions for LangChain.
Embedding models.
Module contains code for a cache backed embedder.
LangSmith utilities.
LangSmith evaluation utilities.
Configuration for run evaluators.
A simple progress bar for the console.
Run evaluator wrapper for string evaluators.
Utilities for running language models or Chains over datasets.
Prompt is the input to the model.
Logic for selecting examples to include in prompts.
Document Transformers are classes to transform Documents.
LangChain Runnable and the LangChain Expression Language (LCEL).
Vector store stores embedded data and performs vector search.
Implementations of key-value stores and storage helpers.
In memory store that is not thread safe and has no eviction policy.