AI模型通信协议

┌─────────────┐
│   MCP Host  │
│  (contains) │
└──────┬──────┘
       │
       ├─────────────────────────┐
       │                         │
   ┌───▼────┐            ┌──────▼──┐
   │ Client │◄───────────┤ Server  │
   │        │  JSON-RPC  │         │
   │        ├───────────►│         │
   └────────┘            └─────────┘
       ▲                       ▲
       │   Message Exchange    │
       └───────────────────────┘

┌────────────────────────────────────────────────────────────────┐
│                  MCP Host (AI Application)                     │
│                                                                │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                    Application Layer                     │  │
│  │  • User Interface                                        │  │
│  │  • Request Routing                                       │  │
│  │  • Response Handling                                     │  │
│  └────────────────┬─────────────────────────────────────────┘  │
│                   │                                            │
│  ┌────────────────▼─────────────────┐  ┌──────────────────┐    │
│  │         MCP Client               │  │   LLM Provider   │    │
│  │                                  │  │  (Claude, GPT,   │    │
│  │  • Connection Management         │◄─┤   Gemini, etc.)  │    │
│  │  • Tool Discovery                │  │                  │    │
│  │  • Request/Response Handling     │  │  • Tool Calling  │    │
│  │  • Protocol Implementation       │  │  • Reasoning     │    │
│  └────────────────┬─────────────────┘  └──────────────────┘    │
│                   │                                            │
└───────────────────┼────────────────────────────────────────────┘
                    │
                    │ MCP Protocol (JSON-RPC 2.0)
                    │ • tools/list
                    │ • tools/call
                    │ • resources/list
                    │ • prompts/list
                    │
┌───────────────────▼────────────────────────────────────────────┐
│                      MCP Server                                │
│                                                                │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                   Server Implementation                  │  │
│  │  • Tool Definitions                                      │  │
│  │  • Request Handling                                      │  │
│  │  • Business Logic                                        │  │
│  └────────────────┬─────────────────────────────────────────┘  │
│                   │                                            │
│  ┌────────────────▼─────────────────────────────────────────┐  │
│  │                    Data Sources                           │ │
│  │                                                           │ │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐    │ │
│  │  │ Database │  │  Files   │  │   APIs   │  │ Other   │    │ │
│  │  └──────────┘  └──────────┘  └──────────┘  └─────────┘    │ │
│  │                                                           │ │
│  └───────────────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────────────┘

{
  "tools": [
    {
      "name": "read_file",
      "description": "Read the complete contents of a file from the file system. Handles various text encodings and provides detailed error messages if the file cannot be read.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string",
            "description": "The absolute or relative path to the file to read"
          }
        },
        "required": ["path"]
      }
    },
    {
      "name": "search_database",
      "description": "Search the customer database using natural language queries. Returns matching records with relevance scores.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "description": "The search query in natural language"
          },
          "limit": {
            "type": "integer",
            "description": "Maximum number of results to return",
            "default": 10,
            "minimum": 1,
            "maximum": 100
          },
          "filters": {
            "type": "object",
            "description": "Optional filters to narrow results",
            "properties": {
              "status": {
                "type": "string",
                "enum": ["active", "inactive", "pending"]
              },
              "created_after": {
                "type": "string",
                "format": "date"
              }
            }
          }
        },
        "required": ["query"]
      }
    },
    {
      "name": "execute_sql",
      "description": "Execute a SQL query against the connected database. Supports SELECT, INSERT, UPDATE, and DELETE operations with transaction support.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "query": {
            "type": "string",
            "description": "The SQL query to execute"
          },
          "params": {
            "type": "array",
            "description": "Query parameters for prepared statements",
            "items": {
              "type": ["string", "number", "boolean", "null"]
            }
          },
          "timeout": {
            "type": "integer",
            "description": "Query timeout in seconds",
            "default": 30
          }
        },
        "required": ["query"]
      }
    }
  ]
}

You are an AI assistant with access to tools via the Model Context Protocol.

You can invoke tools by writing a function_calls block like this:
<function_calls>
<invoke>
<tool_name>tool_name_here</tool_name>
<parameters>
<param_name>value</param_name>
</parameters>
</invoke>
</function_calls>

Available tools:

<tools>
<tool>
<name>read_file</name>
<description>
Read the complete contents of a file from the file system. Handles various text 
encodings and provides detailed error messages if the file cannot be read.
</description>
<parameters>
  <parameter>
    <name>path</name>
    <type>string</type>
    <required>true</required>
    <description>The absolute or relative path to the file to read</description>
  </parameter>
</parameters>
</tool>

<tool>
<name>search_database</name>
<description>
Search the customer database using natural language queries. Returns matching 
records with relevance scores.
</description>
<parameters>
  <parameter>
    <name>query</name>
    <type>string</type>
    <required>true</required>
    <description>The search query in natural language</description>
  </parameter>
  <parameter>
    <name>limit</name>
    <type>integer</type>
    <required>false</required>
    <description>Maximum number of results to return (default: 10, min: 1, max: 100)</description>
  </parameter>
  <parameter>
    <name>filters</name>
    <type>object</type>
    <required>false</required>
    <description>Optional filters: status (active|inactive|pending), created_after (date)</description>
  </parameter>
</parameters>
</tool>

<tool>
<name>execute_sql</name>
<description>
Execute a SQL query against the connected database. Supports SELECT, INSERT, 
UPDATE, and DELETE operations with transaction support.
</description>
<parameters>
  <parameter>
    <name>query</name>
    <type>string</type>
    <required>true</required>
    <description>The SQL query to execute</description>
  </parameter>
  <parameter>
    <name>params</name>
    <type>array</type>
    <required>false</required>
    <description>Query parameters for prepared statements</description>
  </parameter>
  <parameter>
    <name>timeout</name>
    <type>integer</type>
    <required>false</required>
    <description>Query timeout in seconds (default: 30)</description>
  </parameter>
</parameters>
</tool>
</tools>

{
  "model": "gpt-4",
  "messages": [
    {
      "role": "system",
      "content": "You are an AI assistant with access to tools via MCP."
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "read_file",
        "description": "Read the complete contents of a file from the file system. Handles various text encodings and provides detailed error messages if the file cannot be read.",
        "parameters": {
          "type": "object",
          "properties": {
            "path": {
              "type": "string",
              "description": "The absolute or relative path to the file to read"
            }
          },
          "required": ["path"]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "search_database",
        "description": "Search the customer database using natural language queries. Returns matching records with relevance scores.",
        "parameters": {
          "type": "object",
          "properties": {
            "query": {
              "type": "string",
              "description": "The search query in natural language"
            },
            "limit": {
              "type": "integer",
              "description": "Maximum number of results to return",
              "default": 10,
              "minimum": 1,
              "maximum": 100
            },
            "filters": {
              "type": "object",
              "description": "Optional filters to narrow results",
              "properties": {
                "status": {
                  "type": "string",
                  "enum": ["active", "inactive", "pending"]
                },
                "created_after": {
                  "type": "string",
                  "format": "date"
                }
              }
            }
          },
          "required": ["query"]
        }
      }
    }
  ]
}

SYSTEM PROMPT:

You are an AI assistant with access to the following MCP tools:

1. **read_file**
   Purpose: Read the complete contents of a file from the file system
   Parameters:
   - path (required): The absolute or relative path to the file to read
   Example: read_file("/home/user/document.txt")

2. **search_database**
   Purpose: Search the customer database using natural language queries
   Parameters:
   - query (required): The search query in natural language
   - limit (optional): Maximum results to return (1-100, default: 10)
   - filters (optional): Object with status and/or created_after filters
   Example: search_database("customers in California", limit=20)

3. **execute_sql**
   Purpose: Execute SQL queries with transaction support
   Parameters:
   - query (required): The SQL query to execute
   - params (optional): Array of parameters for prepared statements
   - timeout (optional): Query timeout in seconds (default: 30)
   Example: execute_sql("SELECT * FROM users WHERE id = ?", params=[123])

When you need to use a tool, clearly indicate which tool and what parameters.

