1. 引言：为什么这些概念总让人混淆？

随着大语言模型（LLM）应用的爆发，Prompt、Agent、Function Call、Skill、MCP 这些术语频繁出现在技术文章和招聘要求中。它们看似相近，实则处于不同层次、解决不同问题。很多开发者刚接触时容易混淆，甚至把它们当成同义词。

本文将从定义、定位、关系三个维度逐一拆解，并通过可运行的代码示例，帮助你真正理解它们的分工与协作方式。

2. 核心概念速览

在深入代码之前，先用一张表快速建立整体认知：

概念	本质	解决的问题	类比
Prompt	输入给模型的文本指令	引导模型输出符合预期的内容	给员工的“任务说明书”
Agent	自主决策与执行循环	让模型自主规划、调用工具、完成任务	“项目经理”
Function Call	模型输出结构化调用指令	让模型触发外部函数并获取结果	“接口调用单”
Skill	可复用的能力封装	把特定任务的提示词与逻辑打包复用	“岗位技能包”
MCP	模型与工具间的开放协议	统一连接外部数据与工具的标准	“USB-C 接口标准”

3. Prompt：最基础也最容易被低估

Prompt 是用户与模型交互的直接载体。它可以是简单的一句话，也可以是包含上下文、示例、约束条件的复杂指令。Prompt 的质量直接决定模型输出的质量。

一个结构化的 Prompt 通常包含以下要素：

• 角色设定：告诉模型“你是一个……”。
• 任务描述：明确要完成什么。
• 上下文：提供必要的背景信息。
• 输出格式：指定返回结构，如 JSON、Markdown。
• 示例：给出少量示例（Few-shot）引导风格。

下面是一个简单的 Python 示例，演示如何通过 Prompt 让模型输出结构化 JSON：

from openai import OpenAI
client = OpenAI()
prompt = """
你是一个信息抽取助手。请从以下文本中抽取“公司名称”和“成立年份”，并以 JSON 格式返回。
文本：OpenAI 于 2015 年在美国旧金山成立。
输出格式：
{"company": "公司名称", "year": 成立年份}
"""
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": prompt}]
)
print(response.choices[0].message.content)

Prompt 是“一次性”的输入，它本身不具备记忆和决策能力。当任务变得复杂、需要多步推理时，仅靠 Prompt 往往不够，这时就需要 Agent。

4. Agent：从“回答问题”到“完成任务”

Agent 是一个能够自主规划、调用工具、观察结果并迭代执行的系统。它通常由以下组件构成：

• 大模型：作为“大脑”，负责推理与决策。
• 工具集：可调用的外部函数或 API。
• 记忆：短期上下文与长期存储。
• 循环控制：决定何时停止、何时重试。

一个典型的 Agent 工作流程如下：

flowchart TD
    A[用户输入] --> B[LLM 推理]
    B --> C{需要调用工具?}
    C -->|是| D[Function Call]
    D --> E[执行工具]
    E --> F[观察结果]
    F --> B
    C -->|否| G[输出最终答案]

下面用一个简单的 ReAct 风格 Agent 示例，演示如何让模型自主决定是否调用“天气查询”工具：

import json
from openai import OpenAI
client = OpenAI()
def get_weather(city: str) -> str:
"""模拟天气查询工具"""
weather_map = {"北京": "晴，25°C", "上海": "小雨，22°C"}
return weather_map.get(city, "未知城市")
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "查询指定城市的天气",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "城市名称"}
},
"required": ["city"]
}
}
}
]
messages = [{"role": "user", "content": "北京今天天气怎么样？"}]
第一轮：让模型决定是否调用工具
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=messages,
tools=tools
)
msg = response.choices[0].message
print("模型回复：", msg)
如果模型要求调用工具
if msg.tool_calls:
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = get_weather(args["city"])
messages.append(msg)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": result
})
# 第二轮：把工具结果交给模型生成最终回答
final = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    tools=tools
)
print("最终回答：", final.choices[0].message.content)

Agent 的核心价值在于“自主性”，但它依赖 Function Call 来真正触达外部世界。

5. Function Call：Agent 的“手”

Function Call 是模型输出的一种结构化指令，告诉调用方“我需要调用某个函数，参数是什么”。它本身不是执行器，而是“请求”。真正执行函数的是应用代码。

