从零构建AI智能体：基于LLM的自主决策与工具调用实战指南

1. 项目概述：从零开始，亲手构建你的第一个AI智能体

最近在GitHub上看到一个微软开源的教程项目，叫“AI Agents for Beginners”。这个名字起得挺直白，就是“给初学者的AI智能体”。我点进去一看，发现它不是一个现成的工具库或者框架，而是一个精心编排的、从零开始的实践教程。这让我想起了自己刚开始接触这个概念时的迷茫——市面上各种术语满天飞，什么“智能体”、“自主代理”、“多智能体系统”，听起来高大上，但具体怎么上手、怎么让它真正“动”起来，却很少有系统性的指引。

这个项目恰恰填补了这个空白。它不假设你有深厚的机器学习背景，而是从一个更普适的视角切入：如何让一个大型语言模型（LLM）从一个被动的“答题器”，转变为一个能主动思考、规划并执行任务的“智能体”。简单来说，就是教你怎么给ChatGPT这类模型装上“大脑”和“手脚”，让它不仅能说，还能做。无论是想自动化处理日常文档、分析市场数据，还是构建一个能陪你聊天的个性化助手，智能体都是实现这些构想的核心技术路径。如果你对AI的应用感兴趣，不满足于仅仅问答，而是希望创造能独立完成复杂流程的AI伙伴，那么这个入门指南将是你绝佳的起点。

2. 智能体核心概念：超越简单问答的AI

在深入动手之前，我们有必要先厘清几个核心概念。很多人会把“调用API的脚本”和“AI智能体”混淆。前者是线性的、确定性的：你发送一个请求，它返回一个结果，结束。而智能体（Agent）的核心在于状态、记忆、工具使用和自主决策。

2.1 什么是AI智能体？

你可以把一个基础的AI智能体想象成一个刚入职的、非常聪明但缺乏经验的实习生。你（用户）是老板，给TA布置了一个任务，比如“帮我分析一下上个月的销售数据，写一份报告，并找出表现最好的三个产品”。

一个只会简单问答的模型，可能会直接生成一段关于“如何分析销售数据”的通用文本，这显然不是你要的。而一个智能体化的模型，则会像那个实习生一样，开始自主规划：

1. 理解任务：哦，老板要销售数据报告和Top 3产品。
2. 制定计划：我需要先拿到数据（访问数据库或文件），然后清洗和分析数据（调用数据分析工具），最后组织成报告（调用文档生成工具）。
3. 执行与调整：在执行过程中，如果发现数据格式不对，它会尝试转换；如果某个工具返回了错误，它会尝试其他方法或向你汇报。
4. 交付结果：最终给你一份结构清晰的报告，并附上产品列表。

这个“思考-规划-行动-观察”的循环，就是智能体的工作流。项目的教程正是围绕如何构建这个循环展开的。

2.2 智能体的关键组件

要实现上述能力，一个典型的智能体系统通常包含以下几个部分，这也是我们后续实操中会逐一实现的核心：

• 大脑（LLM Core）：通常是像GPT-4、Claude 3或开源的Llama 3这类大型语言模型。它的核心职责是理解和推理。它接收来自外部的信息（用户指令、工具返回结果、记忆内容），进行思考，然后决定下一步该做什么（是继续思考，还是调用某个工具，还是直接给出最终答案）。
• 规划器（Planner）：负责将模糊的用户目标拆解成具体的、可执行的步骤序列。比如“写一份报告”可以拆解为“搜集资料 -> 拟定大纲 -> 撰写内容 -> 润色格式”。在简单智能体中，规划功能通常直接由LLM承担；在复杂场景下，可能会有一个专门的规划模块。
• 记忆（Memory）：智能体不是金鱼，它需要记住之前的对话、执行过的步骤和得到的结果。记忆分为短期记忆（当前会话的上下文）和长期记忆（可以存储到向量数据库，供未来会话检索）。这保证了智能体在复杂、多轮的任务中能保持连贯性。
• 工具（Tools）：这是智能体的“手脚”。LLM本身无法直接操作世界，它必须通过工具。一个工具可以是一个函数：比如search_web(keywords)用于搜索，read_file(path)用于读取文件，execute_python(code)用于运行代码。智能体需要知道它有哪些工具可用，以及何时、如何使用它们。
• 执行器（Executor）：负责调度整个流程。它管理智能体的状态，调用LLM进行决策，根据决策调用相应的工具，处理工具返回的结果，并更新记忆，然后循环这个过程，直到任务完成或无法继续。

