名称: langchain 描述: 用于构建由大型语言模型驱动的应用程序的框架，支持代理、链和检索增强生成(RAG)。支持多种提供商（OpenAI、Anthropic、Google），500多个集成，ReAct代理、工具调用、内存管理和向量存储检索。用于构建聊天机器人、问答系统、自主代理或RAG应用程序。最适合快速原型开发和生产部署。版本: 1.0.0 作者: Orchestra Research 许可证: MIT 标签: [代理, LangChain, RAG, 工具调用, ReAct, 内存管理, 向量存储, LLM应用程序, 聊天机器人, 生产] 依赖项: [langchain, langchain-core, langchain-openai, langchain-anthropic]

LangChain - 使用代理和RAG构建LLM应用程序

构建LLM驱动应用程序的最流行框架。

何时使用LangChain

使用LangChain当：

构建具有工具调用和推理（ReAct模式）的代理
实现RAG（检索增强生成）管道
需要轻松切换LLM提供商（OpenAI、Anthropic、Google）
创建具有对话记忆的聊天机器人
快速原型开发LLM应用程序
生产部署，配合LangSmith可观察性

指标：

119,000+ GitHub星标
272,000+ 代码库 使用LangChain
500+ 集成（模型、向量存储、工具）
3,800+ 贡献者

改用替代方案：

LlamaIndex：专注于RAG，更适合文档问答
LangGraph：复杂状态工作流，更多控制
Haystack：生产搜索管道
Semantic Kernel：微软生态系统

快速入门

安装

# 核心库（Python 3.10+）
pip install -U langchain

# 使用OpenAI
pip install langchain-openai

# 使用Anthropic
pip install langchain-anthropic

# 常见额外功能
pip install langchain-community  # 500多个集成
pip install langchain-chroma     # 向量存储

基本LLM使用

from langchain_anthropic import ChatAnthropic

# 初始化模型
llm = ChatAnthropic(model="claude-sonnet-4-5-20250929")

# 简单完成
response = llm.invoke("用两句话解释量子计算")
print(response.content)

创建代理（ReAct模式）

from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic

# 定义工具
def get_weather(city: str) -> str:
    """获取城市的当前天气。"""
    return f"在{city}天气晴朗，72°F"

def search_web(query: str) -> str:
    """在网络上搜索信息。"""
    return f"搜索结果：{query}"

# 创建代理（<10行代码！）
agent = create_agent(
    model=ChatAnthropic(model="claude-sonnet-4-5-20250929"),
    tools=[get_weather, search_web],
    system_prompt="你是一个有帮助的助手。需要时使用工具。"
)

# 运行代理
result = agent.invoke({"messages": [{"role": "user", "content": "巴黎的天气怎么样？"}]})
print(result["messages"][-1].content)

核心概念

1. 模型 - LLM抽象

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI

# 轻松切换提供商
llm = ChatOpenAI(model="gpt-4o")
llm = ChatAnthropic(model="claude-sonnet-4-5-20250929")
llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash-exp")

# 流式传输
for chunk in llm.stream("写一首诗"):
    print(chunk.content, end="", flush=True)

2. 链 - 顺序操作

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# 定义提示模板
prompt = PromptTemplate(
    input_variables=["topic"],
    template="写一个关于{topic}的3句话摘要"
)

# 创建链
chain = LLMChain(llm=llm, prompt=prompt)

# 运行链
result = chain.run(topic="机器学习")

3. 代理 - 使用工具进行推理

ReAct（推理+行动）模式：

from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import Tool

# 定义自定义工具
calculator = Tool(
    name="计算器",
    func=lambda x: eval(x),
    description="用于数学计算。输入：有效的Python表达式。"
)

# 使用工具创建代理
agent = create_tool_calling_agent(
    llm=llm,
    tools=[calculator, search_web],
    prompt="使用可用工具回答问题"
)

# 创建执行器
agent_executor = AgentExecutor(agent=agent, tools=[calculator], verbose=True)

# 运行带推理
result = agent_executor.invoke({"input": "25 * 17 + 142 是多少？"})

4. 内存 - 对话历史

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# 添加内存以跟踪对话
memory = ConversationBufferMemory()

conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# 多轮对话
conversation.predict(input="嗨，我是Alice")
conversation.predict(input="我的名字是什么？")  # 记住"Alice"

RAG（检索增强生成）

基本RAG管道

from langchain_community.document_loaders import WebBaseLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma
from langchain.chains import RetrievalQA

# 1. 加载文档
loader = WebBaseLoader("https://docs.python.org/3/tutorial/")
docs = loader.load()

# 2. 分割成块
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
splits = text_splitter.split_documents(docs)

# 3. 创建嵌入和向量存储
vectorstore = Chroma.from_documents(
    documents=splits,
    embedding=OpenAIEmbeddings()
)

# 4. 创建检索器
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# 5. 创建QA链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    return_source_documents=True
)

# 6. 查询
result = qa_chain({"query": "什么是Python装饰器？"})
print(result["result"])
print(f"来源：{result['source_documents']}")

带内存的对话式RAG

from langchain.chains import ConversationalRetrievalChain

# 带对话内存的RAG
qa = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=retriever,
    memory=ConversationBufferMemory(
        memory_key="chat_history",
        return_messages=True
    )
)

