从零构建AI Agent：LangChain实战指南与金融问答机器人开发

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度

这次我们来看一个能让你亲手搭建 AI Agent 的项目：LangChain。别再只是听说 AI Agent 有多厉害，这篇文章直接带你从零开始，理解 LangChain 的核心工作机制，并完成一个可运行的实战入门案例。对于开发者来说，LangChain 最大的价值在于它提供了一套标准化的“积木”，让你能快速连接大模型、工具和数据，构建出能自主执行任务的智能体。

本文将重点拆解 LangChain 的核心组件，并通过一个完整的项目案例，展示如何从环境搭建到功能实现。整个过程不涉及复杂的硬件门槛，普通 CPU 或带 GPU 的电脑都能跑起来，关键在于理解其设计思想和代码逻辑。我们会重点关注 LangChain 的模块化设计、如何串联不同组件、以及如何通过 API 提供服务。

如果你关心如何将大模型能力转化为实际应用，想了解 Agent、RAG、Chain 这些概念如何落地，那么这篇文章可以直接收藏。我们将从最基础的“Hello World”开始，逐步构建一个具备记忆、工具调用和外部知识检索能力的问答机器人，并探讨其扩展为商用 Agent 的潜力。

1. 核心能力速览

在深入代码之前，我们先通过一个表格快速了解 LangChain 是什么，以及它能做什么。这有助于你判断它是否是你当前需要的技术栈。

2. 适用场景与使用边界

LangChain 不是一个开箱即用的成品应用，而是一个强大的“脚手架”。理解它的适用边界，能帮助你更好地决策。

它非常适合以下场景：

• 你需要定制化工作流：当标准的大模型对话接口无法满足你的业务逻辑时，例如需要先查数据库、再调用计算工具、最后生成报告。
• 你需要连接私有数据：希望大模型能够基于你内部的文档、知识库进行回答，避免“幻觉”，这就是 RAG 的典型应用。
• 你在构建复杂的 AI Agent：Agent 能根据目标自主选择使用哪些工具（如搜索、计算、执行代码），LangChain 的 Agent 模块提供了标准实现。
• 你希望技术栈统一：它支持众多模型提供商和向量数据库，用一个框架可以管理多种后端，降低切换成本。

它可能不是最佳选择，如果：

• 你只需要简单的对话：直接调用 OpenAI 或 Claude 的 Chat API 更简单快捷。
• 你对性能有极致要求：LangChain 的抽象层会带来轻微开销。在对延迟极其敏感的纯推理场景，直接调用模型底层接口可能更优。
• 项目极度简单：如果只是一个简单的文本转换或分类脚本，引入 LangChain 可能显得臃肿。

合规与安全边界提醒：

• 数据隐私：当使用 RAG 接入公司内部文档时，务必确保数据访问权限可控，避免敏感信息通过模型泄露。
• 模型合规：使用第三方商业 API（如 OpenAI）需遵守其服务条款；使用开源模型（如 Qwen）则需遵循其对应的开源协议。
• 生成内容审核：对于面向公众的 Agent，必须对模型的输出内容建立审核或过滤机制，防止生成有害、偏见或虚假信息。

3. 环境准备与前置条件

开始实战前，需要准备好开发环境。以下是一个通用且稳妥的环境清单，你可以根据自己的系统进行调整。

1. 操作系统：Windows 10/11, macOS, 或 Linux (如 Ubuntu 20.04+) 。LangChain 是跨平台的。
2. Python 版本：推荐使用 Python 3.8 至 3.11 版本。避免使用最新的 3.12+ 可能存在的兼容性问题。
3. 包管理工具：使用pip或更推荐的conda/uv来管理虚拟环境，避免包冲突。

   # 创建并激活 conda 虚拟环境（推荐） conda create -n langchain-demo python=3.10 conda activate langchain-demo # 或者使用 venv python -m venv venv # Windows: venv\Scripts\activate # Linux/macOS: source venv/bin/activate