理解了这些组件，我们再看这个教程项目，就会发现它的结构非常清晰：它引导你从最简单的“思考-行动”循环开始，逐步加入记忆、更复杂的工具链，最终构建一个功能相对完整的智能体。

3. 环境准备与工具选型：搭建你的智能体工作台

工欲善其事，必先利其器。在开始编码之前，我们需要准备好开发环境。教程本身可能提供了多种路径，但我会结合最常见的实践，给你一个稳定、高效的起步方案。

3.1 核心运行环境：Python与包管理

AI智能体开发几乎离不开Python，因为它拥有最丰富的AI库和工具生态。

1. Python版本：推荐使用Python 3.10或3.11。这两个版本在兼容性和稳定性上达到了很好的平衡。避免使用最新的3.12或较旧的3.8，以免遇到一些库的不兼容问题。你可以使用pyenv（Mac/Linux）或直接从官网安装指定版本。
2. 包管理工具：强烈建议使用pipenv或poetry来管理你的项目依赖，而不是直接用pip。它们能创建独立的虚拟环境，并生成精确的依赖锁文件，确保你的项目在任何机器上都能以相同的环境运行。这里我以poetry为例，因为它对依赖解析和打包更友好。

   # 安装poetry pip install poetry # 在你的项目目录初始化 poetry new ai-agent-project cd ai-agent-project # 后续添加依赖都会更新pyproject.toml和poetry.lock

3.2 LLM接入选择：云端API vs. 本地模型

这是最关键的选择之一，决定了你的智能体的“大脑”来源、成本和性能。

• 云端API（推荐初学者）：简单、强大、无需昂贵硬件。你需要一个API密钥。

  • OpenAI GPT系列：生态最成熟，工具兼容性最好，智能体框架对其支持度最高。从GPT-3.5-turbo（便宜、够用）到GPT-4（更强推理）都可选。
  • Anthropic Claude系列：上下文窗口极大（最高200K），在长文档处理和复杂指令遵循上表现优异。
  • 国内大模型API：如智谱AI、百度文心、阿里通义等，访问速度可能更快，但英文能力或特定工具链的生态可能稍弱。
  • 操作：通常就是安装SDK（openai,anthropic），设置环境变量API_KEY，然后就可以调用。

• 本地模型（适合进阶、注重隐私/成本）：需要强大的GPU（如RTX 3090/4090或消费级显卡），部署复杂，但数据完全私有，无使用费用。

  • 模型选择：Llama 3（70B/8B）、Qwen 2.5、DeepSeek等，通过ollama、vLLM或Transformers库加载。
  • 量化：为了在消费级显卡上运行，通常需要对模型进行量化（降低精度，如从FP16到INT4），这会在一定程度上损失精度。
  • 框架：LangChain、LlamaIndex对本地模型有良好支持。

实操心得：对于纯粹的学习和功能验证，强烈建议从云端API开始，特别是GPT-3.5-turbo。它的成本极低（每百万tokens约0.5美元），能让你完全专注于智能体逻辑本身，而不是耗费大量时间在模型部署、调试和硬件问题上。等项目原型跑通，再考虑迁移到本地或更换其他模型。

3.3 智能体框架：LangChain vs. 原生开发

教程可能会引导你使用LangChain、AutoGen或Semantic Kernel等框架，也可能教你从零开始用OpenAI SDK构建。

