入门Agent：读懂四大核心组件，轻松理解AI智能体
入门Agent：读懂四大核心组件，轻松理解AI智能体
最近AI圈最火的词，除了大模型，大概就是Agent（智能体）了。很多人听着觉得高深，总觉得是“遥不可及的技术”，但其实拆解开来就会发现，Agent的核心离不开四个关键部分——模型、工具、中间件、提示词。
就像我们想打造一个“全能虚拟助手”，这四个组件就相当于它的“大脑、双手、神经中枢和指令手册”，各司其职又相互配合，才能让Agent从“只会对话”变成“能自主干活”。今天就用最通俗的话，跟大家拆解这四大核心，帮你快速入门Agent，告别“听不懂”的尴尬。
一、模型（Model）：Agent的“大脑”，决定它有多聪明
模型是Agent的核心，相当于它的“大脑”，也是Agent能思考、能理解的基础。我们常说的GPT-4o、Claude、Llama 3等大语言模型（LLM），就是Agent最常用的“大脑”载体。
很多人会把模型和Agent搞混，其实很简单：模型只是“能思考”，但不能“主动做事”——就像一个智商很高的人，但如果不给他指令、不让他用工具，他也只能在脑子里想，没法落地行动。而Agent之所以能“自主”，核心就是靠模型的推理、规划能力，把模糊的用户需求，拆解成可执行的步骤。
举个类比：模型就像厨师的大脑和厨艺，决定了能做出多好吃的菜，但光有厨艺，没有食材、厨具，也做不出一桌饭。而Agent，就是让这个“厨师”能自己买菜、做饭、上菜的全能角色，模型则是支撑这一切的核心能力来源。
对入门者来说，不用纠结“选哪个模型最好”，重点要知道：模型的能力，直接决定了Agent的推理精度、理解深度——比如能不能听懂复杂需求、能不能合理拆解任务、能不能应对突发情况，这些都靠模型来支撑。
这里给大家一个最简单的LangChain框架模型调用代码案例（以Python+LangChain+OpenAI API为例），基于create_agent相关包，直观感受模型如何作为“大脑”进行思考规划：
from langchain.agents import create_agent, AgentExecutor
from langchain.agents import AgentType
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
# 1. 初始化模型（Agent的“大脑”，使用GPT-3.5-turbo）
openai_api_key = "你的API密钥"
llm = ChatOpenAI(model_name="gpt-3.5-turbo", api_key=openai_api_key)
# 2. 定义提示词（引导模型拆解需求）
prompt = ChatPromptTemplate.from_messages([
("system", "你是一个任务拆解助手，把用户需求拆成3个可执行子步骤，不需要调用任何工具"),
("user", "{input}")
])
# 3. 创建简单Agent（仅包含模型和提示词，无工具）
agent = create_agent(
llm=llm,
prompt=prompt,
agent_type=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
tools=[], # 暂不添加工具，仅展示模型的思考规划能力
verbose=True # 显示Agent的思考过程
)
# 4. 测试：让Agent拆解“查明天天气并提醒我带伞”的需求
agent_executor = AgentExecutor(agent=agent, tools=[], verbose=True)
result = agent_executor.run("查明天天气并提醒我带伞")
print("需求拆解结果：", result)
# 输出示例（包含思考过程）：
# > Entering new AgentExecutor chain...
# 我需要把这个需求拆成3个可执行子步骤。首先，得知道明天的天气情况，所以第一步是查询天气；然后，根据天气判断是否需要带伞；最后，整理结果并给出提醒。
# 1. 调用天气查询工具，获取明天的天气详情（是否下雨、气温）；
# 2. 根据天气结果判断是否需要带伞（有雨则需带，无雨则无需带）；
# 3. 整理天气信息和带伞提醒，反馈给用户。
# > Finished chain.
# 需求拆解结果： 1. 调用天气查询工具，获取明天的天气详情（是否下雨、气温）；2. 根据天气结果判断是否需要带伞（有雨则需带，无雨则无需带）；3. 整理天气信息和带伞提醒，反馈给用户。
这个案例中，我们用LangChain的create_agent创建了基础Agent，模型（大脑）仅通过思考拆解需求，未调用工具，清晰体现了模型的核心规划作用。
import openai
# 初始化模型（选择GPT-3.5-turbo作为Agent的“大脑”）
openai.api_key = "你的API密钥"
def agent_model_think(user需求):
# 调用模型，让模型拆解需求（体现推理规划能力）
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "你是一个任务拆解助手，把用户需求拆成3个可执行子步骤"},
{"role": "user", "content": user需求}
]
)
return response.choices[0].message["content"]
# 测试：让模型拆解“查明天天气并提醒我带伞”的需求
print(agent_model_think("查明天天气并提醒我带伞"))
# 输出示例：
# 1. 调用搜索引擎工具，查询明天的天气情况（温度、是否下雨）；
# 2. 判断明天是否有雨，若有雨则生成带伞提醒；
# 3. 将天气信息和提醒内容整理后反馈给用户。
这个案例中，模型没有直接完成“查天气”的动作，而是通过推理，拆解出了需要调用工具的步骤，这就是模型作为“大脑”的核心作用。
二、工具（Tools）：Agent的“双手”，让想法落地
如果说模型是“大脑”，那工具就是Agent的“双手”，负责把模型的“想法”落地成实际行动。毕竟模型再聪明，也有自己的局限性——比如不能实时查天气、不能算复杂数据、不能发邮件、不能操作电脑文件，而工具，就是用来弥补这些不足的。
Agent的工具范围很广，简单来说，只要是能帮它完成任务的“外部辅助”，都能算工具，比如：
-
基础工具：搜索引擎（实时查信息）、计算器（算数据）、文本编辑器（写文档）；
-
专业工具：API接口（调用其他平台功能，比如发邮件、查订单）、代码解释器（写代码、运行程序）、向量数据库（存储长期记忆）；
-
场景化工具：电商平台接口（查商品、下订单）、客服系统（处理咨询）、数据分析工具（生成报表）。
还是用厨师的类比：工具就像餐厅里的厨具、食材、外卖接口，厨师（模型）有了这些，才能把“做一桌川菜”的想法，变成实际的菜品，还能送到顾客手上。Agent也是一样，模型规划好“要查明天的天气、订后天的机票”，就需要调用搜索引擎、机票预订工具，才能完成这些操作，而不是只停留在“思考”阶段。
核心重点：工具的作用是“扩展Agent的能力边界”，让Agent从“只能说”变成“能做”，这也是Agent和普通聊天机器人最本质的区别之一。
结合上面的模型案例，我们用LangChain框架给Agent加上“工具”，基于create_agent实现完整的工具调用，落地执行需求（延续Python+LangChain+OpenAI API）：
from langchain.agents import create_agent, AgentExecutor
from langchain.agents import AgentType
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.tools import Tool
import requests
# 1. 初始化模型（大脑）
openai_api_key = "你的API密钥"
llm = ChatOpenAI(model_name="gpt-3.5-turbo", api_key=openai_api_key)
# 2. 定义工具（双手）：天气查询工具（调用公开天气API）
def get_weather(city="北京"):
"""查询指定城市的明天天气信息，返回气温和天气状况"""
try:
weather_api = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid=你的天气API密钥&lang=zh_cn"
response = requests.get(weather_api, timeout=5)
data = response.json()
weather = data["weather"][0]["description"]
temp = round(data["main"]["temp"] - 273.15, 1) # 转换为摄氏度
return f"明天{city}天气：{weather}，气温{temp}℃"
except Exception as e:
return f"天气查询失败：{str(e)}"
# 3. 注册工具（LangChain需将工具封装为Tool对象）
tools = [
Tool(
name="get_weather",
func=get_weather,
description="用于查询指定城市的明天天气信息，参数为城市名称（默认北京）"
)
]
# 4. 定义提示词（引导Agent调用工具）
prompt = ChatPromptTemplate.from_messages([
("system", "你是一个天气提醒助手，可调用get_weather工具查询天气，根据天气结果生成带伞或防晒提醒，输出简洁明了"),
("user", "{input}")
])
# 5. 用create_agent创建完整Agent（整合模型、工具、提示词）
agent = create_agent(
llm=llm,
prompt=prompt,
agent_type=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
tools=tools,
verbose=True
)
# 6. 执行Agent任务
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = agent_executor.run("查明天北京天气并提醒我带伞")
print("最终结果：", result)
# 输出示例（包含思考过程）：
# > Entering new AgentExecutor chain...
# 我需要查询明天北京的天气，然后判断是否需要带伞。应该调用get_weather工具，参数为北京。
# Action: get_weather
# Action Input: {"city": "北京"}
# Observation: 明天北京天气：小雨，气温18.5℃
# Thought: 明天北京有雨，需要提醒用户带伞。
# Final Answer: 明天北京天气：小雨，气温18.5℃，记得带伞哦～
# > Finished chain.
# 最终结果： 明天北京天气：小雨，气温18.5℃，记得带伞哦～
这个案例用LangChain的create_agent整合了模型、工具和提示词，Agent自主判断需要调用天气工具，完成需求落地，完美体现“模型+工具”的协同作用，也是LangChain框架开发Agent的基础方式。
import openai
import requests
# 1. 模型（大脑）：负责拆解需求、判断是否需要调用工具
openai.api_key = "你的API密钥"
# 2. 工具（双手）：天气查询工具（调用公开天气API）
def get_weather(city="北京"):
weather_api = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid=你的天气API密钥&lang=zh_cn"
response = requests.get(weather_api)
data = response.json()
# 提取关键天气信息
weather = data["weather"][0]["description"]
temp = round(data["main"]["temp"] - 273.15, 1) # 转换为摄氏度
return f"明天{city}天气：{weather}，气温{temp}℃"
# 3. Agent核心逻辑：模型调用工具，完成任务
def agent_do_task(user需求):
# 第一步：模型拆解需求，判断是否需要调用工具
model_response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "你可以调用get_weather工具查询天气，若不需要工具则直接回答"},
{"role": "user", "content": user需求}
],
functions=[
{
"name": "get_weather",
"description": "查询指定城市的天气信息",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "城市名称，默认北京"}
}
}
}
]
)
# 第二步：判断是否需要调用工具，执行对应操作
if model_response.choices[0].message.get("function_call"):
# 调用天气工具
city = eval(model_response.choices[0].message["function_call"]["arguments"])["city"]
weather_info = get_weather(city)
# 第三步：模型整理工具结果，给出最终反馈
final_response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "根据天气信息，生成带伞提醒"},
{"role": "user", "content": user需求},
{"role": "function", "name": "get_weather", "content": weather_info}
]
)
return final_response.choices[0].message["content"]
else:
return model_response.choices[0].message["content"]
# 测试：让Agent完成“查明天北京天气并提醒我带伞”
print(agent_do_task("查明天北京天气并提醒我带伞"))
# 输出示例：明天北京天气：小雨，气温18.5℃，记得带伞哦～
这个案例中，模型（大脑）判断需要调用天气工具，工具（双手）完成天气查询，最终协同完成了用户需求，完美体现了“模型+工具”的核心配合。
三、中间件（Middleware）：Agent的“神经中枢”，打通所有环节
这是很多人容易忽略的一个组件，但却是Agent能“顺畅工作”的关键——中间件，相当于Agent的“神经中枢”，负责连接模型、工具、提示词，解决它们之间的“沟通问题”，让整个系统高效协同。
你可以把它理解成“连接器”+“调节器”：没有中间件，模型、工具、提示词就是三个独立的“孤岛”——模型不知道该调用哪个工具，工具不知道该执行什么指令，提示词也无法动态适配不同场景，Agent自然无法正常工作。
中间件的核心作用，主要有这3点，通俗好懂：
-
连接适配：让模型能“看懂”工具的调用规则，让工具能“接收”模型的指令——比如模型想调用搜索引擎，中间件就会把模型的需求，转换成搜索引擎能识别的格式，再把搜索结果转换回模型能理解的内容；
-
动态调控：比如动态切换提示词（同一个Agent，面对客服场景和报告场景，用不同的提示词）、监控工具调用情况、处理错误（比如工具调用失败，中间件会让模型重新尝试或更换工具）；
-
解耦复用：把日志记录、权限检查、性能监控这些通用功能，统一交给中间件处理，不用在每个工具、模型里重复写代码，降低开发和维护成本。
简单说，中间件就像餐厅里的“传菜员”+“调度员”，连接厨师（模型）、厨具（工具）、菜单（提示词），确保每个环节衔接顺畅，不出现混乱。
下面用LangChain框架实现一个简单的中间件（整合工具管理、错误处理），结合create_agent，让Agent的模型、工具衔接更顺畅，提升稳定性：
from langchain.agents import create_agent, AgentExecutor
from langchain.agents import AgentType
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.tools import Tool
import requests
# 中间件：工具管理+错误处理（LangChain中可通过自定义工具和回调实现）
class AgentMiddleware:
def __init__(self, openai_api_key):
self.llm = ChatOpenAI(model_name="gpt-3.5-turbo", api_key=openai_api_key)
self.tools = self._register_tools() # 注册并管理工具
# 工具注册与错误处理（中间件核心功能）
def _register_tools(self):
# 封装天气工具，加入错误处理
def get_weather(city="北京"):
"""查询指定城市的明天天气信息，返回气温和天气状况"""
try:
weather_api = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid=你的天气API密钥&lang=zh_cn"
response = requests.get(weather_api, timeout=5)
response.raise_for_status() # 抛出HTTP错误
data = response.json()
weather = data["weather"][0]["description"]
temp = round(data["main"]["temp"] - 273.15, 1)
return f"明天{city}天气：{weather}，气温{temp}℃"
except Exception as e:
# 中间件统一处理工具调用错误
return f"【中间件提示】天气查询失败：{str(e)}，请尝试更换城市或稍后再试"
# 注册工具到LangChain
return [
Tool(
name="get_weather",
func=get_weather,
description="用于查询指定城市的明天天气信息，参数为城市名称（默认北京）"
)
]
# 中间件连接Agent，创建并执行任务
def create_and_run_agent(self, user_input):
# 定义提示词（中间件可动态调整提示词，适配不同场景）
prompt = ChatPromptTemplate.from_messages([
("system", "你是一个天气提醒助手，可调用get_weather工具，工具调用异常会有中间件提示，根据提示调整或直接反馈结果"),
("user", "{input}")
])
# 用create_agent创建Agent，中间件注入工具和模型
agent = create_agent(
llm=self.llm,
prompt=prompt,
agent_type=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
tools=self.tools,
verbose=True
)
# 执行Agent任务
agent_executor = AgentExecutor(agent=agent, tools=self.tools, verbose=True)
return agent_executor.run(user_input)
# 测试：模拟工具调用失败（故意输错天气API密钥）
if __name__ == "__main__":
openai_api_key = "你的API密钥"
middleware = AgentMiddleware(openai_api_key)
result = middleware.create_and_run_agent("查明天上海天气并提醒我带伞")
print("最终结果：", result)
# 输出示例（包含中间件错误处理）：
# > Entering new AgentExecutor chain...
# 我需要查询明天上海的天气，调用get_weather工具，参数为上海。
# Action: get_weather
# Action Input: {"city": "上海"}
# Observation: 【中间件提示】天气查询失败：API key invalid，请尝试更换城市或稍后再试
# Thought: 工具调用失败，中间件已给出提示，直接将提示反馈给用户。
# Final Answer: 天气查询失败：API key invalid，请尝试更换城市或稍后再试
# > Finished chain.
# 最终结果： 天气查询失败：API key invalid，请尝试更换城市或稍后再试
这个案例中，中间件实现了LangChain工具的注册、统一错误处理，通过create_agent将模型、工具、提示词无缝衔接，相当于Agent的“神经中枢”，避免了组件脱节，让系统更稳定。
import openai
import requests
# 中间件：负责连接模型、工具，处理适配和错误
class AgentMiddleware:
def __init__(self, model_name="gpt-3.5-turbo"):
self.model_name = model_name
self.tools = {"get_weather": self.get_weather} # 注册工具
# 工具：天气查询（被中间件管理）
def get_weather(self, city="北京"):
try:
weather_api = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid=你的天气API密钥&lang=zh_cn"
response = requests.get(weather_api, timeout=5)
response.raise_for_status() # 抛出HTTP错误
data = response.json()
weather = data["weather"][0]["description"]
temp = round(data["main"]["temp"] - 273.15, 1)
return f"明天{city}天气：{weather}，气温{temp}℃"
except Exception as e:
# 中间件处理工具调用错误
return f"天气查询失败：{str(e)}，请尝试更换城市或稍后再试"
# 中间件核心：适配模型指令，调用对应工具
def call_tool(self, tool_name, parameters):
if tool_name in self.tools:
return self.tools[tool_name](**parameters)
else:
return f"未找到工具：{tool_name}"
# 中间件核心：连接模型，传递指令和工具结果
def connect_model(self, user需求):
response = openai.ChatCompletion.create(
model=self.model_name,
messages=[
{"role": "system", "content": "你可以调用get_weather工具，工具调用由中间件处理"},
{"role": "user", "content": user需求}
],
functions=[
{
"name": "get_weather",
"description": "查询指定城市的天气信息",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "城市名称，默认北京"}
}
}
}
]
)
return response.choices[0].message
# Agent核心：整合中间件、模型、工具
def agent_with_middleware(user需求):
middleware = AgentMiddleware()
# 中间件连接模型，获取模型指令
model_msg = middleware.connect_model(user需求)
# 中间件处理工具调用
if model_msg.get("function_call"):
tool_name = model_msg["function_call"]["name"]
parameters = eval(model_msg["function_call"]["arguments"])
tool_result = middleware.call_tool(tool_name, parameters)
# 中间件将工具结果反馈给模型，生成最终响应
final_response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": user需求},
{"role": "function", "name": tool_name, "content": tool_result}
]
)
return final_response.choices[0].message["content"]
else:
return model_msg["content"]
# 测试：模拟工具调用失败（故意输错API密钥）
print(agent_with_middleware("查明天上海天气并提醒我带伞"))
# 输出示例：天气查询失败：API key invalid，请尝试更换城市或稍后再试
这个中间件案例中，实现了工具注册、错误处理、模型与工具的适配，相当于给Agent加上了“神经中枢”，避免了模型和工具的“脱节”，让整个系统更稳定。
四、提示词（Prompt）：Agent的“指令手册”，教它怎么思考、怎么做事
提示词，就是我们给Agent的“指令”，相当于它的“操作手册”，决定了Agent“怎么思考、怎么做事”。很多人觉得提示词就是“一句话需求”，比如“帮我写个方案”，但其实好的提示词，能让Agent的效率翻倍，差的提示词，只会让Agent“跑偏”。
举个直观的例子：
❌ 差的提示词（模糊指令）：“帮我写个方案”——就像跟厨师说“给我来个菜”，厨师不知道你要川菜还是粤菜、要辣还是不辣，最后做出来的菜很可能不符合预期；
✅ 好的提示词（精准指令）：“我是教育行业运营，要写一份针对高中生家长的暑期课程推广方案，包含3个引流渠道、预算5万以内、风格接地气，输出为PPT大纲格式”——就像跟厨师说“微辣的水煮鱼，用黑鱼，少油少盐，两人份”，清晰明了，Agent能快速get核心需求，给出精准结果。
在Agent中，提示词的作用远不止“下达需求”，还能：
-
界定角色：告诉Agent“你是一个专业的客服助手”“你是一个数据分析专家”，让它明确自己的定位；
-
引导推理：通过思维链、思维树等方式，引导模型把复杂任务拆解成可执行的子步骤；
-
约束行为：明确Agent不能做什么、输出格式是什么，避免出现无效或错误的结果。
这里要区分一个小知识点：提示词和我们之前说的“工具”不一样——提示词是“口头指令”，每次任务都可能需要调整；而工具是“实际操作的载体”，是Agent完成任务的“硬件支撑”，两者相辅相成，缺一不可。
下面用LangChain框架+create_agent，展示不同提示词对Agent的影响，直观感受提示词的“指令手册”作用，代码更贴合实际开发场景：
from langchain.agents import create_agent, AgentExecutor
from langchain.agents import AgentType
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.tools import Tool
import requests
# 1. 初始化模型和工具（复用之前的天气工具）
openai_api_key = "你的API密钥"
llm = ChatOpenAI(model_name="gpt-3.5-turbo", api_key=openai_api_key)
def get_weather(city="北京"):
"""查询指定城市的明天天气信息，返回气温和天气状况"""
weather_api = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid=你的天气API密钥&lang=zh_cn"
response = requests.get(weather_api)
data = response.json()
weather = data["weather"][0]["description"]
temp = round(data["main"]["temp"] - 273.15, 1)
return f"明天{city}天气：{weather}，气温{temp}℃"
tools = [
Tool(
name="get_weather",
func=get_weather,
description="用于查询指定城市的明天天气信息，参数为城市名称（默认北京）"
)
]
# 2. 定义不同提示词（指令手册），通过中间件动态切换
def create_agent_with_prompt(prompt_content):
"""根据不同提示词，用create_agent创建对应Agent"""
prompt = ChatPromptTemplate.from_messages([
("system", prompt_content),
("user", "{input}")
])
return create_agent(
llm=llm,
prompt=prompt,
agent_type=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
tools=tools,
verbose=False # 关闭思考过程，仅看输出结果
)
# 3. 测试不同提示词的效果
user_input = "查明天广州天气，给我提醒"
# 提示词1：模糊提示
prompt1 = "帮我处理这个需求"
agent1 = create_agent_with_prompt(prompt1)
executor1 = AgentExecutor(agent=agent1, tools=tools, verbose=False)
print("模糊提示输出：", executor1.run(user_input))
# 提示词2：精准提示
prompt2 = "你是天气提醒助手，调用get_weather查指定城市明天天气，有雨提醒带伞，无雨提醒防晒，输出简洁（≤50字）"
agent2 = create_agent_with_prompt(prompt2)
executor2 = AgentExecutor(agent=agent2, tools=tools, verbose=False)
print("精准提示输出：", executor2.run(user_input))
# 提示词3：角色提示
prompt3 = "你是专业职场助理，语气正式，查指定城市明天天气，包含详情和礼貌提醒，格式规范"
agent3 = create_agent_with_prompt(prompt3)
executor3 = AgentExecutor(agent=agent3, tools=tools, verbose=False)
print("角色提示输出：", executor3.run(user_input))
# 输出示例：
# 模糊提示输出： 请明确需要查询的城市名称，以便我调用工具查询天气并给出提醒。
# 精准提示输出： 明天广州小雨，气温20℃，记得带伞，注意保暖～
# 角色提示输出： 您好，明天广州天气为小雨，气温20℃，建议您携带雨伞，注意出行安全。
这个案例用LangChain的create_agent，根据不同提示词创建不同行为的Agent，清晰体现了提示词的“指令手册”作用——精准、有角色界定的提示词，能让Agent输出更符合预期的结果，这也是LangChain开发中优化Agent性能的关键。
import openai
openai.api_key = "你的API密钥"
# 定义不同的提示词（指令手册）
def agent_with_prompt(user需求, prompt_type):
# 不同场景的提示词（引导Agent的行为）
prompts = {
"模糊提示": "帮我处理这个需求",
"精准提示": "你是一个天气提醒助手，需要先调用天气工具查询指定城市明天天气，若有雨则生成带伞提醒，无雨则提示注意防晒，输出格式简洁，不超过50字",
"角色提示": "你是一个专业的职场助理，语气正式，处理天气提醒需求时，需包含天气详情和礼貌提醒，输出格式规范"
}
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": prompts[prompt_type]},
{"role": "user", "content": user需求}
],
functions=[
{
"name": "get_weather",
"description": "查询指定城市的天气信息",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "城市名称"}
}
}
}
]
)
return response.choices[0].message["content"]
# 测试不同提示词的效果
user需求 = "查明天广州天气，给我提醒"
print("模糊提示输出：", agent_with_prompt(user需求, "模糊提示"))
# 输出示例：请告诉我需要查询哪个城市的天气，以便我为你处理。
print("精准提示输出：", agent_with_prompt(user需求, "精准提示"))
# 输出示例：明天广州小雨，气温20℃，记得带伞，注意保暖～
print("角色提示输出：", agent_with_prompt(user需求, "角色提示"))
# 输出示例：您好，明天广州天气为小雨，气温20℃，建议您携带雨伞，注意出行安全。
从案例能明显看出，提示词的精准度、角色界定，直接决定了Agent的输出效果——好的提示词，能让Agent精准get需求，输出符合预期的结果，这就是“指令手册”的核心价值。
最后：用一句话总结Agent的四大组件
模型（大脑）负责“思考规划”，工具（双手）负责“落地执行”，中间件（神经中枢）负责“连接调控”，提示词（指令手册）负责“引导约束”——这四个组件协同工作，就构成了一个能自主接收需求、规划路径、调用工具、完成任务的Agent。
对入门者来说，不用一开始就追求“搭建复杂的Agent”，先搞懂这四大核心的作用，再慢慢尝试组合（比如用简单的模型+搜索引擎工具+基础提示词），就能快速感受到Agent的魅力。
毕竟Agent的核心不是“高深的技术”，而是“让AI替我们干活”——把复杂的任务交给它，我们只需要专注于更有价值的事情，这也是Agent最动人的地方。后续我也会分享更多Agent的入门实践，感兴趣的可以关注～
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
5
0- 0
已为社区贡献4条内容
所有评论(0)