4. 基础依赖：我们将安装 LangChain 及其常用社区组件。

   pip install langchain langchain-community

5. 大模型连接：根据你选择的 LLM 安装对应包。本文示例将同时展示使用 OpenAI API 和本地 Qwen 模型。
   • 使用 OpenAI API:

     pip install openai # 需要在环境变量中设置 OPENAI_API_KEY

   • 使用本地 Qwen 模型(需要 GPU 环境):

     pip install transformers torch # 如果需要加速，根据 CUDA 版本安装对应的 torch

6. Web 框架（可选）：为了将 Agent 封装成服务，我们安装 FastAPI。

   pip install fastapi uvicorn

7. 向量数据库（可选，用于 RAG）：为了演示知识库检索，我们安装轻量级的 Chroma。

   pip install chromadb

8. IDE/编辑器：VSCode 或 PyCharm 均可，确保已安装 Python 插件。

4. 安装部署与启动方式

LangChain 本身没有“启动”的概念，它作为库被你的代码调用。我们的“启动”指的是运行一个包含了 LangChain 逻辑的 Python 脚本或启动一个 Web 服务。

方式一：直接运行 Python 脚本（最快验证）创建一个demo.py文件，写入你的 LangChain 逻辑，然后直接执行。

python demo.py

方式二：启动 FastAPI 服务（提供 API 接口）创建一个app.py文件，定义 API 端点，然后使用 Uvicorn 启动。

uvicorn app:app --host 0.0.0.0 --port 8000 --reload

启动后，可以通过http://localhost:8000/docs访问自动生成的 API 文档。

方式三：使用 LangServe（官方服务化工具）LangServe 是 LangChain 官方推出的部署工具，能直接将 Chain 或 Agent 发布为 API。

pip install langserve

然后按照 LangServe 的模板编写服务脚本并启动。

在本文的实战部分，我们将采用方式一来逐步构建核心逻辑，并在最后演示如何将其改造成方式二的 API 服务。

5. 功能测试与效果验证：从零构建金融问答机器人

我们将围绕网络热词中提到的“金融大模型问答机器人”项目案例，分步骤实现一个具备基础能力的 AI Agent。这个 Agent 将能回答金融相关问题，并可以查询特定知识。

5.1 第一步：基础对话能力 - 连接大模型

首先，让我们的 Agent 能“说话”，即拥有一个大脑（LLM）。

测试目的：验证 LangChain 能否成功连接大模型并完成一次简单对话。

操作步骤：

1. 在项目目录下创建step1_llm.py。
2. 编写以下代码。这里我们先用 OpenAI GPT-3.5 作为示例（因为它稳定、快速，适合初次验证）。

# step1_llm.py import os from langchain_openai import ChatOpenAI # 请替换为你的 OpenAI API Key，或通过环境变量设置 os.environ[“OPENAI_API_KEY”] = “your-api-key-here” # 初始化聊天模型 llm = ChatOpenAI(model=“gpt-3.5-turbo”, temperature=0) # 发起一次对话 from langchain_core.messages import HumanMessage messages = [HumanMessage(content=“什么是市盈率？”)] response = llm.invoke(messages) print(“AI 回复：”, response.content)

预期结果与判断： 运行脚本python step1_llm.py，你应该能看到一个关于“市盈率”的简明金融解释。如果看到AuthenticationError，请检查 API Key；如果看到网络超时，请检查代理设置。这一步成功，说明 LangChain 和大模型的基础通道已打通。

5.2 第二步：添加记忆功能 - 实现多轮对话

一个健谈的 Agent 需要记住之前的对话内容。

测试目的：让 Agent 能在多轮对话中保持上下文连贯。

操作步骤：

1. 创建step2_memory.py。
2. 使用ConversationBufferMemory来保存历史消息。

