How-to guides

Here you’ll find answers to “How do I….?” types of questions. These guides are goal-oriented and concrete; they're meant to help you complete a specific task. For conceptual explanations see the Conceptual guide. For end-to-end walkthroughs see Tutorials. For comprehensive descriptions of every class and function see the API Reference.

Installation

• Install LangChain packages

Key features

This highlights functionality that is core to using LangChain.

• Return structured data from a model
• Use a model to call tools
• Stream runnables
• Debug your LLM apps

LangChain Expression Language (LCEL)

LangChain Expression Language is a way to create arbitrary custom chains. It is built on the Runnable protocol.

LCEL cheatsheet: For a quick overview of how to use the main LCEL primitives.

• Chain runnables
• Stream runnables
• Invoke runnables in parallel
• Add default invocation args to runnables
• Turn any function into a runnable
• Pass through inputs from one chain step to the next
• Configure runnable behavior at runtime
• Add message history (memory) to a chain
• Route between sub-chains
• Create a dynamic (self-constructing) chain
• Inspect runnables
• Add fallbacks to a runnable

Components

These are the core building blocks you can use when building applications.

Prompt templates

Prompt Templates are responsible for formatting user input into a format that can be passed to a language model.

• Use few shot examples
• Use few shot examples in chat models
• Partially format the prompt templates
• Compose prompts together

Example selectors

Example Selectors are responsible for selecting the correct few shot examples to pass to the prompt.

• Use example selectors
• Select examples by length
• Select examples by semantic similarity
• Select examples by semantic ngram overlap
• Select examples by maximal marginal relevance

Chat models

Chat Models are newer forms of language models that take messages in and output a message.

• Do function/tool calling
• Get models to return structured output
• Cache model responses
• Get log probabilities
• Create a custom chat model class
• Stream a response back
• Track token usage
• Track response metadata across providers
• Let your end users choose their model

LLMs

What LangChain calls LLMs are older forms of language models that take a string in and output a string.

• Cache model responses
• Create a custom LLM class
• Stream a response back
• Track token usage
• Work with local LLMs

Output parsers

Output Parsers are responsible for taking the output of an LLM and parsing into more structured format.

• Use output parsers to parse an LLM response into structured format
• Parse JSON output
• Parse XML output
• Parse YAML output
• Retry when output parsing errors occur
• Try to fix errors in output parsing
• Write a custom output parser class

Document loaders

Document Loaders are responsible for loading documents from a variety of sources.

• Load CSV data
• Load data from a directory
• Load HTML data
• Load JSON data
• Load Markdown data
• Load Microsoft Office data
• Load PDF files
• Write a custom document loader

Text splitters

Text Splitters take a document and split into chunks that can be used for retrieval.

• Recursively split text
• Split by HTML headers
• Split by HTML sections
• Split by character
• Split code
• Split Markdown by headers
• Recursively split JSON
• Split text into semantic chunks
• Split by tokens

Embedding models

Embedding Models take a piece of text and create a numerical representation of it.

• Embed text data
• Cache embedding results

Vector stores

Vector stores are databases that can efficiently store and retrieve embeddings.

• Use a vector store to retrieve data

Retrievers

Retrievers are responsible for taking a query and returning relevant documents.

• Use a vector store to retrieve data
• Generate multiple queries to retrieve data for
• Use contextual compression to compress the data retrieved
• Write a custom retriever class
• Add similarity scores to retriever results
• Combine the results from multiple retrievers
• Reorder retrieved results to mitigate the "lost in the middle" effect
• Generate multiple embeddings per document
• Retrieve the whole document for a chunk
• Generate metadata filters
• Create a time-weighted retriever
• Use hybrid vector and keyword retrieval

Indexing

Indexing is the process of keeping your vectorstore in-sync with the underlying data source.

• Reindex data to keep your vectorstore in-sync with the underlying data source

Tools

LangChain Tools contain a description of the tool (to pass to the language model) as well as the implementation of the function to call).

• Create custom tools
• Use built-in tools and built-in toolkits
• Use a chat model to call tools
• Add ad-hoc tool calling capability to LLMs and chat models
• Add a human in the loop to tool usage
• Handle errors when calling tools

Multimodal

• Pass multimodal data directly to models
• Use multimodal prompts

Agents

note

For in depth how-to guides for agents, please check out LangGraph documentation.

• Use legacy LangChain Agents (AgentExecutor)
• Migrate from legacy LangChain agents to LangGraph

Callbacks

• Pass in callbacks at runtime
• Attach callbacks to a module
• Pass callbacks into a module constructor
• Create custom callback handlers
• Use callbacks in async environments

Custom

All of LangChain components can easily be extended to support your own versions.

• Create a custom chat model class
• Create a custom LLM class
• Write a custom retriever class
• Write a custom document loader
• Write a custom output parser class
• Create custom callback handlers
• Define a custom tool

Use cases

These guides cover use-case specific details.

Q&A with RAG

Retrieval Augmented Generation (RAG) is a way to connect LLMs to external sources of data.

• Add chat history
• Stream
• Return sources
• Return citations
• Do per-user retrieval

Extraction

Extraction is when you use LLMs to extract structured information from unstructured text.

• Use reference examples
• Handle long text
• Do extraction without using function calling

Chatbots

Chatbots involve using an LLM to have a conversation.

• Manage memory
• Do retrieval
• Use tools

Query analysis

Query Analysis is the task of using an LLM to generate a query to send to a retriever.

• Add examples to the prompt
• Handle cases where no queries are generated
• Handle multiple queries
• Handle multiple retrievers
• Construct filters
• Deal with high cardinality categorical variables

Q&A over SQL + CSV

You can use LLMs to do question answering over tabular data.

• Use prompting to improve results
• Do query validation
• Deal with large databases
• Deal with CSV files

Q&A over graph databases

You can use an LLM to do question answering over graph databases.

• Map values to a database
• Add a semantic layer over the database
• Improve results with prompting
• Construct knowledge graphs