1.LangChain介绍

LangChain 是一个用于开发大语言模型（LLM）驱动应用的开源框架（Python/JS 库）。它的核心目标是简化将 LLM（如 GPT、Llama 等）与外部数据源、计算逻辑和工具集成的过程，从而构建更强大、可定制化的 AI 应用。

官方文档（https://python.langchain.com）开始，逐步探索各个模块的高级用法。

2.LangChain 能做什么?

场景	主要用途
PromptTemplate	模板化提示词，批量生成不同内容
Chains	把多个步骤串起来，形成完整流程
Memory	保存上下文，实现多轮对话
Retriever + VectorStore	做RAG，先在知识库检索，再生成回答，解决幻觉问题，防止胡编乱造
Agent + Tools	根据用户需求自动选择合适工具，比如先查天气再写诗

3.对比示例(使用LangChain的优点)

直接调用API

import openai
response = openai.chatcompletion.create(
    mode1="gpt-3.5-turbo"
    messages=[{"role":"user","content":"请帮我写一篇面试自我介绍"}]
print(response.choices[o] .message.content)

from langchain.prompts import PromptTemplate
from 1angchain.chains import LLMchain
from langchain_openai import ChatopenAI
llm = ChatOpenAI()
prompt = PromptTemplate.from_template("请帮我写一篇{topic}")
chain = LLMchain(llm=llm, prompt=prompt)
result= chain.run({"topic"："面试自我介绍})
print(result)

对比可以知道，使用框架，我们可以灵活的进行不同需求的实现，还可以有更多的串联步骤

4.LangChain核心模块

一、核心六大模块

1. 模型（Models）

负责与各种语言模型交互

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_community.llms import Ollama

# OpenAI 模型
llm_openai = ChatOpenAI(model="gpt-4-turbo")

# Anthropic 模型
llm_claude = ChatAnthropic(model="claude-3-opus")

# 本地模型
llm_local = Ollama(model="llama3")

2. 提示（Prompts）

管理提示模板和优化

from langchain.prompts import ChatPromptTemplate

template = """
你是一位专业的{role}。请根据以下上下文回答问题：
{context}

问题：{question}
"""

prompt = ChatPromptTemplate.from_template(template)
formatted_prompt = prompt.format(
    role="医生",
    context="患者有发热、咳嗽症状，体温38.5℃",
    question="可能的诊断是什么？"
)

3. 数据连接（Indexes）

集成外部数据源

from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

# 1. 加载文档
loader = WebBaseLoader("https://zh.wikipedia.org/wiki/人工智能")
docs = loader.load()

# 2. 分割文本
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
splits = text_splitter.split_documents(docs)

# 3. 向量化存储
vectorstore = Chroma.from_documents(
    documents=splits, 
    embedding=OpenAIEmbeddings()
)

# 4. 创建检索器
retriever = vectorstore.as_retriever()

4. 记忆（Memory）

管理对话状态和历史

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# 使用示例
memory.save_context(
    {"input": "你好，我叫小明"}, 
    {"output": "你好小明！有什么可以帮你的？"}
)
memory.save_context(
    {"input": "我的名字是什么？"}, 
    {"output": "你叫小明。"}
)

5. 链（Chains）

组合多个组件形成工作流

from langchain.chains import RetrievalQA

# 创建问答链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm_openai,
    chain_type="stuff",
    retriever=retriever,
    memory=memory
)

# 使用链
response = qa_chain.invoke({"query": "人工智能的主要应用领域有哪些？"})
print(response["result"])

6. 代理（Agents）

动态调用工具完成任务

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

# 定义工具
def currency_converter(amount: float, from_currency: str, to_currency: str):
    """货币转换工具"""
    conversion_rates = {"USD": 1, "CNY": 7.2, "EUR": 0.93}
    return amount * conversion_rates[to_currency] / conversion_rates[from_currency]

tools = [
    Tool(
        name="CurrencyConverter",
        func=currency_converter,
        description="货币转换工具，支持USD, CNY, EUR"
    )
]

# 创建代理
agent = create_tool_calling_agent(
    llm=llm_openai,
    tools=tools,
    prompt=prompt
)

# 执行代理
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = agent_executor.invoke({
    "input": "请将100美元转换为人民币"
})

二、高级应用模式

1. 检索增强生成（RAG）

from langchain_core.runnables import RunnablePassthrough

# 定义RAG管道
rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm_openai
    | StrOutputParser()
)
 
# 使用RAG
response = rag_chain.invoke("LangChain是什么？")

2. 多智能体协作

from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.agents import initialize_multi_agent

# 定义不同角色的代理
researcher = create_openai_tools_agent(
    llm=llm_openai,
    tools=[web_search_tool],
    system_message="你是一名研究人员"
)

writer = create_openai_tools_agent(
    llm=llm_openai,
    tools=[drafting_tool],
    system_message="你是一名内容撰写者"
)

# 初始化多代理系统
team = initialize_multi_agent(
    agents=[researcher, writer],
    manager_llm=llm_openai
)

# 执行团队任务
result = team.invoke("撰写一篇关于量子计算的科普文章")

3. 结构化输出

from langchain_core.pydantic_v1 import BaseModel, Field

# 定义输出结构
class PatientInfo(BaseModel):
    name: str = Field(description="患者姓名")
    age: int = Field(description="患者年龄")
    symptoms: list[str] = Field(description="症状列表")
    diagnosis: str = Field(description="初步诊断")

# 创建带结构化输出的链
structured_chain = llm_openai.with_structured_output(PatientInfo)

# 使用
medical_text = "患者张三，45岁，主诉头痛、发热三天，体温38.2℃"
result = structured_chain.invoke(f"从以下文本提取患者信息：{medical_text}")
print(f"姓名: {result.name}, 诊断: {result.diagnosis}")

三、最佳实践

1. 性能优化技巧

# 流式响应
for chunk in qa_chain.stream({"query": "解释深度学习原理"}):
    print(chunk["result"], end="", flush=True)

# 批量处理
questions = ["什么是机器学习？", "监督学习和无监督学习的区别？"]
results = qa_chain.batch([{"query": q} for q in questions])

# 异步调用
async def run_chain():
    return await qa_chain.ainvoke({"query": "AI的未来发展趋势"})

2. 错误处理

from langchain_core.runnables import RunnableLambda

def handle_errors(input_dict):
    try:
        # 正常执行
        return qa_chain.invoke(input_dict)
    except Exception as e:
        # 错误处理
        return {"result": f"处理请求时出错: {str(e)}"}

safe_chain = RunnableLambda(handle_errors)

3. 部署与监控

# 使用LangServe部署API
from langchain.chains import RetrievalQA
from langserve import add_routes

app = FastAPI()
chain = RetrievalQA.from_chain_type(...)
add_routes(app, chain, path="/qa")

# 集成监控
from langchain.callbacks import LangChainTracer

tracer = LangChainTracer()
chain = RetrievalQA.from_chain_type(..., callbacks=[tracer])

四、实际应用场景

1. 企业知识库问答

qa_system = RetrievalQA.from_chain_type(
    llm=llm_openai,
    retriever=vectorstore.as_retriever(search_kwargs={"k": 5}),
    chain_type="map_reduce"
)

2. 自动化数据分析

agent = create_pandas_dataframe_agent(
    llm=llm_openai,
    df=pd.read_csv("sales_data.csv"),
    verbose=True
)
agent.run("分析第四季度销售趋势")

3. 智能文档处理

from langchain.chains import AnalyzeDocumentChain
from langchain.chains.summarize import load_summarize_chain

summary_chain = load_summarize_chain(llm_openai, chain_type="map_reduce")
summarize_document = AnalyzeDocumentChain(combine_docs_chain=summary_chain)
summarize_document.run("大型法律文档.pdf")

LangChain 的强大之处在于这些模块可以灵活组合，构建从简单问答到复杂工作流的各种应用。