Function Call 的关键在于：

• 工具描述：用 JSON Schema 描述函数名称、参数和用途。
• 模型决策：模型根据用户输入决定是否调用、传什么参数。
• 结果回传：应用执行函数后，把结果作为新的消息返回给模型。

上面的 Agent 示例已经展示了 Function Call 的完整流程。这里再补充一个更贴近业务的多工具示例：

from openai import OpenAI
import json
client = OpenAI()
def calculate(expression: str) -> str:
"""计算数学表达式"""
return str(eval(expression))
def get_stock_price(symbol: str) -> str:
"""查询股票价格（模拟）"""
prices = {"AAPL": "180.5", "GOOGL": "140.2"}
return prices.get(symbol, "未知")
tools = [
{
"type": "function",
"function": {
"name": "calculate",
"description": "计算数学表达式",
"parameters": {
"type": "object",
"properties": {
"expression": {"type": "string"}
},
"required": ["expression"]
}
}
},
{
"type": "function",
"function": {
"name": "get_stock_price",
"description": "查询股票价格",
"parameters": {
"type": "object",
"properties": {
"symbol": {"type": "string"}
},
"required": ["symbol"]
}
}
}
]
messages = [{"role": "user", "content": "AAPL 的股价乘以 2 是多少？"}]
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=messages,
tools=tools
)
msg = response.choices[0].message
print("模型决策：", msg.tool_calls)
依次执行工具调用
for call in msg.tool_calls:
fn_name = call.function.name
args = json.loads(call.function.arguments)
if fn_name == "calculate":
result = calculate(args["expression"])
elif fn_name == "get_stock_price":
result = get_stock_price(args["symbol"])
messages.append(msg)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": result
})
final = client.chat.completions.create(
model="gpt-4o-mini",
messages=messages,
tools=tools
)
print("最终回答：", final.choices[0].message.content)

Function Call 解决了“模型如何调用工具”的问题，但每个工具都需要单独适配。当工具数量增多时，就需要 Skill 和 MCP 来提升复用性与标准化。

6. Skill：把“经验”打包成“能力”

Skill 是对一组提示词、工具调用逻辑和参数配置的封装，目的是让某个特定能力可以被反复复用。它比单个 Prompt 更复杂，比完整 Agent 更轻量。

一个 Skill 通常包含：

• 触发条件：什么场景下使用该 Skill。
• 提示词模板：可参数化的 Prompt。
• 工具依赖：需要哪些 Function Call。
• 输出处理：如何解析和格式化结果。

下面用一个简单的 Python 类来演示 Skill 的封装思想：

class TranslationSkill:
    """翻译技能封装"""
    def __init__(self, client, target_lang="中文"):
        self.client = client
        self.target_lang = target_lang
def run(self, text: str) -> str:
    prompt = f"""
    你是一个专业翻译。请把以下文本翻译成{self.target_lang}，只输出译文，不要解释。
原文：{text}
"""
resp = self.client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": prompt}]
)
return resp.choices[0].message.content
使用
from openai import OpenAI
client = OpenAI()
skill = TranslationSkill(client, target_lang="英文")
print(skill.run("今天天气很好。"))

Skill 的价值在于“复用”。当多个 Agent 都需要翻译能力时，直接调用同一个 Skill，而不是各自写一套 Prompt。

7. MCP：连接模型与世界的“通用插座”

MCP（Model Context Protocol）是 Anthropic 于 2024 年底提出的开放协议，旨在标准化“模型如何发现并调用外部工具与数据源”。它解决了 Function Call 生态碎片化的问题——每个平台都要单独适配。

MCP 的核心角色：

• MCP Server：暴露工具、数据资源的一方，如数据库、文件系统、第三方 API。
• MCP Client：模型应用侧，负责发现并调用 Server 提供的工具。
• 协议层：定义工具发现、调用、结果返回的标准格式。

下面是一个基于官方 SDK 的 MCP Server 示例（Python）：