• 使用框架（如LangChain）：

  • 优点：提供了大量预制组件（工具、记忆、链），能快速搭建原型，社区活跃，例子多。
  • 缺点：抽象层较厚，有时感觉像“黑箱”，出了问题调试较难，性能可能不是最优。
  • 适合：快速验证想法，或者需要集成多种复杂工具（如搜索引擎、数据库）的场景。

• 原生开发（基于OpenAI API等SDK）：

  • 优点：代码完全透明，控制力强，易于调试和理解底层机制，依赖简单。
  • 缺点：所有轮子都要自己造，需要处理工具调用格式、状态循环等逻辑。
  • 适合：学习核心原理，构建轻量级、定制化程度高的智能体。

我的建议：如果你是第一次接触，不妨跟着教程，先用框架（比如LangChain）快速实现一个能跑的智能体，感受完整的工作流。然后，第二个项目尝试用原生SDK重写核心循环。这个过程能让你深刻理解框架帮你做了什么，以及智能体最本质的运作机制。本指南后续的讲解会兼顾这两种路径。

3.4 辅助工具与基础设施

• 代码编辑器：VS Code + Python插件是绝配。
• 向量数据库（用于长期记忆）：当需要让智能体记住大量历史信息时，就需要它。轻量级可选ChromaDB（纯内存/持久化），生产环境可以考虑Qdrant、Weaviate或Pinecone（云服务）。
• 开发调试：善用print日志，或者使用LangSmith（LangChain的官方调试平台）来可视化跟踪智能体的每一步决策和工具调用，这对理解其“思考过程”至关重要。

环境准备好后，我们就可以开始动手，打造第一个会使用工具的智能体了。

4. 实战构建：你的第一个工具调用智能体

现在，让我们进入最激动人心的环节：写代码。我们将构建一个最简单的智能体，它能够理解你的指令，并在需要时调用一个预定义的工具。我们分别用LangChain和原生OpenAI API两种方式来实现，你可以对比理解。

4.1 场景定义与工具创建

假设我们要构建一个“信息查询助手”。它有两个能力：

1. 直接回答知识性问题（用LLM本身的知识）。
2. 如果问题涉及实时信息或计算，就调用工具。

我们先定义两个简单的工具：

• get_current_time(): 返回当前时间。
• calculate(expression): 计算一个数学表达式，如“3 + 5 * 2”。

用原生Python定义工具：

# tools.py import datetime import math import re def get_current_time(): """返回当前的日期和时间。""" now = datetime.datetime.now() return now.strftime("%Y-%m-%d %H:%M:%S") def calculate(expression: str) -> str: """计算一个数学表达式。支持加减乘除和括号。""" # 安全警告：实际生产中，直接eval是危险的，这里仅用于演示。 # 应使用更安全的库如`ast.literal_eval`或自定义解析器。 try: # 简单清理，确保表达式只包含数字和运算符 if not re.match(r'^[\d\+\-\*\/\(\)\.\s]+$', expression): return "错误：表达式包含非法字符。" result = eval(expression) return str(result) except Exception as e: return f"计算错误：{e}"

4.2 方案一：使用LangChain快速搭建

LangChain将工具调用抽象成了Tool对象和AgentExecutor。