# step2_memory.py from langchain_openai import ChatOpenAI from langchain.memory import ConversationBufferMemory from langchain.chains import ConversationChain llm = ChatOpenAI(model=“gpt-3.5-turbo”, temperature=0) memory = ConversationBufferMemory() conversation = ConversationChain(llm=llm, memory=memory, verbose=True) # verbose=True 查看内部过程 print(“第一轮问答：”) response1 = conversation.predict(input=“我是一家科技公司的CEO。”) print(“AI:”, response1) print(“\n第二轮问答（依赖记忆）：”) response2 = conversation.predict(input=“我刚刚说我是做什么的？”) print(“AI:”, response2) # 查看当前记忆内容 print(“\n当前记忆内容：”) print(memory.buffer)

预期结果与判断： 运行脚本，在第二轮问答时，AI 应该能准确回忆起“你是一家科技公司的 CEO”。控制台输出的verbose日志会让你看到 LangChain 是如何将历史记录拼接到最新提问中的。这证明了Memory模块的有效性。

5.3 第三步：赋予工具调用能力 - 变身初级 Agent

Agent 的核心是能使用工具。我们给它一个计算器和一个搜索工具（模拟）。

测试目的：让 Agent 能根据用户问题，自动判断是否需要使用工具，并正确调用。

操作步骤：

1. 创建step3_agent.py。
2. 定义工具函数。
3. 创建 Agent 执行器。

# step3_agent.py from langchain_openai import ChatOpenAI from langchain.agents import tool, AgentExecutor, create_react_agent from langchain import hub # 1. 定义工具 @tool def calculate(expression: str) -> str: “”“计算一个数学表达式的结果。例如：calculate(‘2+2’) -> ‘4’”“” try: # 警告：实际生产中请使用更安全的评估方法，如 ast.literal_eval 或 math 库 result = eval(expression) return str(result) except Exception as e: return f“计算错误：{e}” @tool def search_knowledge_base(query: str) -> str: “”“模拟从知识库中搜索信息。这是一个模拟函数。”“” knowledge = { “公司股价”: “当前股价为 150 元。”, “最新财报”: “Q1 营收同比增长 20%。”, “主打产品”: “我们的主打产品是 AI 数据分析平台。” } return knowledge.get(query, “未找到相关信息。”) tools = [calculate, search_knowledge_base] # 2. 获取 ReAct 提示词模板，并创建 Agent llm = ChatOpenAI(model=“gpt-3.5-turbo”, temperature=0) prompt = hub.pull(“hwchase17/react”) # 从 LangChain Hub 拉取经典 ReAct 提示词 agent = create_react_agent(llm, tools, prompt) # 3. 创建执行器 agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True) # 4. 测试 questions = [ “100美元乘以7.2的汇率是多少人民币？”, “我们公司的最新财报情况如何？”, “请介绍下市盈率。” ] for q in questions: print(f“\n用户问题：{q}”) result = agent_executor.invoke({“input”: q}) print(f“Agent 最终回答：{result[‘output’]}”)

预期结果与判断： 运行脚本，观察verbose输出。对于第一个问题，Agent 应该会思考需要调用calculate工具，然后执行calculate(“100*7.2”)，最后给出结果。对于第二个问题，它会调用search_knowledge_base。对于第三个通用知识问题，它可能直接利用 LLM 的知识回答，而不调用工具。这验证了 Agent 的“思考-行动-观察”循环。

5.4 第四步：集成 RAG - 接入私有知识库

让 Agent 的回答基于我们提供的特定文档，减少“幻觉”。

测试目的：构建一个简单的本地知识库（使用 Chroma），让 Agent 能先检索相关文档片段，再生成答案。

操作步骤：

1. 创建step4_rag.py。
2. 准备知识文档（这里用字符串模拟），进行文本分割、向量化并存入向量数据库。
3. 创建一个检索链。