Application Layer (MCP Host):
┌─────────────────────────────────────────────┐
│         MCP Host (Your AI Application)      │
├─────────────────────────────────────────────┤
│                                             │
│  ┌────────────────────────────────────┐    │
│  │      MCP Client Component          │    │
│  │  (Established by your app)         │    │
│  │  - Sends request to MCP Server     │    │
│  │  - Waits for response              │    │
│  │  - Processes data                  │    │
│  │  - Polls repeatedly                │    │
│  └────────────────────────────────────┘    │
│                     │                       │
│      Request 1      │ Request 2      Request 3
│      (Poll every    │ (Poll every    (Poll every
│       2 seconds)    │  2 seconds)     2 seconds)
│        ▼            │   ▼              ▼
└─────────────────────┼──────────────────────┘
                      │
          ┌──────────────────────────┐
          │   MCP Server             │
          │  (Stock Feed Service)    │
          │  - Waits for requests    │
          │  - Returns current data  │
          │  - Closes connection     │
          └──────────────────────────┘

1. Client: "Give me current stock prices"
2. Client sends request to Server
3. Server responds with data
4. Connection closes
5. Client waits (2 seconds)
6. Client: "Give me current stock prices" (again)
7. Server responds with (possibly) updated data
8. Connection closes
9. (Repeat steps 5-8)

data: message content
id: unique-message-id
event: event-type

GET /mcp/stock-prices HTTP/1.1
Host: server.example.com
Accept: text/event-stream

event: stock_update
data: {"symbol":"AAPL","price":150.25,"change":"+2.50"}
id: stock-001

event: stock_update
data: {"symbol":"GOOGL","price":140.50,"change":"-1.25"}
id: stock-002

event: stock_update
data: {"symbol":"MSFT","price":380.75,"change":"+3.00"}
id: stock-003

Stock prices updated:
- AAPL: $150.25 ↑
- GOOGL: $140.50 ↓
- MSFT: $380.75 ↑

Application Layer (MCP Host):
┌─────────────────────────────────────────────┐
│         MCP Host (Your AI Application)      │
├─────────────────────────────────────────────┤
│                                             │
│  ┌────────────────────────────────────┐    │
│  │      MCP Client Component          │    │
│  │  (Established by your app)         │    │
│  │  - Connects to Stock MCP Server    │    │
│  │  - Receives price updates          │    │
│  │  - Passes context to AI Model      │    │
│  └────────────────────────────────────┘    │
│                     │                       │
│                     │ Uses SSE Connection   │
│                     │ (Persistent)          │
│                     │                       │
└─────────────────────┼───────────────────────┘
                      │
                      │ HTTP + SSE
                      │ GET /stock-prices
                      │ Accept: text/event-stream
                      ▼
          ┌──────────────────────────┐
          │   MCP Server             │
          │  (Stock Feed Service)    │
          │  - Runs stock feed logic │
          │  - Pushes updates via SSE│
          │  - Updates continuously  │
          └──────────────────────────┘

1. Client: "Give me live stock prices"
2. Client establishes SSE connection to Server
3. Connection stays open
4. Server: "Stock price changed to $150"
5. Client receives immediately
6. Server: "Stock price changed to $151"
7. Client receives immediately
8. (Repeat steps 6-7 as long as connection is open)

{
  "jsonrpc": "2.0",
  "id": "unique-request-id",
  "method": "method_name",
  "params": {
    "param1": "value1",
    "param2": "value2"
  }
}

{
  "jsonrpc": "2.0",
  "id": "unique-request-id",
  "result": {
    "status": "success",
    "data": "response-data"
  }
}

{
  "jsonrpc": "2.0",
  "id": "unique-request-id",
  "error": {
    "code": -32600,
    "message": "Invalid Request",
    "data": "Additional error information"
  }
}

1. Client Request:
{
  "jsonrpc": "2.0",
  "id": "req-001",
  "method": "query_database",
  "params": {
    "query": "SELECT * FROM users WHERE status='active'"
  }
}

2. Server Processing:
   - Authenticates request
   - Validates query syntax
   - Executes database query
   - Formats results

3. Server Response:
{
  "jsonrpc": "2.0",
  "id": "req-001",
  "result": {
    "status": "success",
    "rows": [
      {"id": 1, "name": "John", "status": "active"},
      {"id": 2, "name": "Jane", "status": "active"}
    ]
  }
}

4. Client Processing:
   - Receives response
   - Extracts data
   - Passes context to AI model
   - Generates informed response