from mcp.server.fastmcp import FastMCP
mcp = FastMCP("demo-server")
@mcp.tool()
def add(a: int, b: int) -> int:
"""两数相加"""
return a + b
@mcp.tool()
def get_user_name(user_id: int) -> str:
"""根据 ID 查询用户名（模拟）"""
users = {1: "Alice", 2: "Bob"}
return users.get(user_id, "Unknown")
if name == "main":
mcp.run()

对应的 MCP Client 示例：

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
server_params = StdioServerParameters(
command="python",
args=["demo_server.py"]
)
async def main():
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
tools = await session.list_tools()
print("可用工具：", [t.name for t in tools])
        result = await session.call_tool("add", {"a": 3, "b": 5})
        print("add 结果：", result)
import asyncio
asyncio.run(main())

MCP 的引入让“工具接入”从“点对点”变成“一对多”，大幅降低了集成成本。

8. 四者关系：一张图看懂协作链路

现在可以把四个概念串起来了：

flowchart LR
    A[用户] --> B[Agent]
    B --> C[LLM 推理]
    C --> D[Skill 封装]
    D --> E[Function Call]
    E --> F[MCP Client]
    F --> G[MCP Server]
    G --> H[外部工具/数据]
    H --> G
    G --> F
    F --> E
    E --> D
    D --> C
    C --> B
    B --> A

简单总结：

• Prompt 是“怎么问”。
• Agent 是“谁来决策”。
• Function Call 是“怎么调用”。
• Skill 是“怎么复用”。
• MCP 是“怎么统一连接”。

9. 实战：组合使用一个完整示例

下面把四者组合起来，实现一个“能查天气、能算数、能翻译”的迷你 Agent。这里用 Skill 封装能力，用 Function Call 暴露工具，用 MCP 风格统一管理（简化版），由 Agent 循环决策。

import json
from openai import OpenAI
client = OpenAI()
---------- 1. 定义工具（Function Call 层） ----------
def get_weather(city: str) -> str:
weather = {"北京": "晴，25°C", "上海": "小雨，22°C"}
return weather.get(city, "未知城市")
def calculate(expression: str) -> str:
return str(eval(expression))
---------- 2. 定义 Skill（封装提示词 + 工具） ----------
class WeatherSkill:
def run(self, city):
return get_weather(city)
class CalcSkill:
def run(self, expr):
return calculate(expr)
---------- 3. 工具注册表（MCP 风格统一管理） ----------
TOOL_REGISTRY = {
"get_weather": {
"handler": WeatherSkill().run,
"schema": {
"type": "function",
"function": {
"name": "get_weather",
"description": "查询城市天气",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"]
}
}
}
},
"calculate": {
"handler": CalcSkill().run,
"schema": {
"type": "function",
"function": {
"name": "calculate",
"description": "计算数学表达式",
"parameters": {
"type": "object",
"properties": {"expression": {"type": "string"}},
"required": ["expression"]
}
}
}
}
}
---------- 4. Agent 循环 ----------
def run_agent(user_input: str, max_rounds: int = 3):
messages = [{"role": "user", "content": user_input}]
tools = [v["schema"] for v in TOOL_REGISTRY.values()]
for _ in range(max_rounds):
    resp = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        tools=tools
    )
    msg = resp.choices[0].message
if not msg.tool_calls:
    return msg.content
messages.append(msg)
for call in msg.tool_calls:
fn_name = call.function.name
args = json.loads(call.function.arguments)
handler = TOOL_REGISTRY[fn_name]["handler"]
result = handler(**args)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": result
})
return "达到最大轮次，停止。"
---------- 5. 运行 ----------
print(run_agent("北京天气怎么样？"))
print(run_agent("(3 + 5) * 2 等于多少？"))

这个示例展示了：Agent 负责决策，Skill 封装具体能力，Function Call 负责模型与代码的桥接，工具注册表借鉴了 MCP 的统一管理思想。

10. 总结与选型建议

最后给出一些实践建议：

• 简单任务：只用 Prompt 即可，不要过度设计。
• 多步任务：引入 Agent + Function Call。
• 能力复用：把常用能力封装成 Skill。
• 多工具集成：优先考虑 MCP 标准，避免重复适配。

理解这些概念的分层关系，能帮助你在架构设计时做出更合理的选择，也能在团队协作中更准确地表达需求。希望本文的代码示例能帮你真正跑通从 Prompt 到 MCP 的完整链路。