一文搞懂 AI Agent 核心支柱：从 Tools 到 MCP，从 Skills 到 Loop

摘要：2025 年是 AI Agent 的爆发年，但很多开发者分不清 Function Call、MCP、Skills 和 Loop 的区别。本文将从“手”、“接口”、“手艺”和“大脑运行”四个维度，结合 Python 代码与实践架构，彻底拆解这四大核心概念，并手把手教你如何将它们串联成一个可用的 Agent 系统。

---

前言：为什么你的 AI 总在“一本正经地胡说八道”？

传统的 LLM（大语言模型）像是一个博学的“植物人”——脑子里有无穷知识，但无法触碰现实世界。它不会查实时天气，不会操作数据库，更不会自己写代码并运行。

为了让 AI “活” 过来，业界在短短两年内构建了一套完整的技术栈。这套技术栈的四个基石就是：Tools（工具）、MCP（协议）、Skills（技能） 和 Loop（循环）。

很多新手容易把它们混为一谈，其实它们的职责边界非常清晰：

• Tools 解决“能干啥”（原子能力）
• MCP 解决“怎么接进来”（统一接口）
• Skills 解决“怎么干好”（流程编排）
• Loop 解决“怎么干完”（自主迭代）

下面我们逐一深入。

---

一、Tools（工具）：LLM 的“手脚”——最底层的原子能力

1.1 什么是 Tools？

在 OpenAI 提出 Function Calling 之前，想让 LLM 调用外部函数，你得用繁琐的提示词工程（如 ReAct 风格的文本解析）。现在，Tools 通过标准的 JSON Schema 描述函数签名，让 LLM 能够“感知”外部世界。

说白了，Tools 就是一个个封装好的函数（Function），比如 get_weather(city)、search_web(query)、execute_python(code)。

1.2 代码实战：标准 Tools 定义（Python）

在最新的 OpenAI SDK 或 LangChain 中，Tool 的定义长这样：

from typing import Literal
from pydantic import BaseModel

# 1. 定义输入参数的 Schema
class WeatherInput(BaseModel):
    city: str
    unit: Literal["celsius", "fahrenheit"] = "celsius"

# 2. 定义工具的具体执行逻辑
def get_weather(params: WeatherInput) -> str:
    # 模拟真实 API 调用
    return f"{params.city} 当前气温 22°，天气晴朗。"

# 3. 生成 Tool 描述（传给 LLM 的 JSON）
tool_definition = {
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "获取指定城市的实时天气信息",
        "parameters": WeatherInput.model_json_schema(),
    }
}

关键点：Tools 必须是**无状态（Stateless）且原子性（Atomic）**的，一个 Tool 只专注做一件事。

---

二、MCP（模型上下文协议）：AI 界的“USB-C 万能接口”

2.1 Tools 的痛点：碎片化严重

假设你给 ChatGPT 写了一套基于 openai 格式的 Tools，想迁移到 Claude 或本地开源的 Llama 上，发现它们的 Tool Calling 格式完全不同（有的要求 XML，有的要求特定 JSON）。每接一个新模型，就要重写所有工具适配层——极其痛苦。

2.2 MCP 的诞生

MCP（Model Context Protocol） 由 Anthropic 在 2024 年底开源。它定义了一套标准化的 Client-Server 架构：

• MCP Server：暴露工具、资源（Resource）和提示词（Prompt），比如一个“本地文件系统 Server”或“GitHub Server”。
• MCP Client：AI 应用（如 Claude Desktop、Cursor、VS Code 插件）。

只要 Client 和 Server 都遵循 MCP 协议（基于 JSON-RPC 2.0），AI 就能动态发现并即插即用所有工具。

2.3 MCP 通信流程（精简版）

// Client 发送初始化请求，发现可用工具
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}

// Server 返回可用工具列表
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "read_file",
        "description": "读取本地文件",
        "inputSchema": { "type": "object", "properties": { "path": {"type": "string"} } }
      }
    ]
  }
}

CSDN 划重点：MCP 让 AI 应用从“单机写死工具”进化到了“动态插拔生态”。未来，MCP Server 会像 npm 包一样丰富，开发者只需要维护一个 MCP Client，就能调用全世界的工具生态。

---

三、Skills（技能）：把“工具”变成“手艺”

有了 Tools（锤子、钉子）和 MCP（能够到任何工具箱），AI 就能干好活了吗？不能。因为干好一项复杂任务，需要的是流程，而不是孤立的 API。

3.1 Tools vs Skills

• Tools：“打开文件”、“写入代码”、“执行终端命令”。
• Skills：“创建一个 Spring Boot 博客系统” —— 它内部封装了：检查环境 -> 创建项目结构 -> 写入依赖文件 -> 生成 Entity/Controller -> 编译运行 -> 若报错则修复 这一整套工作流。

3.2 Skills 的核心特征：渐进式披露（Progressive Disclosure）

Skills 和 Tools 最大的工程区别在于上下文占用。

• Tools 的定义必须始终塞进 System Prompt，占满上下文窗口（Context Window）。
• Skills 采用按需加载。系统先给 LLM 一个极简的 Skill 列表（只包含名称和一句话描述）。当 LLM 决定调用某个 Skill 时，系统才把该 Skill 的详细指令（Prompt）和依赖的子工具注入上下文。