# step4_rag.py from langchain_openai import ChatOpenAI, OpenAIEmbeddings from langchain_community.vectorstores import Chroma from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain.chains import RetrievalQA from langchain.prompts import PromptTemplate # 1. 模拟我们的私有知识库文档 financial_docs = “”” 公司金融政策：2024年，本公司研发费用预算为5亿元人民币，主要用于AI Agent和云计算方向。 产品定价：标准版AI数据分析平台年费为10万元/年，企业版为50万元/年，包含专属客服和定制开发。 投资条款：A轮融资已于2023年Q4完成，融资金额2亿美元，领投方为红杉资本。 “”” # 2. 分割文档 text_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=50) texts = text_splitter.split_text(financial_docs) # 3. 创建向量存储（使用 OpenAI 的嵌入模型，也可用其他开源模型） embeddings = OpenAIEmbeddings() vectorstore = Chroma.from_texts(texts, embeddings, persist_directory=“./chroma_finance_db”) vectorstore.persist() # 持久化到磁盘 retriever = vectorstore.as_retriever(search_kwargs={“k”: 2}) # 检索最相关的2个片段 # 4. 创建带提示词的检索问答链 prompt_template = “””基于以下上下文，回答用户问题。如果你不知道答案，就说不知道，不要编造。 上下文：{context} 问题：{question} 请给出准确、简洁的答案：”“” PROMPT = PromptTemplate(template=prompt_template, input_variables=[“context”, “question”]) llm = ChatOpenAI(model=“gpt-3.5-turbo”, temperature=0) qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type=“stuff”, retriever=retriever, chain_type_kwargs={“prompt”: PROMPT}, return_source_documents=True ) # 5. 测试 questions = [“我们公司今年的研发预算是多少？”, “企业版产品多少钱一年？”, “谁领投了A轮融资？”] for q in questions: print(f“\n问题：{q}”) result = qa_chain.invoke({“query”: q}) print(f“答案：{result[‘result’]}”) print(f“来源文档：{[doc.page_content[:80]+‘...’ for doc in result[‘source_documents’]]}”) # 打印来源片段

预期结果与判断： 运行脚本，Agent 的回答应严格基于我们提供的financial_docs内容。例如，对于研发预算的问题，答案应是“5亿元人民币”。同时，控制台会输出它检索到的具体文档片段，证明了 RAG 流程（检索 -> 增强 -> 生成）的有效性。这是构建可靠领域知识问答系统的关键。

5.5 第五步：整合与升级 - 构建完整 Agent

现在，我们将记忆、工具和 RAG 能力整合到一个更强大的 Agent 中。

测试目的：创建一个能同时处理对话历史、使用工具、并查询知识库的复合型 Agent。

操作步骤：

1. 创建step5_full_agent.py。
2. 我们将使用 LangChain 的create_react_agent作为基础，但为其工具集增加一个“查询知识库”的工具，这个工具内部封装了上面的 RAG 检索链。

