langchain二次开发:入门

第一章：入门基础

1.1 LangChain 是什么

1.1.1 背景与诞生

在2022年底，OpenAI发布ChatGPT之后，大型语言模型（Large Language Models, LLMs）迎来了爆发式增长。开发者们很快发现，虽然这些模型拥有强大的语言理解和生成能力，但将它们集成到实际应用中却面临诸多挑战：

  1. 上下文管理困难：LLM是无状态的，无法记住之前的对话内容
  2. 数据集成复杂：如何让模型访问外部数据源（数据库、文档、API等）
  3. 提示工程繁琐：编写、管理和优化提示词（Prompt）需要大量经验
  4. 链式调用复杂：复杂的任务需要多个LLM调用协同完成
  5. 生产化部署困难：从原型到生产环境需要解决监控、调试、性能等问题

正是为了解决这些问题，LangChain于2022年10月由Harrison Chase创建。它是一个开源的Python（后来也支持JavaScript/TypeScript）框架，旨在帮助开发者更轻松地构建基于LLM的应用程序。

1.1.2 LangChain 的核心理念

LangChain的核心理念可以概括为：将语言模型作为核心计算单元，通过组件化的方式构建复杂应用。

这个理念包含几个关键要点：

1. 组件化设计

LangChain将LLM应用所需的功能拆分为独立的、可复用的组件：

  • Models：与各种LLM的接口
  • Prompts：提示词管理
  • Chains：将多个组件串联起来
  • Indexes：文档索引和检索
  • Memory：状态管理
  • Agents：智能代理

2. 链式思维

复杂任务往往需要通过多个步骤完成。LangChain提供了“Chain”（链）的概念，允许开发者将多个操作串联起来，形成处理流程。

3. 数据感知

LLM本身只拥有训练数据中的知识。LangChain通过Indexes和Retrievers，让模型能够访问外部数据源，实现“检索增强生成”（RAG）。

4. 代理能力

通过Agents，LLM可以自主决策，选择使用哪些工具来完成任务，实现真正的智能化应用。

1.1.3 LangChain 的应用场景

LangChain适用于多种应用场景：

应用场景 说明 典型示例
问答系统 基于文档的智能问答 企业内部知识库、客服机器人
聊天机器人 具有记忆的对话系统 个人助手、智能客服
代码助手 代码生成与分析 GitHub Copilot类产品
数据分析 自然语言查询数据 “今年销售额趋势如何？”
内容生成 自动化内容创作 营销文案、新闻报道
智能代理 自主任务执行 自动预订、信息收集
工作流自动化 多步骤业务流程 审批流程、数据同步

1.1.4 LangChain 的架构概览

┌─────────────────────────────────────────────────────────────┐
│                      应用层 (Applications)                   │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐     │
│  │ 聊天机器人│  │ 问答系统 │  │ 代码助手  │  │ 智能代理  │     │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘     │
└─────────────────────────────────────────────────────────────┘
                              │
┌─────────────────────────────────────────────────────────────┐
│                      链层 (Chains)                           │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐     │
│  │ LLM Chain│  │ RAG Chain│  │Agent Chain│ │ 自定义链 │     │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘     │
└─────────────────────────────────────────────────────────────┘
                              │
┌─────────────────────────────────────────────────────────────┐
│                     组件层 (Components)                      │
│  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐ │
│  │Models│  │Prompts│ │Indexes│ │Memory│  │Agents│  │Tools │ │
│  └──────┘  └──────┘  └──────┘  └──────┘  └──────┘  └──────┘ │
└─────────────────────────────────────────────────────────────┘
                              │
┌─────────────────────────────────────────────────────────────┐
│                      模型层 (LLMs)                           │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐     │
│  │  OpenAI  │  │Anthropic │  │ 本地模型  │  │  其他    │     │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘     │
└─────────────────────────────────────────────────────────────┘

LangChain的架构分为四个层次：

  1. 模型层：与各种LLM提供商的接口
  2. 组件层：构成应用的基本单元
  3. 链层：将组件组合成可执行的工作流
  4. 应用层：面向最终用户的完整应用

这种分层架构使得LangChain既灵活又强大：开发者可以从底层组件开始构建，也可以直接使用高层抽象快速开发应用。

