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