# step5_full_agent.py from langchain_openai import ChatOpenAI, OpenAIEmbeddings from langchain.memory import ConversationBufferMemory from langchain.agents import tool, AgentExecutor, create_react_agent from langchain import hub from langchain_community.vectorstores import Chroma # --- 初始化 LLM 和记忆 --- llm = ChatOpenAI(model=“gpt-3.5-turbo”, temperature=0) memory = ConversationBufferMemory(memory_key=“chat_history”, return_messages=True) # --- 准备 RAG 检索工具 --- # 假设向量数据库已在上一步创建好，直接加载 embeddings = OpenAIEmbeddings() vectorstore = Chroma(persist_directory=“./chroma_finance_db”, embedding_function=embeddings) retriever = vectorstore.as_retriever(search_kwargs={“k”: 2}) @tool def query_finance_knowledge(query: str) -> str: “”“当问题涉及公司金融政策、产品定价、投资等信息时，使用此工具从公司知识库中查找答案。”“” docs = retriever.get_relevant_documents(query) if not docs: return “知识库中未找到相关信息。” # 简单拼接检索到的文档作为上下文 context = “\n”.join([doc.page_content for doc in docs]) # 这里可以调用一个简单的 LLM 来根据上下文生成精炼答案，为简化，直接返回上下文 # 实际应用中，可以内嵌一个 QA 链 return f“根据知识库，相关信息如下：{context}” # --- 定义其他工具（计算器）--- @tool def calculate(expression: str) -> str: “”“计算一个数学表达式。例如：calculate(‘100*7.2’)”“” try: result = eval(expression) return str(result) except: return “计算失败，请检查表达式格式。” tools = [query_finance_knowledge, calculate] # --- 创建 Agent --- prompt = hub.pull(“hwchase17/react”) agent = create_react_agent(llm, tools, prompt) # --- 创建执行器，并注入记忆 --- agent_executor = AgentExecutor( agent=agent, tools=tools, memory=memory, verbose=True, handle_parsing_errors=True ) # --- 进行多轮测试 --- test_inputs = [ “你好，我是新来的财务分析师。”, “我们公司A轮融资情况怎么样？”, # 应触发 query_finance_knowledge “如果企业版买三年，总价是多少？帮我算一下。”, # 应触发 calculate “我刚刚问过融资的事情，你还记得领投方是谁吗？” # 测试记忆 ] for inp in test_inputs: print(f“\n用户：{inp}”) result = agent_executor.invoke({“input”: inp}) print(f“Agent：{result[‘output’]}”) print(“-” * 50)

预期结果与判断： 这是一个综合性测试。运行后，你应该看到：

1. 第一轮，普通问候。
2. 第二轮，Agent思考后调用query_finance_knowledge工具，并从我们构建的向量库中检索到“红杉资本领投”的信息。
3. 第三轮，Agent 需要先理解“企业版年费50万，三年总价”，然后思考调用calculate工具计算50*3。
4. 第四轮，得益于ConversationBufferMemory，Agent 能直接回忆起之前的对话历史，无需再次检索即可回答。 这标志着一个具备记忆、工具调用和知识检索的初级 AI Agent 已经构建完成。

6. 接口 API 与批量任务

一个完整的应用需要提供 API 供其他系统调用，并能高效处理批量请求。

6.1 使用 FastAPI 封装为 Web 服务

我们将上述的agent_executor封装成一个 HTTP API。

操作步骤：

1. 创建app.py。
2. 使用 FastAPI 创建端点。

# app.py from fastapi import FastAPI, HTTPException from pydantic import BaseModel from langchain_openai import ChatOpenAI from langchain.memory import ConversationBufferMemory from langchain.agents import AgentExecutor, create_react_agent from langchain import hub from .step5_full_agent import tools # 假设工具定义在另一个模块，这里需要导入 import uuid app = FastAPI(title=“金融问答 AI Agent API”) # 为每个会话维护独立的内存 session_memories = {} class AgentRequest(BaseModel): session_id: str | None = None # 会话ID，用于保持多轮对话 message: str # 可以添加其他参数，如 temperature, model_name 等 class AgentResponse(BaseModel): session_id: str reply: str def get_agent_executor(session_id: str) -> AgentExecutor: “”“获取或创建一个属于特定会话的 Agent 执行器。”“” if session_id not in session_memories: llm = ChatOpenAI(model=“gpt-3.5-turbo”, temperature=0) memory = ConversationBufferMemory(memory_key=“chat_history”, return_messages=True) prompt = hub.pull(“hwchase17/react”) agent = create_react_agent(llm, tools, prompt) executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=False, handle_parsing_errors=True) session_memories[session_id] = executor return session_memories[session_id] @app.post(“/chat”, response_model=AgentResponse) async def chat_with_agent(request: AgentRequest): try: session_id = request.session_id if request.session_id else str(uuid.uuid4()) agent_executor = get_agent_executor(session_id) result = agent_executor.invoke({“input”: request.message}) return AgentResponse(session_id=session_id, reply=result[“output”]) except Exception as e: raise HTTPException(status_code=500, detail=f“Agent 处理失败：{str(e)}”) @app.get(“/health”) async def health_check(): return {“status”: “ok”} if __name__ == “__main__”: import uvicorn uvicorn.run(app, host=“0.0.0.0”, port=8000)