1.1.5 LangChain 与其他框架的比较

特性 LangChain LlamaIndex Semantic Kernel Haystack
主要语言 Python/JS Python Python/C# Python
核心优势 通用性、生态 检索增强 微软生态 搜索/NLP
易用性 ⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐
灵活性 ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐
企业级 ⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐
社区活跃度 ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐ ⭐⭐⭐ ⭐⭐⭐

LangChain的最大优势在于其：

  • 丰富的集成：支持几乎所有主流LLM和工具
  • 活跃的社区：大量教程、插件和开源项目
  • 快速迭代：紧跟AI领域最新发展
  • 企业级功能：LangSmith和LangServe提供完整的生产支持

1.2 核心概念详解

1.2.1 语言模型（Language Models）

语言模型是LangChain的核心。在LangChain中，主要有两类模型：

1. LLMs（纯文本补全模型）

这类模型接收文本输入，输出文本。典型的代表是OpenAI的早期模型如text-davinci-003。 

from langchain.llms import OpenAI
 
llm = OpenAI()
response = llm.predict("你好，请介绍一下自己")
print(response)

2. Chat Models（对话模型）

这类模型专为对话场景设计，接收消息列表，输出消息。代表是GPT-4、Claude等现代模型。 

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage
 
chat = ChatOpenAI()
messages = [
    SystemMessage(content="你是一个有用的助手"),
    HumanMessage(content="你好")
]
response = chat.predict_messages(messages)
print(response.content)

3. 文本嵌入模型（Embeddings）

用于将文本转换为向量表示，是语义搜索和RAG的基础。 

from langchain.embeddings import OpenAIEmbeddings
 
embeddings = OpenAIEmbeddings()
text = "这是一段测试文本"
vector = embeddings.embed_query(text)
print(f"向量维度: {len(vector)}")

1.2.2 提示词（Prompts）

提示词是与语言模型交互的桥梁。LangChain提供了强大的提示词管理功能：

1. PromptTemplate（提示词模板）

允许创建可复用的、带变量的提示词模板。 

from langchain.prompts import PromptTemplate
 
template = """
你是一个{role}。请用{style}的风格回答以下问题：
 
问题：{question}
"""
 
prompt = PromptTemplate.from_template(template)
formatted_prompt = prompt.format(
    role="技术专家",
    style="通俗易懂",
    question="什么是机器学习？"
)
print(formatted_prompt)

2. ChatPromptTemplate（对话提示词模板）

专为对话模型设计的模板。 

from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
 
system_template = "你是一个{field}领域的专家"
system_prompt = SystemMessagePromptTemplate.from_template(system_template)
 
human_template = "请解释{topic}"
human_prompt = HumanMessagePromptTemplate.from_template(human_template)
 
chat_prompt = ChatPromptTemplate.from_messages([system_prompt, human_prompt])
 
messages = chat_prompt.format_messages(field="人工智能", topic="神经网络")
for msg in messages:
    print(f"{msg.type}: {msg.content}")

1.2.3 链（Chains）

链是LangChain的核心抽象，表示将多个组件组合成一个可执行的工作流。

1. 简单链（LLMChain）

最基本的链，将提示词模板和语言模型连接起来。 

from langchain import LLMChain
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
 
llm = ChatOpenAI()
prompt = ChatPromptTemplate.from_template("用一句话解释{concept}")
 
chain = LLMChain(llm=llm, prompt=prompt)
result = chain.predict(concept="区块链")
print(result)

2. 复杂链

可以组合多个链，实现更复杂的逻辑。 

from langchain.chains import SimpleSequentialChain
 
# 第一个链：生成故事标题
title_prompt = ChatPromptTemplate.from_template("为{topic}生成一个吸引人的标题")
title_chain = LLMChain(llm=llm, prompt=title_prompt, output_key="title")
 
# 第二个链：基于标题写故事
story_prompt = ChatPromptTemplate.from_template("基于标题'{title}'写一个100字的故事")
story_chain = LLMChain(llm=llm, prompt=story_prompt, output_key="story")
 
# 组合链
overall_chain = SimpleSequentialChain(chains=[title_chain, story_chain])
result = overall_chain.run("太空探索")
print(result)

1.2.4 索引与检索（Indexes & Retrievers）

这是实现RAG（检索增强生成）的基础。