Skills 文件结构示例（参考开源项目 anthropic/skills）：

my-blog-generator/
├── SKILL.md          # 主指令：定义角色、流程、约束条件
├── scripts/          # 关联的 Python/Shell 脚本
├── references/       # 参考文档（如 API 文档、架构图）
└── assets/           # 模板文件（如 HTML 模板）

---

四、Loop（反馈循环）：Agent 的“永动机”

LLM 是一次性推理（Inference），Agent 是循环推理（Iterative Reasoning）。

Loop 就是 Agent 的灵魂。它模拟了人类的思考模式：思考（Think）→ 行动（Act）→ 观察（Observe）→ 再思考（Re-think）。这就是著名的 ReAct（Reason + Act） 范式。

4.1 一个极简的 Agent Loop 核心代码

import json
from typing import List, Dict

class SimpleAgent:
    def __init__(self, llm, tools: List[Dict]):
        self.llm = llm
        self.tools = tools
        self.messages = []
        self.max_iterations = 10

    def run(self, user_goal: str):
        self.messages.append({"role": "user", "content": user_goal})
        
        for step in range(self.max_iterations):
            # 1. 思考：调用 LLM 获取下一步动作
            response = self.llm.chat(
                messages=self.messages,
                tools=self.tools,  # 传入可用工具
                tool_choice="auto"
            )
            
            # 2. 判断：LLM 是否想调用工具？
            if response.tool_calls:
                for tool_call in response.tool_calls:
                    # 3. 行动：执行工具
                    tool_name = tool_call.function.name
                    tool_args = json.loads(tool_call.function.arguments)
                    result = self._execute_tool(tool_name, tool_args)
                    
                    # 4. 观察：将结果喂回给 LLM
                    self.messages.append({
                        "role": "tool",
                        "tool_call_id": tool_call.id,
                        "content": result
                    })
                    print(f"[Step {step}] 调用 {tool_name} 返回: {result[:50]}...")
            else:
                # 如果没有工具调用，说明任务完成，返回最终答案
                return response.content
        
        return "达到最大迭代次数，任务终止。"

4.2 工业级 Loop 的“六块积木”

一个能上生产环境的 Loop，远不止上面几行代码。它需要：

1. Automations（触发器）：支持定时或 Webhook 自动唤醒 Loop。
2. Worktrees（隔离环境）：每一次新任务运行在独立的 Git Worktree 或 Docker 容器中，互不污染。
3. Sub-agents（多智能体协作）：分解任务，比如“代码编写员”负责写代码，“代码审查员”负责挑错，由主 Loop 协调。
4. Memory（记忆系统）：使用向量数据库（如 Milvus）或 Redis，将长期记忆存储在模型外部，支持跨会话回忆。

---

五、一图流：四大概念的协作关系（CSDN 读者最爱）

为了方便大家记忆，我将它们整理为一张逻辑拓扑图（文字版）：

用户输入：“帮我部署一个个人网站”
        │
        ▼
┌───────────────────────────────────────┐
│   Agent Core (大脑运行机制 - Loop)    │  ← 在这里进行 Plan→Execute→Observe
└───────────────────────────────────────┘
        │ 拆解任务
        ▼
┌───────────────────────────────────────┐
│   技能层 (Skills - 流程封装)          │
│   “部署网站 Skill”                    │  ← 渐进式加载，节省 Token
└───────────────────────────────────────┘
        │ 调用底层基础能力
        ▼
┌───────────────────────────────────────┐
│   协议层 (MCP - 统一接口)             │  ← USB-C 接口，连接万物的桥梁
└───────────────────────────────────────┘
        │ │ │ │
        ▼ ▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ 文件工具 │ │ 终端工具 │ │ 云端API │  ← 原子能力 (Tools)
└──────────┘ └──────────┘ └──────────┘

---

六、总结与最佳实践建议（干货）

如果你是初学者，请按以下顺序学习：

1. 先死磕 Tools：熟练使用 OpenAI / DashScope 的 Function Calling，这是地基。
2. 再理解 MCP：试着跑通 Claude Desktop 的本地 MCP Server（比如 Filesystem），感受“即插即用”的魅力。
3. 接着模仿 Loop：自己用 Python 写一个 50 行的 while 循环 ReAct Agent，你会有茅塞顿开的感觉。
4. 最后封装 Skills：把你经常做的一套流程（比如“周报生成器”、“代码单元测试生成器”）封装成 Skill 目录结构，沉淀为自己的数字资产。

最后一句忠告：不要把所有的逻辑都塞进 System Prompt！ 善用 Tools 抽离计算逻辑，善用 MCP 解耦外部依赖，善用 Skills 管理复杂流程，善用 Loop 处理不确定性。这四者配合，才是未来 AI 应用开发的正确范式。

---

📢 欢迎在评论区留言讨论你在接入 MCP 或封装 Skills 时遇到的坑，如果本文对你有帮助，请点赞收藏，后续我会出一期《手写一个支持 MCP 协议的轻量级 Agent 框架》！

---