启动与测试：

uvicorn app:app --host 0.0.0.0 --port 8000 --reload

使用 curl 或 Postman 测试：

curl -X POST “http://localhost:8000/chat" \ -H “Content-Type: application/json” \ -d ‘{“message”: “企业版产品年费是多少？”, “session_id”: “test_user_1”}’

这个 API 现在可以轻松被前端、移动端或其他后端服务集成。

6.2 处理批量任务

对于批量处理，例如处理一个 CSV 文件中的多个问题，不建议为每个请求都启动一个独立的 Agent 实例（内存消耗大）。更高效的方式是：

1. 复用资源：在批量任务开始时初始化一个 Agent 执行器（或为每个线程初始化一个）。
2. 管理会话：如果批量任务间无关联，可以为每个任务使用一个独立的临时session_id，或直接不使用记忆功能。
3. 队列与并发：对于大规模批量任务，可以使用 Celery、RQ 等任务队列，并控制并发数，避免对 LLM API 造成速率限制。

简单批量处理示例：

# batch_process.py import pandas as pd from app import get_agent_executor # 导入上面定义的函数 import uuid def process_batch_questions(questions_list): results = [] for question in questions_list: session_id = str(uuid.uuid4()) # 每个问题独立会话 agent_executor = get_agent_executor(session_id) try: result = agent_executor.invoke({“input”: question}) results.append({“question”: question, “answer”: result[“output”]}) except Exception as e: results.append({“question”: question, “answer”: f“处理错误：{e}”}) # 可选：清理该会话内存以释放资源 # del session_memories[session_id] return results # 假设从CSV读取问题 df = pd.read_csv(“questions.csv”) questions = df[“question”].tolist() answers = process_batch_questions(questions) output_df = pd.DataFrame(answers) output_df.to_csv(“answers.csv”, index=False)

7. 资源占用与性能观察

LangChain 框架本身是轻量级的，资源消耗主要来自以下几部分：

1. 大模型推理：

   • 使用云端 API：无本地显存/内存压力，主要消耗网络资源和 API 调用费用。性能受网络延迟和 API 速率限制影响。
   • 部署本地模型：这是资源消耗大头。以 Qwen-7B 为例，使用 4-bit 量化加载，显存占用约 6-8 GB。推理时的峰值显存会更高。需要密切关注 GPU 显存使用情况（可通过nvidia-smi观察）。

2. 向量数据库：

   • Chroma：运行时会占用一定内存，取决于索引的文档数量和向量维度。对于百万级以下的小规模知识库，内存占用通常在几百 MB 到几 GB。
   • 检索速度：检索耗时与向量索引类型和规模有关。对于 demo 级应用，Chroma 的检索是毫秒级的。

3. LangChain 运行时：

   • 内存：ConversationBufferMemory会保存所有历史消息，长时间对话可能导致内存增长。对于生产环境，应考虑使用ConversationSummaryMemory或ConversationBufferWindowMemory。
   • CPU：框架本身的 CPU 开销很小，主要是在组织提示词、解析工具调用等逻辑处理上。

性能优化建议：

• 对话记忆：对于长对话，使用窗口记忆或总结记忆，避免缓冲区无限膨胀。
• 向量检索：控制search_kwargs={“k”: n}中的n（返回的文档片段数），n越小，检索越快，上下文也越短。
• 工具调用：精简工具的定义和逻辑，避免在工具函数内进行耗时的 I/O 操作。
• 异步处理：对于 API 服务，使用异步框架（如FastAPI异步端点）和异步的 LangChain 组件（如langchain.agents.agent_toolkits中的异步支持）可以提高并发处理能力。

8. 常见问题与排查方法

在开发和部署 LangChain 应用时，你可能会遇到以下典型问题。

9. 最佳实践与使用建议