1. Document Loader（文档加载器）

从各种来源加载文档。 

from langchain.document_loaders import TextLoader, PyPDFLoader, WebBaseLoader
 
# 加载文本文件
text_loader = TextLoader("data/article.txt")
text_docs = text_loader.load()
 
# 加载PDF
pdf_loader = PyPDFLoader("data/paper.pdf")
pdf_docs = pdf_loader.load()
 
# 加载网页
web_loader = WebBaseLoader("https://example.com/article")
web_docs = web_loader.load()

2. Text Splitter（文本分割器）

将长文档分割成适合处理的片段。 

from langchain.text_splitter import RecursiveCharacterTextSplitter
 
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,      # 每块最大字符数
    chunk_overlap=200     # 块之间重叠的字符数
)
 
chunks = text_splitter.split_documents(pdf_docs)
print(f"分割成 {len(chunks)} 个片段")

3. Vector Store（向量存储）

存储文档的向量表示，支持语义检索。 

from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
 
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)
 
# 检索相似文档
results = vectorstore.similarity_search("人工智能的发展", k=3)
for doc in results:
    print(doc.page_content[:200])

1.2.5 记忆（Memory）

记忆机制让链能够记住之前的交互。 

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
 
memory = ConversationBufferMemory()
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)
 
# 第一轮对话
response1 = conversation.predict(input="你好，我叫张三")
print(response1)
 
# 第二轮对话 - 模型会记得名字
response2 = conversation.predict(input="还记得我叫什么吗？")
print(response2)
 
# 查看记忆内容
print(memory.load_memory_variables({}))

1.2.6 代理（Agents）

代理让LLM能够自主决策，使用工具完成任务。 

from langchain.agents import initialize_agent, Tool
from langchain.tools import DuckDuckGoSearchRun
 
# 定义工具
search = DuckDuckGoSearchRun()
tools = [
    Tool(
        name="搜索",
        func=search.run,
        description="用于搜索互联网上的实时信息"
    )
]
 
# 初始化代理
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent="zero-shot-react-description",
    verbose=True
)
 
# 运行代理
response = agent.run("今天的比特币价格是多少？")
print(response)

1.3 安装与环境配置

1.3.1 环境要求

  • Python: 3.8.1 或更高版本（推荐 3.10+）
  • 操作系统: Windows、macOS、Linux 均可
  • 内存: 建议 8GB+，如果使用本地模型需要更多
  • 网络: 需要访问OpenAI等API（或使用代理）

1.3.2 安装 LangChain

1. 基础安装

# 创建虚拟环境（推荐）
python -m venv langchain_env
source langchain_env/bin/activate  # Linux/Mac
# 或 langchain_env\Scripts\activate  # Windows
 
# 安装基础包
pip install langchain

2. 安装特定集成

LangChain采用模块化设计，核心包只包含基础功能，特定集成需要单独安装： 

# OpenAI 集成
pip install langchain-openai
 
# Anthropic (Claude) 集成
pip install langchain-anthropic
 
# HuggingFace 集成（本地模型）
pip install langchain-huggingface
 
# 常用的文档加载器
pip install langchain-community
 
# 向量数据库
pip install chromadb           # Chroma
pip install faiss-cpu          # FAISS (CPU版本)
pip install faiss-gpu          # FAISS (GPU版本)
pip install pinecone-client    # Pinecone

3. 完整开发环境安装

# 一键安装所有常用依赖
pip install langchain langchain-openai langchain-community
pip install chromadb faiss-cpu
pip install pypdf unstructured
pip install beautifulsoup4 requests
pip install python-dotenv

1.3.3 API密钥配置

1. 使用环境变量（推荐）

创建 `.env` 文件： 

# .env
OPENAI_API_KEY=your_openai_api_key_here
ANTHROPIC_API_KEY=your_anthropic_api_key_here
HUGGINGFACE_API_TOKEN=your_hf_token_here

加载环境变量： 

from dotenv import load_dotenv
import os
 
load_dotenv()
 
openai_api_key = os.getenv("OPENAI_API_KEY")
print(f"API Key: {openai_api_key[:10]}...")  # 只显示前10个字符

2. 直接在代码中设置

import os
 