# agent_langchain.py import os from langchain_openai import ChatOpenAI from langchain.agents import AgentExecutor, create_tool_calling_agent from langchain_core.prompts import ChatPromptTemplate from langchain.tools import Tool # 导入我们上面定义的工具函数 from tools import get_current_time, calculate # 1. 设置API密钥（建议从环境变量读取） os.environ["OPENAI_API_KEY"] = "your-api-key-here" # 2. 创建LLM llm = ChatOpenAI(model="gpt-3.5-turbo") # 3. 将Python函数包装成LangChain Tool对象 tools = [ Tool( name="GetCurrentTime", func=get_current_time, description="当用户询问当前时间、日期、今天星期几时使用此工具。" ), Tool( name="Calculator", func=calculate, description="当用户需要计算数学表达式时使用此工具。输入应该是一个纯数学表达式，如'3 + 5 * 2'。" ) ] # 4. 创建提示词模板，指导AI如何扮演智能体角色 prompt = ChatPromptTemplate.from_messages([ ("system", "你是一个乐于助人的助手，可以回答问题和使用工具。请根据情况决定是直接回答还是使用工具。如果你使用了工具，请基于工具返回的结果来回答用户。"), ("placeholder", "{chat_history}"), # 为对话历史留位 ("human", "{input}"), ("placeholder", "{agent_scratchpad}"), # 为智能体的思考过程留位 ]) # 5. 创建智能体 agent = create_tool_calling_agent(llm=llm, tools=tools, prompt=prompt) # 6. 创建执行器 agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) # verbose=True 会打印详细思考过程 # 7. 运行测试 if __name__ == "__main__": queries = [ "你好，今天天气怎么样？", # LLM直接回答 "现在几点了？", # 调用GetCurrentTime工具 "123乘以456等于多少？", # 调用Calculator工具 "先告诉我时间，然后计算(15+27)除以3的结果。" # 可能涉及多步调用 ] for query in queries: print(f"\n用户: {query}") result = agent_executor.invoke({"input": query}) print(f"助手: {result['output']}")

运行这段代码，你会看到verbose模式下，LangChain打印出了智能体的思考过程（ReAct模式）：Thought（思考是否需要工具）->Action（选择工具）->Observation（工具返回结果）->Final Answer。这就是智能体核心循环的可视化。

4.3 方案二：使用OpenAI API原生实现

为了理解底层机制，我们手动实现这个循环。这需要利用OpenAI的function calling（函数调用）能力。

# agent_native.py import os import json import datetime from openai import OpenAI # 复用之前的工具函数 from tools import get_current_time, calculate client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY")) # 1. 定义工具的描述信息，这将被发送给LLM tools_definitions = [ { "type": "function", "function": { "name": "get_current_time", "description": "获取当前的日期和时间。", "parameters": { "type": "object", "properties": {}, # 此工具无需参数 "required": [], }, }, }, { "type": "function", "function": { "name": "calculate", "description": "计算一个数学表达式。", "parameters": { "type": "object", "properties": { "expression": { "type": "string", "description": "数学表达式，例如 '3 + 5 * 2'", } }, "required": ["expression"], }, }, }, ] # 2. 工具名称到实际函数的映射 available_functions = { "get_current_time": get_current_time, "calculate": calculate, } def run_conversation(user_input): """核心的智能体执行循环""" messages = [{"role": "user", "content": user_input}] # 第一轮：让LLM判断是否需要调用工具 response = client.chat.completions.create( model="gpt-3.5-turbo", messages=messages, tools=tools_definitions, tool_choice="auto", # 让模型自动决定 ) response_message = response.choices[0].message messages.append(response_message) # 将模型的回复加入历史 # 3. 检查模型是否想调用工具 tool_calls = response_message.tool_calls if tool_calls: # 4. 如果有工具调用，则执行每一个被请求的工具 for tool_call in tool_calls: function_name = tool_call.function.name function_to_call = available_functions[function_name] # 解析工具参数 function_args = json.loads(tool_call.function.arguments) # 调用工具 print(f"[智能体] 正在调用工具: {function_name}，参数: {function_args}") function_response = function_to_call(**function_args) print(f"[工具] {function_name} 返回: {function_response}") # 5. 将工具执行结果作为新的消息，发送回LLM，让它基于结果生成最终回答 messages.append({ "role": "tool", "tool_call_id": tool_call.id, "content": str(function_response), # 结果必须是字符串 }) # 获取LLM基于工具结果的最终回答 second_response = client.chat.completions.create( model="gpt-3.5-turbo", messages=messages, ) final_message = second_response.choices[0].message messages.append(final_message) return final_message.content else: # 如果不需要工具，直接返回LLM的回复 return response_message.content if __name__ == "__main__": queries = ["现在是什么时间？", "计算一下98的平方。"] for q in queries: print(f"\n用户: {q}") answer = run_conversation(q) print(f"助手: {answer}")

