langchain
Framework for building LLM-powered applications with agents, chains, and RAG. Supports multiple providers (OpenAI, Anthropic, Google), 500+ integrations, ReAct agents, tool calling, memory management, and vector store retrieval. Use for building chatbots, question-answering systems, autonomous agents, or RAG applications. Best for rapid prototyping and production deployments.
Install this skill
Works with Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, and 70+ other harnesses.
npx skills add KalarisLabs/research-agent-skills --skill langchainuvx research-agent-skills install langchainDocumentation & Instructions
LangChain - Build LLM Applications with Agents & RAG
The most popular framework for building LLM-powered applications.
When to use LangChain
Use LangChain when:
- Building agents with tool calling and reasoning (ReAct pattern)
- Implementing RAG (retrieval-augmented generation) pipelines
- Need to swap LLM providers easily (OpenAI, Anthropic, Google)
- Creating chatbots with conversation memory
- Rapid prototyping of LLM applications
- Production deployments with LangSmith observability
Metrics:
- 272,000+ repositories use LangChain
- 500+ integrations (models, vector stores, tools)
- 3,800+ contributors
Use alternatives instead:
- LlamaIndex: RAG-focused, better for document Q&A
- LangGraph: Complex stateful workflows, more control
- Haystack: Production search pipelines
- Semantic Kernel: Microsoft ecosystem
Quick start
Installation
# Core library (Python 3.10+)
pip install -U langchain
# With OpenAI
pip install langchain-openai
# With Anthropic
pip install langchain-anthropic
# Common extras
pip install langchain-community # 500+ integrations
pip install langchain-chroma # Vector store
Basic LLM usage
from langchain_anthropic import ChatAnthropic
# Initialize model
llm = ChatAnthropic(model="claude-sonnet-4-5-20250929")
# Simple completion
response = llm.invoke("Explain quantum computing in 2 sentences")
print(response.content)
Create an agent (ReAct pattern)
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic
# Define tools
def get_weather(city: str) -> str:
"""Get current weather for a city."""
return f"It's sunny in {city}, 72°F"
def search_web(query: str) -> str:
"""Search the web for information."""
return f"Search results for: {query}"
# Create agent (<10 lines!)
agent = create_agent(
model=ChatAnthropic(model="claude-sonnet-4-5-20250929"),
tools=[get_weather, search_web],
system_prompt="You are a helpful assistant. Use tools when needed."
)
# Run agent
result = agent.invoke({"messages": [{"role": "user", "content": "What's the weather in Paris?"}]})
print(result["messages"][-1].content)
Core concepts
1. Models - LLM abstraction
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI
# Swap providers easily
llm = ChatOpenAI(model="gpt-4o")
llm = ChatAnthropic(model="claude-sonnet-4-5-20250929")
llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash-exp")
# Streaming
for chunk in llm.stream("Write a poem"):
print(chunk.content, end="", flush=True)
2. Chains - Sequential operations
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
# Define prompt template
prompt = PromptTemplate(
input_variables=["topic"],
template="Write a 3-sentence summary about {topic}"
)
# Create chain
chain = LLMChain(llm=llm, prompt=prompt)
# Run chain
result = chain.run(topic="machine learning")
3. Agents - Tool-using reasoning
ReAct (Reasoning + Acting) pattern:
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import Tool
from scripts.safe_arithmetic import calculate
# Define custom tool
calculator = Tool(
name="Calculator",
func=lambda x: str(calculate(x)),
description="Useful for arithmetic with numbers and +, -, *, /."
)
# Create agent with tools
agent = create_tool_calling_agent(
llm=llm,
tools=[calculator, search_web],
prompt="Answer questions using available tools"
)
# Create executor
agent_executor = AgentExecutor(agent=agent, tools=[calculator], verbose=True)
# Run with reasoning
result = agent_executor.invoke({"input": "What is 25 * 17 + 142?"})
4. Memory - Conversation history
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
# Add memory to track conversation
memory = ConversationBufferMemory()
conversation = ConversationChain(
llm=llm,
memory=memory,
verbose=True
)
# Multi-turn conversation
conversation.predict(input="Hi, I'm Alice")
conversation.predict(input="What's my name?") # Remembers "Alice"
RAG (Retrieval-Augmented Generation)
Details, code examples and parameter tables: references/rag-retrieval-augmented-generation.md. Read it when this step applies.
Advanced agent patterns
Structured output
from langchain_core.pydantic_v1 import BaseModel, Field
# Define schema
class WeatherReport(BaseModel):
city: str = Field(description="City name")
temperature: float = Field(description="Temperature in Fahrenheit")
condition: str = Field(description="Weather condition")
# Get structured response
structured_llm = llm.with_structured_output(WeatherReport)
result = structured_llm.invoke("What's the weather in SF? It's 65F and sunny")
print(result.city, result.temperature, result.condition)
Parallel tool execution
from langchain.agents import create_tool_calling_agent
# Agent automatically parallelizes independent tool calls
agent = create_tool_calling_agent(
llm=llm,
tools=[get_weather, search_web, calculator]
)
# This will call get_weather("Paris") and get_weather("London") in parallel
result = agent.invoke({
"messages": [{"role": "user", "content": "Compare weather in Paris and London"}]
})
Streaming agent execution
# Stream agent steps
for step in agent_executor.stream({"input": "Research AI trends"}):
if "actions" in step:
print(f"Tool: {step['actions'][0].tool}")
if "output" in step:
print(f"Output: {step['output']}")
Common patterns
Multi-document QA
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
# Load multiple documents
docs = [
loader.load("https://docs.python.org"),
loader.load("https://docs.numpy.org")
]
# QA with source citations
chain = load_qa_with_sources_chain(llm, chain_type="stuff")
result = chain({"input_documents": docs, "question": "How to use numpy arrays?"})
print(result["output_text"]) # Includes source citations
Custom tools with error handling
from langchain.tools import tool
@tool
def risky_operation(query: str) -> str:
"""Perform a risky operation that might fail."""
try:
# Your operation here
result = perform_operation(query)
return f"Success: {result}"
except Exception as e:
return f"Error: {str(e)}"
# Agent handles errors gracefully
agent = create_agent(model=llm, tools=[risky_operation])
LangSmith observability
import os
# Enable tracing
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "your-api-key"
os.environ["LANGCHAIN_PROJECT"] = "my-project"
# All chains/agents automatically traced
agent = create_agent(model=llm, tools=[calculator])
result = agent.invoke({"input": "Calculate 123 * 456"})
# View traces at smith.langchain.com
Vector stores
Chroma (local)
from langchain_chroma import Chroma
vectorstore = Chroma.from_documents(
documents=docs,
embedding=OpenAIEmbeddings(),
persist_directory="./chroma_db"
)
Pinecone (cloud)
from langchain_pinecone import PineconeVectorStore
vectorstore = PineconeVectorStore.from_documents(
documents=docs,
embedding=OpenAIEmbeddings(),
index_name="my-index"
)
FAISS (similarity search)
from langchain_community.vectorstores import FAISS
vectorstore = FAISS.from_documents(docs, OpenAIEmbeddings())
vectorstore.save_local("faiss_index")
# Load later
vectorstore = FAISS.load_local("faiss_index", OpenAIEmbeddings())
Document loaders
# Web pages
from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://example.com")
# PDFs
from langchain_community.document_loaders import PyPDFLoader
loader = PyPDFLoader("paper.pdf")
# GitHub
from langchain_community.document_loaders import GithubFileLoader
loader = GithubFileLoader(repo="user/repo", file_filter=lambda x: x.endswith(".py"))
# CSV
from langchain_community.document_loaders import CSVLoader
loader = CSVLoader("data.csv")
Text splitters
# Recursive (recommended for general text)
from langchain.text_splitter import RecursiveCharacterTextSplitter
splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200,
separators=["\n\n", "\n", " ", ""]
)
# Code-aware
from langchain.text_splitter import PythonCodeTextSplitter
splitter = PythonCodeTextSplitter(chunk_size=500)
# Semantic (by meaning)
from langchain_experimental.text_splitter import SemanticChunker
splitter = SemanticChunker(OpenAIEmbeddings())
Best practices
- Start simple - Use
create_agent()for most cases - Enable streaming - Better UX for long responses
- Add error handling - Tools can fail, handle gracefully
- Use LangSmith - Essential for debugging agents
- Optimize chunk size - 500-1000 chars for RAG
- Version prompts - Track changes in production
- Cache embeddings - Expensive, cache when possible
- Monitor costs - Track token usage with LangSmith
Performance benchmarks
| Operation | Latency | Notes |
|---|---|---|
| Simple LLM call | ~1-2s | Depends on provider |
| Agent with 1 tool | ~3-5s | ReAct reasoning overhead |
| RAG retrieval | ~0.5-1s | Vector search + LLM |
| Embedding 1000 docs | ~10-30s | Depends on model |
LangChain vs LangGraph
| Feature | LangChain | LangGraph |
|---|---|---|
| Best for | Quick agents, RAG | Complex workflows |
| Abstraction level | High | Low |
| Code to start | <10 lines | ~30 lines |
| Control | Simple | Full control |
| Stateful workflows | Limited | Native |
| Cyclic graphs | No | Yes |
| Human-in-loop | Basic | Advanced |
Use LangGraph when:
- Need stateful workflows with cycles
- Require fine-grained control
- Building multi-agent systems
- Production apps with complex logic
References
- Agents Guide - ReAct, tool calling, streaming
- RAG Guide - Document loaders, retrievers, QA chains
- Integration Guide - Vector stores, LangSmith, deployment
Resources
- GitHub: https://github.com/langchain-ai/langchain ⭐ 119,000+
- Docs: https://docs.langchain.com
- API Reference: https://reference.langchain.com/python
- LangSmith: https://smith.langchain.com (observability)
- Version: 0.3+ (stable)
- License: MIT
Agent operating procedure
- Check the environment. Confirm the framework version, model provider, API keys and rate limits.
- Pin down the inputs. Confirm formats, identifiers and parameters from the data or the user. Ask rather than guess any value that changes the result.
- Run a small version first. Test a single call or chain with a known input and inspect raw outputs.
- Execute the full task using the instructions and references above.
- Validate the result. Evaluate on a small labeled set; check structured outputs against their schema; log prompts and responses.
- Report. State what was run (versions, commands, parameters), what was checked, and what is still uncertain.
| If this happens | Do this |
|---|---|
| Outputs do not match the expected schema | Add validation and retries, tighten the schema, or simplify the prompt. |
| A function, flag or endpoint in these instructions is missing in the installed version | Check the installed version's own documentation (help(), --help, official docs), adapt, and tell the user. Never invent an API. |
| A required input, identifier or parameter is ambiguous | Ask the user, or state the assumption explicitly before running. |
Integrity rules
- Never fabricate results, parameters, identifiers, citations or statistics. If something cannot be run or verified, say so plainly.
- Never send private or sensitive data to external APIs without the user's consent.
- Treat version-specific details here as possibly outdated: confirm them against the official documentation for the installed version.
- Ask before actions that cost money, consume shared GPUs or cloud quota, touch personal or patient data, or cannot be undone.
Related skills
llamaindex: Data framework for building LLM applications with RAG.autogpt-agents: Autonomous AI agent platform for building and deploying continuous agents.chroma: Open-source embedding database for AI applications.
Trigger Prompts & Evaluation Corpus
These evaluation prompts test that the agent correctly selects langchain for relevant tasks and leaves it out for near misses.
Should trigger (3)
- should trigger
“How do I make a LangChain agent that can call a web search tool?”
expects Shows creating an agent with create_agent (or the installed version's equivalent) with a defined tool and a model, and runs a small test call. Notes that APIs vary by version and should be checked against the installed one.
- should trigger
“I'm in my lab's repo with 40 PDFs of protocol papers in ./papers. I'm using langchain 0.3 with Chroma and an Anthropic model. When I query, retrieval returns chunks that cut sentences in half and the answers miss context. Can you fix my pipeline so it loads the PDFs, splits them sensibly, and answers questions with sources?”
expects Uses a PDF document loader, a RecursiveCharacterTextSplitter with sensible chunk size (about 500-1000 chars) and overlap, and a Chroma vector store with a retriever feeding the Anthropic model. Returns source metadata, tests on a small query first, and checks the installed version's API rather than inventing functions.
- should trigger
“I want a chatbot for my group's wiki that remembers what was said earlier in the conversation, and I want to be able to switch between OpenAI and Gemini without rewriting everything. What should I use and how do I set it up?”
expects Recommends a provider-agnostic framework such as LangChain and shows how to swap chat models behind one interface, with conversation memory or message history. Asks about or states assumptions on API keys, provider and version, and runs a small test first.
Near misses (2)
- near miss
“I have a large folder of mixed documents and want to build a document Q&A system using LlamaIndex with its 300+ data connectors and a VectorStoreIndex query engine. How do I ingest and query them?”
expects Should use the llamaindex skill, since the user explicitly asks for LlamaIndex ingestion and query engines, not LangChain.
- near miss
“Our Chroma collection is slow when I filter by metadata across 2 million embeddings. How do I add a where filter and tune the collection settings?”
expects Should use the chroma skill, since the question is about the Chroma database's filtering and performance, not LangChain orchestration.