os.environ["OPENAI_API_KEY"] = "your-api-key-here"
# 或者
# os.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI API Key: ")

3. 传递给类构造函数

from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(api_key="your-api-key-here")

1.3.4 验证安装

创建一个测试脚本来验证环境： 

# test_installation.py
import sys
 
def check_installation():
    """检查LangChain及其依赖的安装情况"""
 
    print("=" * 50)
    print("LangChain 环境检查")
    print("=" * 50)
 
    # 检查Python版本
    print(f"\nPython 版本: {sys.version}")
 
    # 检查LangChain
    try:
        import langchain
        print(f"✓ langchain 已安装，版本: {langchain.__version__}")
    except ImportError:
        print("✗ langchain 未安装")
 
    # 检查各种集成
    integrations = [
        ("langchain_openai", "OpenAI 集成"),
        ("langchain_anthropic", "Anthropic 集成"),
        ("langchain_community", "社区集成"),
    ]
 
    print("\n集成包检查:")
    for module, name in integrations:
        try:
            __import__(module)
            print(f"✓ {name} 已安装")
        except ImportError:
            print(f"✗ {name} 未安装")
 
    # 检查向量数据库
    vectorstores = [
        ("chromadb", "Chroma"),
        ("faiss", "FAISS"),
    ]
 
    print("\n向量数据库检查:")
    for module, name in vectorstores:
        try:
            __import__(module)
            print(f"✓ {name} 已安装")
        except ImportError:
            print(f"✗ {name} 未安装")
 
    # 检查API密钥
    print("\nAPI密钥检查:")
    import os
    api_keys = ["OPENAI_API_KEY", "ANTHROPIC_API_KEY"]
    for key in api_keys:
        if os.getenv(key):
            print(f"✓ {key} 已设置")
        else:
            print(f"✗ {key} 未设置")
 
    print("\n" + "=" * 50)
 
if __name__ == "__main__":
    check_installation()

运行检查： 

python test_installation.py

1.3.5 配置国内访问（如需要）

如果在无法直接访问OpenAPI的地区，可以使用代理：

1. 设置代理环境变量

import os
 
# 设置代理
os.environ["HTTP_PROXY"] = "http://your-proxy:port"
os.environ["HTTPS_PROXY"] = "http://your-proxy:port"
 
# 或者使用OpenAI的base_url指向国内镜像
os.environ["OPENAI_BASE_URL"] = "https://your-proxy-url/v1"

2. 在代码中配置

from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(
    base_url="https://api.example.com/v1",  # 使用镜像地址
    api_key="your-api-key"
)

1.4 第一个 Hello World 程序

1.4.1 最简单的LangChain程序

让我们从最基础的程序开始： 

# hello_world.py
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
 
# 1. 创建语言模型实例
llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.7
)
 
# 2. 创建提示词模板
prompt = ChatPromptTemplate.from_template("请用中文回答：{question}")
 
# 3. 组合成链
chain = prompt | llm
 
# 4. 运行
response = chain.invoke({"question": "什么是LangChain？"})
print(response.content)

1.4.2 逐步解析

让我们详细解析这个程序的每个部分：

1. 导入模块

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
  • `ChatOpenAI`: 与OpenAI聊天模型的接口
  • `ChatPromptTemplate`: 用于构建对话提示词的模板

2. 创建语言模型实例

llm = ChatOpenAI(
    model="gpt-3.5-turbo",    # 使用的模型名称
    temperature=0.7            # 创造性程度 (0-2)
)

参数说明：

  • `model`: 模型标识符，可选值包括：
    • `gpt-3.5-turbo`: 速度快、成本低
    • `gpt-4`: 能力更强、成本更高
    • `gpt-4-turbo`: GPT-4的优化版本
  • `temperature`: 控制输出的随机性
    • 0.0: 最确定性，适合需要精确答案的场景
    • 0.7: 平衡的创造性
    • 1.0+: 更具创造性，可能产生意外结果
  • `max_tokens`: 最大输出token数
  • `api_key`: API密钥（如果没有设置环境变量）

3. 创建提示词模板

prompt = ChatPromptTemplate.from_template("请用中文回答：{question}")

模板中的 `{question}` 是一个变量占位符，运行时会被替换为实际值。

4. 组合链（使用LCEL语法）