通过对比，你可以清晰地看到：

• LangChain帮你封装了循环、消息历史管理和工具调用的复杂逻辑，你只需要定义工具和提示词。
• 原生实现让你完全掌控每一步：如何构造消息、如何处理工具调用响应、如何将结果反馈给LLM。这对于调试和深度定制至关重要。

注意事项：在原生实现中，工具调用的结果必须以字符串形式返回给LLM。此外，错误处理非常重要。如果工具执行失败，你应该将错误信息返回给LLM，让它决定是重试、换种方式还是向用户求助。上面的示例为了简洁省略了部分错误处理。

5. 进阶能力：为智能体赋予记忆与规划

一个只会单次调用工具的智能体还不够“智能”。真正的智能体需要记住对话历史，并能处理需要多步规划（Plan）的复杂任务。

5.1 实现短期记忆（对话历史）

记忆的核心是将过去的对话内容有效地放入当前对话的上下文（Context）中。由于LLM有上下文长度限制（如GPT-3.5-turbo是16K），我们不能无限制地附加所有历史。

策略：滑动窗口记忆只保留最近N轮对话。这是最简单有效的方式。

# memory_simple.py from collections import deque class SimpleMemory: def __init__(self, max_turns=10): self.memory = deque(maxlen=max_turns) # 双端队列，自动丢弃最老的记录 self.max_turns = max_turns def add(self, role: str, content: str): """添加一条对话记录""" self.memory.append({"role": role, "content": content}) def get_context(self): """获取所有记忆，用于构造LLM的messages""" return list(self.memory) def clear(self): self.memory.clear() # 在智能体循环中使用 memory = SimpleMemory(max_turns=5) # 每次用户输入和AI回复后，都存入memory memory.add("user", "你好") memory.add("assistant", "你好！我是助手。") # 当需要发起新的请求时，构造messages messages = memory.get_context() + [{"role": "user", "content": "新问题"}]

在LangChain中使用记忆：LangChain提供了ConversationBufferMemory、ConversationSummaryMemory等开箱即用的组件。

from langchain.memory import ConversationBufferMemory memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True) # 在创建AgentExecutor时传入memory参数即可 agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True)

5.2 实现长期记忆（向量数据库检索）

当对话历史很长，或者你需要智能体记住大量知识文档（如产品手册、公司规章）时，就需要长期记忆。其核心是：将信息转换成向量（Embedding）存入向量数据库，提问时，将问题也转换成向量，去数据库里搜索最相关的片段，作为上下文提供给LLM。

# 以ChromaDB为例 from langchain_community.document_loaders import TextLoader from langchain_text_splitters import CharacterTextSplitter from langchain_openai import OpenAIEmbeddings from langchain_chroma import Chroma from langchain.chains import RetrievalQA # 1. 加载文档并分割 loader = TextLoader("./knowledge_base.txt") documents = loader.load() text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50) texts = text_splitter.split_documents(documents) # 2. 创建向量存储 embeddings = OpenAIEmbeddings() vectorstore = Chroma.from_documents(documents=texts, embedding=embeddings, persist_directory="./chroma_db") # 3. 创建检索器 retriever = vectorstore.as_retriever(search_kwargs={"k": 3}) # 返回最相关的3个片段 # 4. 在智能体提示词中，可以加入检索到的内容作为上下文 def get_relevant_knowledge(question): docs = retriever.get_relevant_documents(question) context = "\n".join([doc.page_content for doc in docs]) return context # 在用户提问前，先检索相关知识，并入系统提示 user_question = "我们公司的休假政策是什么？" knowledge = get_relevant_knowledge(user_question) system_prompt = f"""你是一个公司助手。请基于以下已知信息回答问题。如果信息不足，请说明。 已知信息： {knowledge} """

