← 返回首页
🧠

LangChain基础：构建LLM应用的核心框架

📂 llm ⏱ 2 min 344 words

--- title: "LangChain基础：构建LLM应用的核心框架" description: "系统学习LangChain的核心组件、链式调用和代理机制，掌握LLM应用开发的完整流程" tags: ["LangChain", "LLM应用", "Chain", "Agent"] category: "llm" icon: "🧠"

LangChain基础：构建LLM应用的核心框架

LangChain简介

LangChain是一个用于开发LLM驱动应用的开源框架。它提供了一套完整的工具链，帮助开发者将大语言模型与外部数据源、API和工具集成，构建强大的AI应用。LangChain的设计理念是"可组合性"，允许开发者像搭积木一样组合各种组件。

LangChain的核心组件：

安装与配置

# 安装LangChain核心
pip install langchain

# 安装常用集成
pip install langchain-openai langchain-community langchain-chroma

# 设置环境变量
export OPENAI_API_KEY="your-api-key"

Models：模型接口

LangChain提供了统一的模型接口：

from langchain_openai import ChatOpenAI, OpenAIEmbeddings

# Chat模型
llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.7,
    max_tokens=1000
)

# 调用模型
from langchain_core.messages import HumanMessage, SystemMessage

response = llm.invoke([
    SystemMessage(content="你是一个有帮助的助手"),
    HumanMessage(content="什么是机器学习？")
])
print(response.content)

# Embedding模型
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector = embeddings.embed_query("机器学习")
print(f"向量维度: {len(vector)}")

Prompts：提示词模板

LangChain提供了强大的提示词管理系统：

from langchain_core.prompts import ChatPromptTemplate, PromptTemplate

# 简单模板
template = PromptTemplate(
    input_variables=["topic"],
    template="请用简洁的语言解释{topic}"
)
prompt = template.invoke({"topic": "深度学习"})
print(prompt)

# 聊天模板
chat_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个{role}专家"),
    ("human", "{question}")
])

messages = chat_prompt.invoke({
    "role": "Python",
    "question": "如何学习Python？"
})
print(messages)

Chains：链式调用

Chains是LangChain的核心概念，用于组合多个组件：

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 创建简单的Chain
llm = ChatOpenAI(model="gpt-3.5-turbo")
prompt = ChatPromptTemplate.from_template(
    "用一句话解释{topic}"
)
parser = StrOutputParser()

# 使用LCEL（LangChain Expression Language）构建链
chain = prompt | llm | parser

# 调用链
result = chain.invoke({"topic": "量子计算"})
print(result)

# 带记忆的链
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory

# 会话存储
store = {}

def get_session_history(session_id):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

# 添加记忆的链
with_message_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="question"
)

# 多轮对话
config = {"configurable": {"session_id": "abc123"}}
response1 = with_message_history.invoke(
    {"topic": "机器学习"},
    config=config
)
response2 = with_message_history.invoke(
    {"topic": "深度学习"},
    config=config
)

Output Parsers：输出解析

将LLM的输出转换为结构化数据：

from langchain_core.output_parsers import JsonOutputParser
from langchain_core.pydantic_v1 import BaseModel, Field

# 定义输出结构
class MovieReview(BaseModel):
    title: str = Field(description="电影名称")
    rating: float = Field(description="评分1-10")
    summary: str = Field(description="简短总结")

# 创建解析器
parser = JsonOutputParser(pydantic_object=MovieReview)

# 提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "分析电影并返回JSON格式结果\n{format_instructions}"),
    ("human", "分析电影：{movie}")
])

# 构建链
chain = prompt | llm | parser
result = chain.invoke({
    "movie": "盗梦空间",
    "format_instructions": parser.get_format_instructions()
})
print(result)

实用工具

from langchain_core.tools import tool

# 自定义工具
@tool
def calculate(expression: str) -> str:
    """计算数学表达式"""
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"计算错误: {e}"

# 使用工具
from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor

llm = ChatOpenAI(model="gpt-3.5-turbo")
tools = [calculate]

# 创建Agent
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 运行
result = agent_executor.invoke({"input": "计算 123 * 456 + 789"})
print(result["output"])

最佳实践

  1. 使用LCEL：优先使用LangChain Expression Language构建链
  2. 错误处理：使用try-except包装LLM调用
  3. 异步支持：使用ainvoke进行异步调用
  4. 流式输出：使用stream方法获取流式响应
# 流式输出示例
for chunk in chain.stream({"topic": "机器学习"}):
    print(chunk, end="", flush=True)

LangChain通过其灵活的设计和丰富的组件，成为构建LLM应用的首选框架。