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