5.3 实现任务规划（Plan）

对于“帮我订一张明天从北京飞上海的最便宜机票，并预订一家外滩附近的酒店”这样的复杂任务，智能体需要先规划步骤，再逐步执行。

实现思路：

1. 规划阶段：让LLM根据任务生成一个步骤列表（JSON格式）。例如：[{"step": 1, "action": "search_flights", "parameters": {...}}, {"step": 2, "action": "compare_prices", ...}, {"step": 3, "action": "book_hotel", ...}]。
2. 执行阶段：智能体按顺序执行每个步骤，每个步骤可能涉及调用工具，并根据上一步的结果调整下一步的参数。
3. 监控与调整：如果某一步失败（如航班已售罄），需要将错误反馈给LLM，让它重新规划或调整后续步骤。

这通常需要更复杂的智能体架构（如ReAct模式或Plan-and-Execute模式）。LangChain的PlanAndExecute执行器就是为此设计的。

实操心得：规划是智能体开发中最具挑战性的部分。LLM生成的计划可能不完整、不可行或存在逻辑漏洞。一个有效的技巧是让LLM在规划时进行“自我批判”，例如：“在生成计划前，先列出执行这个计划可能遇到的三个风险点。” 这能显著提高规划的质量。另外，为复杂任务设计检查点（Checkpoint），让用户在关键步骤（如付款前）进行确认，是保证系统安全可靠的必要措施。

6. 避坑指南与性能优化

在实际开发中，你会遇到各种各样的问题。以下是我从项目中总结的一些常见陷阱和优化技巧。

6.1 常见问题与排查

6.2 提示词工程技巧

智能体的表现极大程度上依赖于提示词（Prompt）。

• 角色扮演（Role-playing）：给LLM一个明确的角色，如“你是一个经验丰富的软件工程师”、“你是一个谨慎的财务分析师”。这能引导其采用特定的思维模式。
• 提供示例（Few-shot）：在提示词中给出1-2个完整的“用户提问-智能体思考-工具调用-最终回答”的示例，能显著提升智能体遵循格式和逻辑的能力。
• 明确输出格式：要求LLM以特定格式（如JSON、XML）或使用特定关键词（如“我需要使用X工具”）来响应，便于程序解析。
• 分步指令：将复杂的指令分解。例如，不要只说“分析这份报告”，而是说“第一步，总结报告核心观点；第二步，提取关键数据；第三步，给出风险评估”。
• 设置约束：明确告诉LLM什么不能做，比如“不要编造信息”、“如果信息不足，请直接说不知道”。

6.3 成本与性能优化

• 上下文管理是省钱关键：LLM API按Token收费，上下文越长越贵。积极使用摘要记忆、向量检索，只传递必要的信息。
• 缓存（Caching）：对于相同或相似的查询（如“今天天气”），可以缓存LLM的响应或工具调用的结果，避免重复计算和API调用。
• 流式输出（Streaming）：对于生成长文本的响应，使用流式接口可以提升用户体验，让用户更快看到部分结果。
• 后备模型（Fallback）：可以设置一个成本更低的模型（如GPT-3.5-turbo）作为主力，当它多次失败或信心不足时，再调用更强的模型（如GPT-4）。
• 评估与监控：建立简单的评估流程，用一批测试问题验证智能体的表现。监控Token使用量、工具调用成功率、用户满意度等指标。

构建AI智能体是一个迭代的过程，很少有一次性就完美的设计。从最小的可行产品（MVP）开始，定义一个明确的小场景，实现它，测试它，根据反馈不断调整提示词、工具设计和流程逻辑。这个“微软AI智能体入门”项目为你提供了绝佳的地图和起点，但真正的探索和建造，现在才刚刚开始。拿起你的工具，从让第一个智能体对你说“现在时间是……”开始吧。