基于上述实战，总结出以下几点建议，帮助你更稳健地使用 LangChain：

1. 从简单开始，逐步迭代：不要一开始就设计复杂的多 Agent 系统。先完成一个能跑通的LLM -> Chain -> Output的最小闭环，再逐步添加记忆、工具、检索等模块。
2. 善用verbose=True：在开发和调试阶段，始终为AgentExecutor和Chain开启verbose模式。它能完整展示 LangChain 的思考过程、工具调用和中间结果，是排查问题的利器。
3. 提示词工程是关键：LangChain 将很多逻辑交给了提示词。工具的描述、系统的指令、用户的提问方式，都会极大影响 Agent 的表现。花时间精心设计和迭代你的提示词模板。
4. 管理好模型成本与性能：在原型阶段，使用gpt-3.5-turbo等低成本模型进行快速迭代。在确定流程后，再换用gpt-4或本地大模型来提升效果。对于本地部署，量化是平衡效果与资源的必要手段。
5. 为生产环境做好准备：
   • 错误处理：对 LLM 调用、工具调用、外部 API 调用做好全面的异常捕获和重试机制。
   • 日志记录：记录每一次用户交互、模型响应、工具调用和最终输出，便于后续分析和优化。
   • 可观测性：监控 API 的响应延迟、错误率、Token 消耗等指标。
   • 安全与合规：对用户输入和模型输出进行内容安全过滤。确保 RAG 检索的数据来源合法合规。
6. 探索 LangGraph：对于需要复杂状态管理和循环的工作流（如审批流、多步骤决策），可以关注 LangChain 的姊妹项目LangGraph，它基于图结构来编排 Agent 和 Chain，更适合复杂场景。

10. 总结与下一步

通过本文的实战，我们完成了一个金融问答 AI Agent 从零到一的构建。这个 Agent 具备了与用户进行多轮对话的能力，可以调用工具进行计算，并能从私有知识库中检索信息来回答问题。整个过程清晰地演示了 LangChain 的核心模块：Model I/O、Memory、Tools、Retrieval、Agent、Chain是如何协同工作的。

最值得尝试的点：

• 模块化设计：像搭积木一样组合功能，快速实验不同架构。
• 强大的 Agent 抽象：用很少的代码就实现了“思考-行动”循环，这是构建智能应用的核心。
• 丰富的集成生态：轻松连接各种模型、向量库和工具，避免了重复造轮子。

最先应该验证的功能： 建议你按照本文步骤，先确保能成功运行5.1和5.2节的基础对话与记忆代码。这是所有复杂功能的基石。成功后，再尝试加入一个简单的工具（如 5.3 节的计算器），体验 Agent 的决策过程。

最容易踩的坑：

1. 环境配置：Python 版本、包依赖冲突是最常见的问题。务必使用虚拟环境。
2. API 连接：网络问题和 API Key 配置错误会直接导致程序无法运行。
3. 提示词设计：如果 Agent 行为不符合预期，首先检查并优化提示词。

后续扩展方向：

1. 更换更强的本地模型：将示例中的ChatOpenAI替换为本地部署的Qwen、ChatGLM等，体验完全私有化部署的 Agent。
2. 接入真实工具：将示例中的模拟工具替换为真实的搜索引擎 API、数据库查询、企业内部系统 API 等。
3. 实现更复杂的记忆：尝试ConversationSummaryMemory或结合向量数据库实现长期记忆。
4. 构建图形化界面：使用Gradio或Streamlit快速为你的 Agent 制作一个 Web 界面。
5. 学习 LangGraph：当你需要处理包含分支、循环、并发的复杂工作流时，LangGraph 是下一个进阶选择。

LangChain 降低了构建 AI 应用的门槛，但构建一个真正可靠、高效的 AI Agent 仍然需要对大模型原理、软件工程和具体业务场景有深入的理解。希望本文能成为你探索 AI Agent 开发的一个坚实起点。建议收藏本文，在动手实践中随时回溯参考。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度