chain = prompt | llm

这是LangChain Expression Language (LCEL)的语法，`|` 操作符表示将前一个组件的输出传递给后一个组件。

这行代码等价于： 

from langchain.chains import LLMChain
 
chain = LLMChain(prompt=prompt, llm=llm)

5. 运行链

response = chain.invoke({"question": "什么是LangChain？"})

* `invoke`: 同步调用链 * 参数是一个字典，键对应模板中的变量名 * 返回的是模型的输出

1.4.3 添加输出解析器

默认情况下，模型的输出是`AIMessage`对象。我们可以添加输出解析器来获得更干净的输出： 

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
 
llm = ChatOpenAI(model="gpt-3.5-turbo")
prompt = ChatPromptTemplate.from_template("请用一句话解释{concept}")
 
# 添加字符串输出解析器
output_parser = StrOutputParser()
 
# 链：提示词 -> 模型 -> 解析器
chain = prompt | llm | output_parser
 
# 运行并获得字符串输出
result = chain.invoke({"concept": "机器学习"})
print(result)  # 直接是字符串，不是AIMessage
print(type(result))  # <class 'str'>

1.4.4 添加记忆功能

让程序记住之前的对话： 

from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
 
llm = ChatOpenAI()
 
# 创建记忆组件
memory = ConversationBufferMemory()
 
# 创建对话链
conversation = ConversationChain(
    llm=llm,
    memory=memory
)
 
# 多轮对话
print("=== 第一轮 ===")
print(conversation.predict(input="你好，我叫小明"))
 
print("\n=== 第二轮 ===")
print(conversation.predict(input="我叫什么名字？"))
 
print("\n=== 第三轮 ===")
print(conversation.predict(input="1+1等于几？"))
 
print("\n=== 第四轮 ===")
print(conversation.predict(input="刚才那个问题的答案是多少？"))
 
# 查看对话历史
print("\n=== 对话历史 ===")
print(memory.load_memory_variables({}))

1.4.5 完整示例：智能问答机器人

结合前面学习的知识，创建一个稍微复杂一点的示例： 

# smart_qa_bot.py
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.memory import ConversationBufferMemory
from langchain.schema.runnable import RunnablePassthrough
 
class SmartQABot:
    """一个简单的智能问答机器人"""
 
    def __init__(self):
        # 初始化组件
        self.llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
        self.memory = ConversationBufferMemory(
            return_messages=True,
            memory_key="history"
        )
        self.output_parser = StrOutputParser()
 
        # 构建提示词模板
        self.prompt = ChatPromptTemplate.from_messages([
            ("system", "你是一个友善的AI助手，会尽力帮助用户。"),
            ("placeholder", "{history}"),
            ("human", "{input}")
        ])
 
        # 构建链
        self.chain = (
            RunnablePassthrough.assign(
                history=lambda x: self.memory.load_memory_variables(x)["history"]
            )
            | self.prompt
            | self.llm
            | self.output_parser
        )
 
    def chat(self, user_input: str) -> str:
        """处理用户输入并返回回复"""
        # 获取回复
        response = self.chain.invoke({"input": user_input})
 
        # 保存对话到记忆
        self.memory.save_context(
            {"input": user_input},
            {"output": response}
        )
 
        return response
 
    def get_history(self):
        """获取对话历史"""
        return self.memory.load_memory_variables({})
 
# 使用示例
def main():
    bot = SmartQABot()
 
    print("=" * 50)
    print("智能问答机器人 (输入 'quit' 退出)")
    print("=" * 50)
 
    while True:
        user_input = input("\n你: ").strip()
 
        if user_input.lower() == 'quit':
            print("再见！")
            break
 
        if not user_input:
            continue
 
        try:
            response = bot.chat(user_input)
            print(f"机器人: {response}")
        except Exception as e:
            print(f"出错了: {e}")
 
if __name__ == "__main__":
    main()

1.4.6 练习与挑战

练习 1：温度参数实验

创建一个程序，用不同的temperature值生成对同一个问题的回答，观察差异。 

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
 
