深度理解agent与llm之间的关系、及mcp与skill的区别

目的：为了解 ai agent平台底层的基本原理，搭建简易的ai code平台。个人理解

文章目录

• • [1、测试项目搭建（使用trae-Builder 模式）](#1、测试项目搭建（使用trae-Builder 模式）)
  • • [1.1 项目提示词：](#1.1 项目提示词：)
    • [1.2 项目生成](#1.2 项目生成)
    • [1.3 Python环境准备](#1.3 Python环境准备)
  • 2、MCP服务端启动
  • • [2.1 mcp 服务与 tools 配置](#2.1 mcp 服务与 tools 配置)
    • [2.2 mcp 手动工具调用](#2.2 mcp 手动工具调用)
  • [3、Agent 模块构建](#3、Agent 模块构建)
  • • [3.1 mcp 客户端配置](#3.1 mcp 客户端配置)
    • [3.2 llm 客户端配置](#3.2 llm 客户端配置)
    • [3.3 Ai agent 配置](#3.3 Ai agent 配置)
  • [4、AI agent 使用测试](#4、AI agent 使用测试)
  • • [4.1 普通对话测试](#4.1 普通对话测试)
    • [4.2 使用mcp服务工具](#4.2 使用mcp服务工具)
  • [5、AI agent 简单总结](#5、AI agent 简单总结)
  • • • [mcp 服务：一个提供各功能函数用于调用的api接口平台。](#mcp 服务：一个提供各功能函数用于调用的api接口平台。)
      • [llm: 整个ai agent 系统的大脑，用于思考解析用户问题。](#llm: 整个ai agent 系统的大脑，用于思考解析用户问题。)
      • [agent : 整个ai agent 系统协调者，也像 llm大脑的四肢，整理用户的输入信息，帮忙进行mcp工具调用。](#agent : 整个ai agent 系统协调者，也像 llm大脑的四肢，整理用户的输入信息，帮忙进行mcp工具调用。)
  • 6、skill

1、测试项目搭建（使用trae-Builder 模式）

1.1 项目提示词：

创建一个名为agent-mcp-skill-learning的测试项目，满足以下要求：

1. 模型强制使用：免费 DeepSeek-V3.1 模型

2. 语言与环境：Python，所有环境、依赖、虚拟环境由我手动配置，项目只生成代码和配置文件

3. 学习目标：

- 理解 Agent 与 LLM 的交互流程

- 学会 MCP（Model Context Protocol）的创建与调用

- 学会自定义 Skill 的创建与注册

- 实现完整工作流：指令 → LLM思考 → 调用MCP /执行Skill → 返回结果

4. 必须生成：

- 清晰的项目结构

- 可直接运行的 Python 代码

- 带注释的 Agent 配置文件

- 自定义 MCP Server 示例

- 自定义 Skill 示例

- 手动环境配置清单（我要手动安装）

- 手动运行步骤

不要自动配置环境，所有依赖我手动安装。

1.2 项目生成

1.3 Python环境准备

# 创建虚拟环境，并安装相关包
agent-mcp-skill-test > python -m venv agent_python      # 当前项目文件夹创建python环境
agent-mcp-skill-test > .\agent_python\Scripts\activate  # 激活环境
（agent_python）agent-mcp-skill-test > pip install -r .\requirements.txt     # 安装项目依赖包

2、MCP服务端启动

2.1 mcp 服务与 tools 配置

• 工具类 tools.py：创建 获取当前时间 、网络搜索内容 、发送邮件 、实时股票信息获取 4个测试功能函数

  from datetime import datetime
  import random
  # 获取当前时间
  def get_current_time() -> str:
      now = datetime.now()
      return f"当前时间：{now.strftime('%Y-%m-%d %H:%M:%S')}"
  
  # 网络搜索内容
  def search_web(query: str) -> str:
      mock_results = [
          f"关于 '{query}' 的搜索结果 1：这是一个模拟的搜索结果",
          f"关于 '{query}' 的搜索结果 2：这是另一个模拟的搜索结果",
          f"关于 '{query}' 的搜索结果 3：还可以有更多搜索结果"
      ]
      return "\n".join(mock_results)
  
  # 发送邮件
  def send_email(to: str, subject: str, body: str) -> str:
      return f"邮件已发送至 {to}，主题：{subject}，内容：{body}"
  
  # 实时股票信息获取
  def get_stock_price(symbol: str) -> str:
      price = round(random.uniform(10, 500), 2)
      change = round(random.uniform(-10, 10), 2)
      return f"股票 {symbol} 当前价格：¥{price}，涨跌：{change:+.2f}%"

• fastapi服务 mcp_server.py ： 创建fastapi，添加请求路由（获取所有工具、工具注册、工具调用等）

  from fastapi import FastAPI, HTTPException
  from pydantic import BaseModel
  from typing import Dict, Any, List
  import uvicorn
  
  
  class ToolCallRequest(BaseModel):
      tool: str
      arguments: Dict[str, Any]
  
  
  class MCPServer:
      def __init__(self, name: str = "demo"):
          self.name = name
          self.app = FastAPI(title=f"{name} MCP Server")       # 创建fastpai应用
          self.tools: Dict[str, Dict[str, Any]] = {}
          self._setup_routes()
      
      # 应用路由设置
      def _setup_routes(self):
          @self.app.get("/")
          async def root():
              return {"message": f"{self.name} MCP Server is running"}
          
          @self.app.get("/tools")                              #  获取所有工具列表
          async def get_tools():
              return {"tools": list(self.tools.values())}
          
          @self.app.post("/call")                              # 工具调用
          async def call_tool(request: ToolCallRequest):
              if request.tool not in self.tools:
                  raise HTTPException(status_code=404, detail=f"Tool {request.tool} not found")
              
              tool_func = self.tools[request.tool]["function"]
              try:
                  result = tool_func(**request.arguments)
                  return {"result": result}
              except Exception as e:
                  raise HTTPException(status_code=500, detail=str(e))
      
      def register_tool(self, name: str, description: str, function):    # 工具注册（主要包含名称、描述和功能函数）
          self.tools[name] = {
              "name": name,
              "description": description,
              "function": function
          }
      
      def run(self, host: str = "127.0.0.1", port: int = 8000):
          uvicorn.run(self.app, host=host, port=port)

• 启动mcp服务 run_server.py

  from mcp_server import MCPServer
  from tools import get_current_time, search_web, send_email, get_stock_price
  
  # mcp 注册工具类（就是把函数名称、描述存储到MCPServer.tools字典变量中）
  def create_demo_server():
      server = MCPServer(name="bigData")
      
      server.register_tool(
          name="get_time",
          description="获取当前时间",
          function=get_current_time
      )
      
      server.register_tool(
          name="search",
          description="在网络上搜索信息，参数：query（搜索关键词）",
          function=search_web
      )
      
      server.register_tool(
          name="send_email",
          description="发送邮件，参数：to（收件人），subject（主题），body（内容）",
          function=send_email
      )
      
      server.register_tool(
          name="get_stock",
          description="获取股票价格，参数：symbol（股票代码）",
          function=get_stock_price
      )
      
      return server
  
  # 启动mcp服务
  if __name__ == "__main__":
      server = create_demo_server()
      print("启动 MCP Demo 服务器...")
      print("访问 http://127.0.0.1:8000/docs 查看可用工具")
      server.run(host="127.0.0.1", port=8000)

2.2 mcp 手动工具调用

访问 http://127.0.0.1:8000/docs

3、Agent 模块构建

3.1 mcp 客户端配置

**目的：**连接 mcp 服务器，方便大模型调用相应mcp工具集，获取数据。

import httpx
from typing import Dict, List, Any


# mcp 客户端
class MCPClient:
    def __init__(self):
        self.servers: Dict[str, str] = {}
    
    def connect(self, server_name: str, server_url: str):
        self.servers[server_name] = server_url                    # 配置mcp服务ip;可以配置多个mcp服务
    
    def _call_server(self, server_name: str, endpoint: str, data: Dict[str, Any] = None, method: str = "POST") -> Any:
        if server_name not in self.servers:
            return f"MCP 服务器 {server_name} 未连接"
        
        server_url = self.servers[server_name]
        url = f"{server_url}{endpoint}"
        
        try:
            with httpx.Client(timeout=30.0) as client:      # 调用指定 mcp服务 相应工具集
                if method.upper() == "GET":
                    response = client.get(url)
                else:
                    response = client.post(url, json=data)
                response.raise_for_status()
                return response.json()
        except httpx.HTTPError as e:
            return f"MCP 调用错误: {str(e)}"
        except Exception as e:
            return f"未知错误: {str(e)}"
    
    def call_tool(self, tool_name: str, server_name: str = "demo", **kwargs) -> str:
        data = {
            "tool": tool_name,
            "arguments": kwargs
        }
        result = self._call_server(server_name, "/call", data)
        
        if isinstance(result, str):
            return result
        
        return result.get("result", "无返回结果")
    
    def get_available_tools(self, server_name: str = "demo") -> str:    # 获取 指定mcp服务 所有可用工具
        result = self._call_server(server_name, "/tools", {})
        
        if isinstance(result, str):
            return result
        
        tools = result.get("tools", [])
        descriptions = []
        for tool in tools:
            descriptions.append(f"- mcp_{tool['name']}: {tool['description']}")
        return "\n".join(descriptions) if descriptions else "无可用 MCP 工具"

# mcp 服务连接测试
if __name__ == "__main__":
    client = MCPClient()
    client.connect("demo", "http://127.0.0.1:8000")
    print(client.get_available_tools("demo"))    # 获取所有可用工具
    print('--------------- 获取当前时间 工具调用 ---------------------')
    print(client.call_tool(tool_name='get_time',server_name='demo'))    # 调用 mcp 工具 -- 后去当前时间

mcp服务返回：

3.2 llm 客户端配置

**目的：**连接 llm API，发送相应提示词，获取大模型结果。

import httpx
from typing import List, Dict, Any

# 阿里千问大模型
class QwenClient:
    def __init__(self, api_key: str, base_url: str):
        self.api_key = api_key
        self.base_url = base_url
        self.model = "Qwen3.5-27B"
    
    def chat(self, messages: List[Dict[str, str]], temperature: float = 0.7) -> str:
        headers = {
            "Authorization": f"Bearer {self.api_key}",     # 大模型 api 秘钥
            "Content-Type": "application/json"
        }
        
        data = {
            "model": self.model,
            "messages": messages,
            "temperature": temperature
        }
        
        try:
            with httpx.Client(timeout=60.0) as client:         # 发送大模型提示词
                response = client.post(
                    f"{self.base_url}/chat/completions",
                    headers=headers,
                    json=data
                )
                response.raise_for_status()
                result = response.json()
                return result["choices"][0]["message"]["content"]
        except httpx.HTTPError as e:
            return f"API 调用错误: {str(e)}"
        except Exception as e:
            return f"未知错误: {str(e)}"

        
# llm api 测试
if __name__ == "__main__":
    client = Qwen3Client("你的秘钥", "http://127.0.0.1:8691/v1")
    print(client.chat([
         {"role": "system", "content": '''你是一位诗词作家，专门写中文4言诗'''},
         {"role": "user", "content": "请帮我生成一首关于"春天"的6句诗"}])   

大模型输出：

3.3 Ai agent 配置

AI Agent： 作为系统协调者，负责串联大模型与 MCP 服务，整理历史对话内容，统一规整提示词，实现各模块高效协同。

import os
import yaml
from typing import Dict, List, Optional, Any
from .llm_client import Qwen3Client
from .mcp_client import MCPClient


class Agent:
    def __init__(self, config_path: str = None):
        self.config = self._load_config(config_path)
        self.llm_client = Qwen3Client(
            api_key=self.config.get('deepseek_api_key'),
            base_url=self.config.get('deepseek_base_url', 'https://api.deepseek.com/v1')
        )

        self.mcp_client = MCPClient()  # MCP 客户端
        self.conversation_history: List[Dict[str, str]] = []   # 对话历史记录

    # 加载配置文件
    def _load_config(self, config_path: str) -> Dict[str, Any]:
        if config_path is None:
            config_path = os.path.join(os.path.dirname(__file__), '..', 'config', 'config.yaml')
        
        if os.path.exists(config_path):
            with open(config_path, 'r', encoding='utf-8') as f:
                return yaml.safe_load(f)
        return {}
    
    # 给 agent 添加 MCP 服务器
    def connect_mcp_server(self, server_name: str, server_url: str):
        self.mcp_client.connect(server_name, server_url)
    
    # 构建系统提示
    def _build_system_prompt(self,mcp_server_name) -> str:
        mcp_tools = self.mcp_client.get_available_tools(mcp_server_name)
        
        prompt = f"""你是一个智能 Agent，可以使用工具来完成任务。

可用的 MCP 工具：
{mcp_tools}

当需要使用工具时，请按照以下格式输出：
<tool_call>
{{"name": "工具名称", "arguments": {{"参数名": "参数值"}}}}
</tool_call>

你可以连续调用多个工具，直到获得足够的信息来回答用户的问题。"""
        
        return prompt
    
    # 从llm响应中提取工具调用
    def _extract_tool_calls(self, response: str) -> List[Dict[str, Any]]:
        import re
        
        tool_calls = []
        pattern = r'<tool_call>\s*({.*?})\s*</tool_call>'
        matches = re.findall(pattern, response, re.DOTALL)
        
        for match in matches:
            try:
                import json
                tool_calls.append(json.loads(match))
            except json.JSONDecodeError:
                continue
        
        return tool_calls
    
    # 执行工具调用
    def _execute_tool_call(self, tool_call: Dict[str, Any],mcp_server_name: str = None) -> str:
        tool_name = tool_call['name']
        arguments = tool_call.get('arguments', {})
        
        if tool_name.startswith('mcp_'):
            mcp_tool = tool_name.replace('mcp_', '')
            result = self.mcp_client.call_tool(tool_name=mcp_tool, server_name=mcp_server_name,**arguments)
        else:
            result = f"未知工具: {tool_name}"
        
        return result
    
    # 用户输入大模型思考并执行工具调用
    def think_and_act(self, user_input: str, max_iterations: int = 5,mcp_server_name: str = None) -> str:
        self.conversation_history.append({"role": "user", "content": user_input}) # 用户输入
        
        system_prompt = self._build_system_prompt(mcp_server_name)
        
        # 设置多轮对话，解决问题
        for iteration in range(max_iterations):
            messages = [{"role": "system", "content": system_prompt}] + self.conversation_history
            
            response = self.llm_client.chat(messages) 
            
            tool_calls = self._extract_tool_calls(response)
            
            if not tool_calls:
                self.conversation_history.append({"role": "assistant", "content": response})
                # 记录agent的与llm的对话流程，包括用户输入和llm的响应
                print('agent 与 llm 对话流程：\n ----------------------\n')
                for message in messages:
                    print(f"{message['role']}: {message['content']}")
                print('\n --------------------------------')
                return response
            
            tool_results = []
            for tool_call in tool_calls:
                result = self._execute_tool_call(tool_call,mcp_server_name)
                tool_results.append(f"工具 {tool_call['name']} 的执行结果：\n{result}")
            
            tool_response = "\n\n".join(tool_results)
            self.conversation_history.append({"role": "assistant", "content": response})  # 记录模型上一轮回复内容
            self.conversation_history.append({"role": "user", "content": tool_response})  # 记录工具调用结果
        
        return "达到最大迭代次数，未能完成任务"
    
    def reset_conversation(self):
        self.conversation_history = []

4、AI agent 使用测试

4.1 普通对话测试

import sys
import os
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from agent import Agent


def main():
    agent = Agent()
       
    agent.connect_mcp_server("demo", "http://127.0.0.1:8000")  # 可连接多个mcp服务器
    
    print("=== Agent-MCP-Skill 学习项目 ===")
    print("输入 'exit' 退出\n")
    
    while True:
        user_input = input("用户: ")
        
        if user_input.lower() in ['exit', 'quit']:
            print("再见！")
            break
        
        print("\nAgent 正在思考...")
        response = agent.think_and_act(user_input,mcp_server_name="demo")
        print(f"\nAgent: {response}\n")
        
        # 重置对话历史，准备下一次对话
        agent.reset_conversation()


if __name__ == "__main__":
    main()

如图红框所示：agent 负责将 system提示词+用户问题 ，转发给llm，llm思考后，无需调用工具，直接返回问题结果。

4.2 使用mcp服务工具

import sys
import os
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from agent import Agent


def main():
    agent = Agent()
    agent.connect_mcp_server("demo", "http://127.0.0.1:8000")
    
    print("=== MCP 工具调用示例 ===")
    
    user_input = "帮我查询当前时间，然后搜索一下 Python 编程"
    print(f"用户: {user_input}")
    
    response = agent.think_and_act(user_input,mcp_server_name='demo')
    print(f"Agent: {response}")


if __name__ == "__main__":
    main()

如图红框所示：

第一步：agent 负责将 system提示词+用户问题 ，转发给llm，llm思考后，需要调用工具，返回需要的工具名称+工具参数。

第一步：agent 先调用llm上一步返回的工具集，收集工具执行结果，然后将 system提示词 + 用户问题 + 工具执行结果 整合，转发给llm，llm思考后，整理所有答案，返还用户。

5、AI agent 简单总结

mcp 服务：一个提供各功能函数用于调用的api接口平台。

llm: 整个ai agent 系统的大脑，用于思考解析用户问题。

agent : 整个ai agent 系统协调者，也像 llm大脑的四肢，整理用户的输入信息，帮忙进行mcp工具调用。

6、skill

待定