# 多轮RAG
qa({"question": "Python用于什么？"})
qa({"question": "你能详细说说Web开发吗？"})  # 记住上下文

高级代理模式

结构化输出

from langchain_core.pydantic_v1 import BaseModel, Field

# 定义模式
class WeatherReport(BaseModel):
    city: str = Field(description="城市名称")
    temperature: float = Field(description="温度（华氏度）")
    condition: str = Field(description="天气状况")

# 获取结构化响应
structured_llm = llm.with_structured_output(WeatherReport)
result = structured_llm.invoke("旧金山的天气怎么样？是65°F，晴朗")
print(result.city, result.temperature, result.condition)

并行工具执行

from langchain.agents import create_tool_calling_agent

# 代理自动并行化独立工具调用
agent = create_tool_calling_agent(
    llm=llm,
    tools=[get_weather, search_web, calculator]
)

# 这将并行调用get_weather("巴黎")和get_weather("伦敦")
result = agent.invoke({
    "messages": [{"role": "user", "content": "比较巴黎和伦敦的天气"}]
})

流式代理执行

# 流式代理步骤
for step in agent_executor.stream({"input": "研究AI趋势"}):
    if "actions" in step:
        print(f"工具：{step['actions'][0].tool}")
    if "output" in step:
        print(f"输出：{step['output']}")

常见模式

多文档QA

from langchain.chains.qa_with_sources import load_qa_with_sources_chain

# 加载多个文档
docs = [
    loader.load("https://docs.python.org"),
    loader.load("https://docs.numpy.org")
]

# 带来源引用的QA
chain = load_qa_with_sources_chain(llm, chain_type="stuff")
result = chain({"input_documents": docs, "question": "如何使用numpy数组？"})
print(result["output_text"])  # 包括来源引用

带错误处理的自定义工具

from langchain.tools import tool

@tool
def risky_operation(query: str) -> str:
    """执行可能失败的风险操作。"""
    try:
        # 你的操作在这里
        result = perform_operation(query)
        return f"成功：{result}"
    except Exception as e:
        return f"错误：{str(e)}"

# 代理优雅处理错误
agent = create_agent(model=llm, tools=[risky_operation])

LangSmith可观察性

import os

# 启用追踪
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "your-api-key"
os.environ["LANGCHAIN_PROJECT"] = "my-project"

# 所有链/代理自动追踪
agent = create_agent(model=llm, tools=[calculator])
result = agent.invoke({"input": "计算123 * 456"})

# 在smith.langchain.com查看追踪

向量存储

Chroma（本地）

from langchain_chroma import Chroma

vectorstore = Chroma.from_documents(
    documents=docs,
    embedding=OpenAIEmbeddings(),
    persist_directory="./chroma_db"
)

Pinecone（云）

from langchain_pinecone import PineconeVectorStore

vectorstore = PineconeVectorStore.from_documents(
    documents=docs,
    embedding=OpenAIEmbeddings(),
    index_name="my-index"
)

FAISS（相似性搜索）

from langchain_community.vectorstores import FAISS

vectorstore = FAISS.from_documents(docs, OpenAIEmbeddings())
vectorstore.save_local("faiss_index")

# 稍后加载
vectorstore = FAISS.load_local("faiss_index", OpenAIEmbeddings())

文档加载器

# 网页
from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://example.com")

# PDF
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")

文本分割器

# 递归（推荐用于一般文本）
from langchain.text_splitter import RecursiveCharacterTextSplitter
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["

", "
", " ", ""]
)

# 代码感知
from langchain.text_splitter import PythonCodeTextSplitter
splitter = PythonCodeTextSplitter(chunk_size=500)

# 语义（按含义）
from langchain_experimental.text_splitter import SemanticChunker
splitter = SemanticChunker(OpenAIEmbeddings())

最佳实践

从简单开始 - 大多数情况下使用create_agent()
启用流式传输 - 长响应的更好用户体验
添加错误处理 - 工具可能失败，优雅处理
使用LangSmith - 调试代理的必备工具
优化块大小 - RAG使用500-1000字符
版本化提示 - 生产中跟踪变化
缓存嵌入 - 昂贵，尽可能缓存
监控成本 - 使用LangSmith跟踪令牌使用

性能基准

操作	延迟	备注
简单LLM调用	~1-2秒	取决于提供商
带1个工具的代理	~3-5秒	ReAct推理开销
RAG检索	~0.5-1秒	向量搜索 + LLM
嵌入1000个文档	~10-30秒	取决于模型

LangChain vs LangGraph

功能	LangChain	LangGraph
最适合	快速代理，RAG	复杂工作流
抽象级别	高	低
开始代码	<10行	~30行
控制	简单	完全控制
状态工作流	有限	原生支持
循环图	否	是
人机交互	基本	高级

使用LangGraph当：

需要带循环的状态工作流
需要细粒度控制
构建多代理系统
生产应用带复杂逻辑

参考文献

代理指南 - ReAct, 工具调用, 流式传输
RAG指南 - 文档加载器, 检索器, QA链
集成指南 - 向量存储, LangSmith, 部署

资源

GitHub: https://github.com/langchain-ai/langchain ⭐ 119,000+
文档: https://docs.langchain.com
API参考: https://reference.langchain.com/python
LangSmith: https://smith.langchain.com (可观察性)
版本: 0.3+ (稳定)
许可证: MIT