def temperature_experiment():
    prompt = ChatPromptTemplate.from_template("给'{topic}'写一句创意文案")
    temperatures = [0.0, 0.5, 1.0, 1.5]
 
    for temp in temperatures:
        llm = ChatOpenAI(temperature=temp)
        chain = prompt | llm | StrOutputParser()
        result = chain.invoke({"topic": "夏日海滩"})
        print(f"\nTemperature = {temp}:")
        print(result)
 
temperature_experiment()

练习 2：多语言问候

创建一个能根据用户选择的语言进行问候的程序。 

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
 
def multilingual_greeting():
    template = "用{language}说'{message}'，只输出翻译后的内容"
    prompt = ChatPromptTemplate.from_template(template)
    llm = ChatOpenAI()
    chain = prompt | llm
 
    languages = ["英语", "日语", "法语", "德语", "西班牙语"]
    message = "欢迎来到我的世界"
 
    for lang in languages:
        result = chain.invoke({"language": lang, "message": message})
        print(f"{lang}: {result.content}")
 
multilingual_greeting()

练习 3：对话上下文长度限制

修改SmartQABot，实现当对话历史超过一定长度时，自动清理最早的对话。 

from langchain.memory import ConversationBufferMemory
from langchain.schema.messages import HumanMessage, AIMessage
 
class LimitedMemoryBot:
    """带长度限制的记忆机器人"""
 
    def __init__(self, max_turns=5):
        self.llm = ChatOpenAI()
        self.max_turns = max_turns
        self.memory = ConversationBufferMemory(return_messages=True)
 
    def chat(self, user_input: str) -> str:
        # 获取当前历史
        history = self.memory.load_memory_variables({})["history"]
 
        # 如果超过限制，移除最早的对话
        if len(history) >= self.max_turns * 2:  # *2 因为每轮有用户和AI两条消息
            history = history[2:]  # 移除最早的一轮
            self.memory.clear()
            for msg in history:
                if isinstance(msg, HumanMessage):
                    self.memory.chat_memory.add_user_message(msg.content)
                else:
                    self.memory.chat_memory.add_ai_message(msg.content)
 
        # 正常对话流程...
        response = self.llm.predict(
            f"历史对话: {history}\n用户: {user_input}\nAI:"
        )
 
        self.memory.save_context(
            {"input": user_input},
            {"output": response}
        )
 
        return response

1.5 本章小结

关键知识点回顾

  1. LangChain的定位
    • 用于构建LLM应用的Python/JavaScript框架
    • 提供组件化、链式、数据感知、代理能力
  1. 核心概念
    • Models: LLM、Chat Models、Embeddings
    • Prompts: 提示词模板和管理
    • Chains: 组件的组合和工作流
    • Indexes: 文档加载、分割、存储、检索
    • Memory: 对话历史的保存和管理
    • Agents: 智能代理和工具使用
  1. 安装配置
    • 基础安装：`pip install langchain`
    • 集成包：`langchain-openai`, `langchain-community`等
    • API密钥管理：环境变量是最佳实践
  1. 基础编程模式
    • 使用 `|` 操作符组合组件（LCEL）
    • 使用 `invoke` 方法运行链
    • 使用 `StrOutputParser` 解析输出
    • 使用 `Memory` 保存对话历史

常见错误与解决方案

错误信息 原因 解决方案
`ModuleNotFoundError` 缺少依赖 `pip install` 安装对应包
`AuthenticationError` API密钥无效 检查环境变量或显式传入
`RateLimitError` 请求频率过高 降低调用频率或使用重试机制
`ContextWindowExceeded` 输入太长 缩短输入或使用文本分割器
`ConnectionError` 网络问题 检查代理设置或网络连接

下一步学习建议

  1. 深入理解: 尝试修改本章示例代码，观察不同参数的影响
  2. 动手实践: 基于SmartQABot，添加你自己的功能
  3. 预习准备: 确保OpenAI API可用，为后续章节做好准备
  4. 阅读文档: 访问 查看最新文档

本章作业

  1. 完成三个练习，并记录你的观察和思考
  2. 创建一个能记住用户名字的个性化问候机器人
  3. 尝试使用不同的模型（如gpt-4）运行示例，比较输出质量差异
Detach Close

该主题尚不存在

您访问的页面并不存在。如果允许，您可以使用创建该页面按钮来创建它。

  • langchain二次开发/入门.txt
  • 最后更改: 2026/04/03 11:45
  • 由 张叶安