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.
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.
BaseStore interface that works on the local file system.
Wraps a store with key and value encoders/decoders.
Interface for caching results from embedding 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.
Compute a regex match between the prediction and the reference.
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.
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.
A parser for the output of the PairwiseStringEvalChain.
Pairwise String Evaluation Chain.
Labeled Pairwise String Evaluation Chain.
Distance metric to use.
Compute string distances between the prediction and the reference.
Compute string edit distances between two predictions.
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.
An evaluator that validates a JSON prediction against a JSON schema reference.
An evaluator that calculates the edit distance between JSON strings.
Evaluate whether the prediction is valid JSON.
Json Equality Evaluator.
Compute an exact match between the prediction and the reference.
A named tuple containing the score and reasoning for a trajectory.
Trajectory output parser.
A chain for evaluating ReAct style agents.
Embedding Distance Metric.
Embedding distance evaluation chain.
Use embedding distances to score semantic difference between two predictions.
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.
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.
Memory wrapper that is read-only and cannot be changed.
Conversation chat memory with token limit and vectordb backing.
Combining multiple memories' data together.
Simple Memory.
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.
Iterator for AgentExecutor.
Tool that is run when invalid tool name is encountered by agent.
MRKL Output parser for the chat agent.
Configuration for a chain to use in MRKL system.
AgentFinish with run and thread metadata.
AgentAction with info needed to submit custom tool output to existing run.
Run an OpenAI Assistant.
Output parser for the structured chat agent.
Output parser with retries for the structured chat agent.
Information about a VectorStore.
Toolkit for interacting with a VectorStore.
Toolkit for routing between Vector Stores.
Output parser for the conversational agent.
Output parser for the chat agent.
Output parser for the ReAct agent.
Parses tool invocations and final answers from XML-formatted agent output.
Parses a message into agent action/finish.
Parses self-ask style LLM calls.
Parses a message into agent actions/finish.
Parses tool invocations and final answers in JSON format.
Tool agent action.
Parses a message into agent actions/finish.
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.
Memory used to save agent output AND intermediate steps.
Output parser for the conversational agent.
Retriever that merges the results of multiple retrievers.
Retriever that wraps a base retriever and compresses the results.
Enumerator of the types of search to perform.
Retriever that supports multiple embeddings per parent document.
Retriever that ensembles the multiple retrievers.
Retrieve small chunks then retrieve their parent documents.
Time Weighted Vector Store Retriever.
Output parser for a list of lines.
Given a query, use an LLM to write a set of queries.
Given a query, use an LLM to re-phrase it.
Self Query Retriever.
Embeddings Filter.
Document compressor that uses Zero-Shot Listwise Document Reranking.
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 CrossEncoder for reranking.
Document compressor that uses a pipeline of Transformers.
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.
A function description for ChatOpenAI.
A runnable that routes to the selected function.
Parse the output of an LLM call into a Dictionary using a regex.
Parse an output using Pandas DataFrame format.
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 using a regex.
Parse the output of an LLM call to a boolean.
Parse YAML output using a Pydantic model.
Combine multiple output parsers into one.
Parse the output of an LLM call to a datetime.
Input for the retry chain of the OutputFixingParser.
Wrap a parser and try to fix parsing errors.
Parse an output that is one of a set of values.
Schema for a response from a structured output parser.
Parse the output of an LLM call to a structured output.
Chain where the outputs of one chain feed directly into next.
Simple chain where the outputs of one step feed directly into next.
Pass input through a moderation endpoint.
Base class for prompt selectors.
Prompt collection that goes through conditionals.
Abstract base class for creating structured sequences of calls to components.
Chain that transforms the chain output.
Multi Retrieval QA Chain.
Chain that uses embeddings to route between options.
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.
A typed dictionary containing information about elements in the viewport.
A crawler for web pages.
Question-answering with sources over an index.
Interface for loading the combine documents chain.
Question-answering with sources over a vector database.
Chain for interacting with Elasticsearch Database.
Class for a constitutional principle.
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.
Generate hypothetical document for query, and then embed that.
An answer to the question, with sources.
Class representing a single statement.
A question and its answer as a list of facts.
Output parser that checks if the output is finished.
Chain that generates questions from uncertain spans.
Flare chain.
Input type for ConversationalRetrievalChain.
Chain for chatting with an index.
Chain for chatting with a vector database.
Raise an ImportError if APIChain is used without langchain_community.
Input for a SQL Chain.
Input for a SQL Chain.
Interface for loading the combine documents chain.
Interface for loading the combine documents chain.
Interface for the combine_docs method.
Interface for the combine_docs method.
Base interface for chains combining documents.
Abstract base class for memory in Chains.
Vector Store Retriever Memory.
Conversation chat memory with token limit.
Use to keep track of the last k turns of a conversation.
Mixin for summarizer.
Continually summarizes the conversation history.
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.
Abstract base class for chat memory.
Buffer with summarizer for storing conversation memory.
A basic memory implementation that simply stores the conversation history.
A basic memory implementation that simply stores the conversation history.
Base class for single action agents.
Agent that calls the language model and deciding the action.
An enum for agent types.
Agent driven by OpenAIs function powered API.
Agent for the MRKL chain.
Chain that implements the MRKL system.
Structured Chat Agent.
An agent designed to hold a conversation in addition to using tools.
Chat Agent.
Agent that uses XML tags.
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.
Agent for the self-ask-with-search paper.
[Deprecated] Chain that does self-ask with search.
An Agent driven by OpenAIs function powered API.
An agent that holds a conversation in addition to using tools.
Document compressor that uses Cohere Rerank API.
An instance of a runnable stored in the LangChain Hub.
Map-reduce chain.
Chain to run queries against LLMs.
A router chain that uses an LLM chain to perform routing.
A multi-route chain that uses an LLM router chain to choose amongst prompts.
Implement an LLM driven browser.
Question answering chain with sources over documents.
Question answering with sources over documents.
Chain for applying constitutional principles.
Chain that interprets a prompt and executes python code to do math.
Chain for question-answering with self-verification.
Chain to have a conversation and load context from memory.
Chain for question-answering with self-verification.
Chain for making a simple request to an API endpoint.
Chain for having a conversation based on retrieved documents.
Base class for question-answering chains.
Chain for question-answering against an index.
Chain for question-answering against a vector database.
Base class for question-answer generation chains.
Chain that combines documents by stuffing into context.
Combine documents by recursively reducing them.
Combining documents by mapping a chain over them, then reranking results.
Combine documents by doing a first pass and then refining on more documents.
Chain that splits documents, then analyzes it in pieces.
Combining documents by mapping a chain over them, then combining results.
Get information about the LangChain runtime environment.
Get the major version of Pydantic.
Create a function that helps retrieve objects from their new locations.
Determine if running within IPython or Jupyter.
Callback Handler that writes to a Streamlit app.
Create a store for LangChain serializable objects from a bytes store.
Create a store for langchain Document objects from a bytes store.
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 for the pairwise evaluator.
Resolve the criteria to evaluate.
Run on dataset.
Run on dataset.
Generate a random name.
Get the prompt input key.
Validate tools for single input.
Create an agent that uses OpenAI tools.
Create an agent that uses tools.
Create an agent aimed at supporting tools with multiple inputs.
A convenience method for creating a conversational retrieval agent.
Create an agent that uses JSON to format its logic, build for Chat Models.
Format the intermediate steps as XML.
Construct the scratchpad that lets the agent continue its thought process.
Convert (AgentAction, tool output) tuples into FunctionMessages.
Construct the scratchpad that lets the agent continue its thought process.
Convert (AgentAction, tool output) tuples into ToolMessage objects.
Create an agent that uses XML to format its logic.
Create an agent that uses ReAct prompting.
Create an agent that uses self-ask with search prompting.
Parse an AI message potentially containing tool_calls.
Parse an AI message potentially containing tool_calls.
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.
Return another example given a list of examples for a prompt.
Create retrieval chain that retrieves documents and then passes them on.
Create a chain that takes conversation history and returns documents.
Import error for load_llm.
Import error for load_llm_from_config.
Check if the language model is a LLM.
Check if the language model is a chat model.
Get the appropriate function output parser given the user functions.
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.
Create a citation fuzzy match Runnable.
Return the kwargs for the LLMChain constructor.
Create a chain that generates SQL queries.
Load summarizing chain.
Create a chain for passing a list of Documents to a model.
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.
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.
Initialize a chat model from any supported provider using a unified interface.
Initialize an embeddings model from a model name and optional provider.
Load an agent executor given tools and LLM.
Load agent from Config Dict.
Unified method for loading an agent from LangChainHub or local fs.
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.
Creates a chain that extracts information from a passage.
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.
Create a question answering chain with structure.
Create a question answering chain that returns an answer with sources.
Creates a chain that extracts information from a passage.
Creates a chain that extracts information from a passage using Pydantic schema.
OpenAPI spec to OpenAI function JSON Schema.
Create a chain for querying an API from a OpenAPI spec.
Create tagging chain from schema.
Create tagging chain from Pydantic schema.
Create a citation fuzzy match chain.
[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.
Main entrypoint into package.
Keep here for backwards compatibility.
Global values and configuration that apply to all of LangChain.
DEPRECATED: Kept for backwards compatibility.
DEPRECATED: Kept for backwards compatibility.
Kept for backwards compatibility.
Keep here for backwards compatibility.
Deprecated module for BaseLanguageModel class, kept for backwards compatibility.
Interface with the LangChain Hub.
For backwards compatibility.
Memory maintains Chain state, incorporating context from past runs.
For backwards compatibility.
DEPRECATED: Kept for backwards compatibility.
Experiment with different models.
Vector store stores embedded data and performs vector search.
Document Loaders are classes to load Documents.
Utility functions for LangChain.
Graphs provide a natural language interface to graph databases.
Callback handlers allow listening to events in LangChain.
Callback Handler streams to stdout on new llm token.
Base callback handler that can be used to handle callbacks in langchain.
Callback Handler streams to stdout on new llm token.
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.
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.
Docstores are classes to store and load Documents.
Prompt is the input to the model.
Logic for selecting examples to include in prompts.
Chat Models are a variation on language models.
Implementations of key-value stores and storage helpers.
In memory store that is not thread safe and has no eviction policy.
Embedding models.
Module contains code for a cache backed embedder.
Chat Loaders load chat messages from common communications platforms.
Evaluation chains for grading LLM and Chain outputs.
Interfaces to be implemented by general evaluators.
Loading datasets and evaluators.
Chains and utils related to evaluating question answering functionality.
LLM Chains for evaluating question answering.
LLM Chain for generating examples for question answering.
Scoring evaluators.
Base classes for scoring the output of a model on a scale of 1-10.
Prompts for scoring the outputs of a models for a given question.
Comparison evaluators.
Base classes for comparing the output of two models.
Prompts for comparing the outputs of two models for a given question.
String distance evaluators.
String distance evaluators based on the RapidFuzz library.
Criteria or rubric based evaluators.
Evaluators for parsing strings.
Chains for evaluating ReAct style agents.
Prompt for trajectory evaluation chain.
A chain for evaluating ReAct style agents.
Evaluators that measure embedding distances.
A chain for comparing the output of two models using embeddings.
LangSmith utilities.
LangSmith evaluation utilities.
Run evaluator wrapper for string evaluators.
Utilities for running language models or Chains over datasets.
Configuration for run evaluators.
A simple progress bar for the console.
Memory maintains Chain state, incorporating context from past runs.
Class for a VectorStore-backed memory object.
Class for a conversation memory buffer with older messages stored in a vectorstore .
Deprecated as of LangChain v0.3.4 and will be removed in LangChain v1.0.0.
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.
Load agent.
Interface for tools.
Module definitions of agent types together with corresponding agents.
Functionality for loading agents.
Module implements an agent that uses OpenAI's APIs function enabled API.
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.
Agent toolkits contain integrations with various resources and services.
Local file management toolkit.
OpenAPI spec agent.
Gmail toolkit.
Office365 toolkit.
Zapier Toolkit.
Power BI agent.
Slack toolkit.
NASA Toolkit.
GitHub Toolkit.
Jira Toolkit.
GitLab Toolkit.
Json agent.
SQL agent.
Playwright browser toolkit.
Agent toolkit for interacting with vector stores.
Toolkit for interacting with a vector store.
VectorStore agent.
Spark SQL agent.
AINetwork toolkit.
MultiOn Toolkit.
Steam Toolkit.
An agent designed to hold a conversation in addition to using tools.
An agent designed to hold a conversation in addition to using tools.
Logic for formatting intermediate steps into an agent scratchpad.
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.
Chain that does self ask with search.
Chain that does self-ask with search.
Parsing utils to go from string to AgentAction or Agent Finish.
Memory used to save agent output AND intermediate steps.
Module implements an agent that uses OpenAI's APIs function enabled API.
An agent designed to hold a conversation in addition to using tools.
An agent designed to hold a conversation in addition to using tools.
LLMs.
This module provides backward-compatible exports of core language model classes.
Tools are classes that an Agent uses to interact with the world.
Different methods for rendering Tools to be passed to LLMs.
Tavily Search API toolkit.
PubMed API toolkit.
DataForSeo API Toolkit.
Tools for interacting with the user.
Google Places API Toolkit.
Sleep tool.
Google Lens API Toolkit.
Tool to generate an image.
Google Scholar API Toolkit.
Unsupervised learning based memorization.
Wolfram Alpha API toolkit.
Golden API toolkit.
File Management Tools.
Shell tool.
Utility functions for parsing an OpenAPI spec. Kept for backwards compat.
Gmail tools.
Google Finance API Toolkit.
Merriam-Webster API toolkit.
O365 tools.
Zapier Tool.
This module provides dynamic access to deprecated Zapier tools in LangChain.
Tools for interacting with a PowerBI dataset.
Google Cloud Tools.
Slack tools.
Google Jobs API Toolkit.
GitHub Tool.
Jira Tool.
This module provides dynamic access to deprecated Jira tools.
DuckDuckGo Search API toolkit.
Tools for interacting with a GraphQL API.
StackExchange API toolkit.
GitLab Tool.
Arxiv API toolkit.
Amadeus tools.
Tools for interacting with a JSON file.
This module provides dynamic access to deprecated JSON tools in LangChain.
Edenai Tools.
Azure Cognitive Services Tools.
Eleven Labs Services Tools.
Bing Search API toolkit.
Browser tools and toolkit.
Simple tool wrapper around VectorDBQA chain.
Google Trends API Toolkit.
Google Search API Toolkit.
Tools for interacting with a SQL database.
For backwards compatibility.
Tools for interacting with Spark SQL.
OpenWeatherMap API toolkit.
Tools for making requests to an API endpoint.
Tool for asking for human input.
MutliOn Client API tools.
Metaphor Search API toolkit.
Wikipedia API toolkit.
SceneXplain API toolkit.
Steam API toolkit.
Document Transformers are classes to transform Documents.
Retriever class returns Documents given a text query.
Ensemble Retriever.
Retriever that generates and executes structured queries over its own data source.
Filter that uses an LLM to rerank documents listwise and select top-k.
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.
Indexes.
Vectorstore stubs for the indexing api.
Graphs provide a natural language interface to graph databases.
Relevant prompts for constructing indexes.
Serialization and deserialization.
LangChain Runnable and the LangChain Expression Language (LCEL).
OutputParser classes parse the output of an LLM call.
Chains are easily reusable components linked together.
Map-reduce chain.
Chain pipeline where the outputs of one step feed directly into next.
Chain that just formats a prompt and calls an LLM.
Pass input through a moderation endpoint.
Functionality for loading chains.
Base interface that all chains should implement.
Chain that runs an arbitrary python function.
Use a single chain to route an input to one of multiple retrieval qa chains.
Prompt for the router chain in the multi-prompt chain.
Prompt for the router chain in the multi-retrieval qa chain.
Base classes for LLM-powered router chains.
Base classes for chain routing.
Use a single chain to route an input to one of multiple llm chains.
Implement a GPT-3 driven browser.
Implement an LLM driven browser.
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 for interacting with Elasticsearch Database.
Constitutional AI.
Constitutional principles.
Models for the Constitutional AI chain.
Chain for applying constitutional principles to the outputs of another chain.
Chain that interprets a prompt and executes python code to do math.
Chain that interprets a prompt and executes python code to do math.
Internal representation of a structured query language.
LLM Chain for turning a user text query into a structured query.
Summarization checker chain for verifying accuracy of text generation.
Chain for summarization with self-verification.
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.
Chain that tries to verify assumptions before answering a question.
Chain for question-answering with self-verification.
Methods for creating chains that use OpenAI function-calling APIs.
Adapted from https://github.com/jzbjyb/FLARE.
Chain for chatting with a vector database.
Chain for chatting with a vector 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 for interacting with SQL Database.
Chain for question-answering against a vector database.
Chain for question-answering against a vector database.
Load question answering chains.
Load summarizing chains.
Different ways to combine documents.
Chain that combines documents by stuffing into context.
Combine many documents together by recursively reducing them.
Combining documents by mapping a chain over them first, then reranking results.
Combine documents by doing a first pass and then refining on more documents.
Base interface for chains combining documents.
Combining documents by mapping a chain over them first, then combining results.
Schemas are the LangChain Base Classes and Interfaces.
LangChain Runnable and the LangChain Expression Language (LCEL).