---
# System prepended metadata

title: 2-1 Client-Server 架構詳解
tags: [MCP 白皮書]

---

# 2-1 Client-Server 架構詳解

回到白皮書首頁：[MCP 全方位技術白皮書](/@thc1006/mcp-whitepaper-home)

---

## MCP 的三層架構：不只是 Client-Server，而是智慧化生態系統

當我們談到 MCP 的 Client-Server 架構時，很多人第一個想法可能是「又是一個傳統的客戶端-伺服器模式」。但實際上，MCP 創建了一個**三層智慧化協作架構**，徹底重新定義了 AI 與外部世界的互動方式。

## 核心架構：三個角色的協同演出

### MCP Host：AI 的大腦中樞

**MCP Host** 是整個生態系統的「指揮官」，通常是 AI 應用程式、IDE 或桌面客戶端。

**主要職責：**
- **決策制定**：根據用戶需求決定需要什麼工具
- **資源協調**：管理多個 MCP Client 的連接
- **上下文維護**：保持對話狀態和記憶
- **結果整合**：將來自不同 MCP Server 的結果統一處理

**實際例子：Claude Desktop**
```
用戶：「幫我分析這個專案的 GitHub 活動，並更新專案文件」

Claude Desktop (MCP Host)：
1. 理解需求：需要 GitHub 數據 + 文件操作
2. 決定策略：先獲取 GitHub 數據，再進行文件處理
3. 協調 Client：指示不同的 MCP Client 執行任務
4. 整合結果：將分析結果寫入文件
```

### MCP Client：協議翻譯官

**MCP Client** 是協議的具體實現者，負責維持與 MCP Server 的一對一連接。

**核心功能：**
- **協議轉換**：將 Host 的高層次指令轉為 MCP 協議調用
- **連接管理**：維護與 Server 的穩定連接
- **錯誤處理**：處理網路異常、超時等問題
- **安全管控**：執行認證、授權和資料驗證

**技術實現：**
```python
class MCPClient:
    def __init__(self, server_uri: str):
        self.server_uri = server_uri
        self.transport = None
        self.session = None
        
    async def connect(self):
        """建立與 MCP Server 的連接"""
        self.transport = await self._create_transport()
        self.session = await self._handshake()
        
    async def list_tools(self) -> List[Tool]:
        """發現 Server 提供的工具"""
        response = await self.session.request("tools/list")
        return [Tool.from_dict(tool) for tool in response.tools]
        
    async def call_tool(self, name: str, args: dict) -> dict:
        """調用特定工具"""
        response = await self.session.request("tools/call", {
            "name": name,
            "arguments": args
        })
        return response.content
```

### MCP Server：專業工具提供者

**MCP Server** 是實際執行工作的「專家」，每個 Server 通常專精於特定領域。

**核心職責：**
- **能力暴露**：向 Client 描述自己提供的工具和資源
- **任務執行**：執行 Client 請求的具體操作
- **資料轉換**：將外部系統的資料轉換為 MCP 標準格式
- **安全控制**：確保操作在授權範圍內

**GitHub MCP Server 例子：**
```python
class GitHubMCPServer:
    def __init__(self, github_token: str):
        self.github = GitHub(token=github_token)
        
    def list_tools(self) -> List[Tool]:
        return [
            Tool(
                name="get_repository",
                description="獲取 GitHub 倉庫資訊",
                parameters={
                    "owner": {"type": "string", "required": True},
                    "repo": {"type": "string", "required": True}
                }
            ),
            Tool(
                name="list_issues",
                description="列出倉庫的 Issues",
                parameters={
                    "owner": {"type": "string", "required": True},
                    "repo": {"type": "string", "required": True},
                    "state": {"type": "string", "enum": ["open", "closed", "all"]}
                }
            )
        ]
        
    async def handle_tool_call(self, tool_name: str, arguments: dict):
        if tool_name == "get_repository":
            return await self._get_repository(arguments)
        elif tool_name == "list_issues":
            return await self._list_issues(arguments)
        else:
            raise ToolNotFoundError(f"Unknown tool: {tool_name}")
```

## 資料流向與控制流程

### 完整的請求-響應週期

```
用戶輸入
    ↓
MCP Host (AI 決策)
    ↓
MCP Client (協議轉換)
    ↓
MCP Server (工具執行)
    ↓
外部系統 (實際操作)
    ↓
結果回傳 (逆向流動)
```

### 實際案例：分析專案活動

**步驟一：需求理解**
```
用戶：「分析我們專案最近一週的開發活動」

MCP Host：
- 解析需求：需要 GitHub 資料分析
- 識別所需工具：GitHub API、數據分析工具
- 制定執行計畫：獲取 commits → 分析趨勢 → 生成報告
```

**步驟二：工具發現**
```
MCP Host → MCP Client：「列出所有可用工具」

MCP Client → GitHub MCP Server：GET /tools/list

GitHub MCP Server → MCP Client：
{
  "tools": [
    {"name": "get_commits", "description": "獲取提交記錄"},
    {"name": "get_pull_requests", "description": "獲取 PR 資訊"},
    {"name": "get_contributors", "description": "獲取貢獻者資訊"}
  ]
}
```

**步驟三：數據獲取**
```
MCP Host → MCP Client：「調用 get_commits 工具」

MCP Client → GitHub MCP Server：
{
  "method": "tools/call",
  "params": {
    "name": "get_commits",
    "arguments": {
      "repo": "myproject",
      "since": "2025-08-09T00:00:00Z",
      "until": "2025-08-16T23:59:59Z"
    }
  }
}

GitHub MCP Server → GitHub API：實際 API 調用

GitHub API → GitHub MCP Server：返回 commits 數據

GitHub MCP Server → MCP Client：格式化的結果

MCP Client → MCP Host：結構化數據
```

**步驟四：結果處理**
```
MCP Host：
- 接收所有數據
- 進行智慧化分析
- 生成人類可讀的報告
- 返回給用戶
```

## 傳輸層與通訊協議

### 支援的傳輸方式

**1. HTTP/HTTPS (最常用)**
```python
# RESTful 風格的 MCP over HTTP
transport = HTTPTransport("https://api.example.com/mcp")
client = MCPClient(transport)
```

**2. WebSocket (即時通訊)**
```python
# 適合需要雙向即時通訊的場景
transport = WebSocketTransport("wss://realtime.example.com/mcp")
client = MCPClient(transport)
```

**3. Unix Domain Socket (本地通訊)**
```python
# 適合同機器上的 MCP Server
transport = UnixSocketTransport("/tmp/mcp-server.sock")
client = MCPClient(transport)
```

**4. Standard I/O (程序間通訊)**
```python
# 適合可執行程式形式的 MCP Server
transport = StdioTransport("./my-mcp-server")
client = MCPClient(transport)
```

### JSON-RPC 2.0 協議層

MCP 建立在 JSON-RPC 2.0 之上，確保標準化的通訊格式：

**請求格式：**
```json
{
  "jsonrpc": "2.0",
  "id": "req-123",
  "method": "tools/call",
  "params": {
    "name": "get_file_content",
    "arguments": {
      "path": "/home/user/document.txt"
    }
  }
}
```

**響應格式：**
```json
{
  "jsonrpc": "2.0",
  "id": "req-123",
  "result": {
    "content": "檔案內容...",
    "encoding": "utf-8",
    "size": 1024
  }
}
```

**錯誤格式：**
```json
{
  "jsonrpc": "2.0",
  "id": "req-123",
  "error": {
    "code": -32602,
    "message": "Invalid params",
    "data": {
      "details": "Path parameter is required"
    }
  }
}
```

## 連接生命週期管理

### 連接建立流程

```
1. Transport 建立
   ↓
2. 能力協商 (Capability Negotiation)
   ↓  
3. 身份驗證 (Authentication)
   ↓
4. 工具發現 (Tool Discovery)
   ↓
5. 正常通訊開始
```

**能力協商範例：**
```json
Client → Server:
{
  "jsonrpc": "2.0",
  "method": "initialize",
  "params": {
    "protocolVersion": "2025-06-18",
    "capabilities": {
      "tools": {"listChanged": true},
      "resources": {"subscribe": true},
      "prompts": {"listChanged": true}
    },
    "clientInfo": {
      "name": "Claude Desktop",
      "version": "1.0.0"
    }
  }
}

Server → Client:
{
  "jsonrpc": "2.0",
  "result": {
    "protocolVersion": "2025-06-18",
    "capabilities": {
      "tools": {"listChanged": true},
      "resources": {"listChanged": true},
      "prompts": {"listChanged": false}
    },
    "serverInfo": {
      "name": "GitHub MCP Server",
      "version": "2.1.0"
    }
  }
}
```

### 心跳與健康檢查

```python
class MCPClient:
    async def _maintain_connection(self):
        """維護連接健康"""
        while self.connected:
            try:
                # 發送 ping 檢查連接
                await self.ping()
                await asyncio.sleep(30)  # 30 秒心跳間隔
            except ConnectionError:
                await self._reconnect()
            except Exception as e:
                self.logger.error(f"Health check failed: {e}")
                
    async def _reconnect(self):
        """重新連接邏輯"""
        for attempt in range(3):
            try:
                await self.connect()
                self.logger.info("Reconnected successfully")
                break
            except Exception as e:
                await asyncio.sleep(2 ** attempt)  # 指數退避
```

## 多 Server 協調與負載均衡

### Host 的智慧化調度

```python
class MCPHost:
    def __init__(self):
        self.servers = {}
        self.capabilities_map = {}
        
    async def register_server(self, name: str, client: MCPClient):
        """註冊新的 MCP Server"""
        self.servers[name] = client
        tools = await client.list_tools()
        
        # 建立能力映射
        for tool in tools:
            if tool.category not in self.capabilities_map:
                self.capabilities_map[tool.category] = []
            self.capabilities_map[tool.category].append({
                "server": name,
                "tool": tool
            })
    
    async def execute_task(self, task_description: str):
        """智慧化選擇最適合的 Server 執行任務"""
        # AI 分析任務需求
        required_capabilities = self.analyze_task(task_description)
        
        # 選擇最適合的 Server
        best_server = self.select_best_server(required_capabilities)
        
        # 執行任務
        return await self.servers[best_server].execute_task(task_description)
```

### 容錯與備援機制

```python
class ResilientMCPClient:
    def __init__(self, primary_servers: List[str], backup_servers: List[str]):
        self.primary_servers = primary_servers
        self.backup_servers = backup_servers
        self.current_server_index = 0
        
    async def call_tool_with_fallback(self, tool_name: str, args: dict):
        """帶有故障轉移的工具調用"""
        servers_to_try = self.primary_servers + self.backup_servers
        
        for server_uri in servers_to_try:
            try:
                client = await self.get_client(server_uri)
                result = await client.call_tool(tool_name, args)
                return result
            except Exception as e:
                self.logger.warning(f"Server {server_uri} failed: {e}")
                continue
                
        raise AllServersFailedError("No available servers")
```

## 安全性與訪問控制

### 傳輸層安全

```python
class SecureMCPTransport:
    def __init__(self, server_uri: str, cert_path: str = None):
        self.server_uri = server_uri
        self.ssl_context = self._create_ssl_context(cert_path)
        
    def _create_ssl_context(self, cert_path: str):
        context = ssl.create_default_context()
        if cert_path:
            context.load_verify_locations(cert_path)
        context.check_hostname = True
        context.verify_mode = ssl.CERT_REQUIRED
        return context
```

### OAuth 2.1 整合

```python
class OAuth21MCPClient:
    def __init__(self, client_id: str, client_secret: str):
        self.oauth_client = OAuth21Client(client_id, client_secret)
        self.access_token = None
        
    async def authenticate(self):
        """執行 OAuth 2.1 認證流程"""
        self.access_token = await self.oauth_client.get_access_token()
        
    async def make_authenticated_request(self, method: str, params: dict):
        """帶有認證的請求"""
        headers = {
            "Authorization": f"Bearer {self.access_token}",
            "Content-Type": "application/json"
        }
        return await self._send_request(method, params, headers)
```

## 台灣企業部署策略

### 混合雲架構

```
本地 MCP Servers (敏感數據)
├─ 財務系統 MCP Server
├─ 人事系統 MCP Server  
└─ 內部文件 MCP Server

雲端 MCP Servers (一般服務)
├─ GitHub MCP Server
├─ Google Workspace MCP Server
└─ Slack MCP Server

邊緣 MCP Servers (即時服務)
├─ IoT 設備 MCP Server
├─ 製造設備 MCP Server
└─ 監控系統 MCP Server
```

### 段階式部署建議

**第一階段：概念驗證 (1-2 個月)**
- 部署 2-3 個簡單的 MCP Server
- 建立基本的 MCP Client 連接
- 驗證核心功能

**第二階段：生產試點 (3-4 個月)**  
- 整合核心業務系統
- 建立安全和監控機制
- 培訓內部團隊

**第三階段：全面推廣 (6-12 個月)**
- 擴展到所有部門
- 建立企業級治理機制
- 持續最佳化和創新

## 效能最佳化策略

### 連接池管理

```python
class MCPConnectionPool:
    def __init__(self, max_connections: int = 10):
        self.pool = asyncio.Queue(maxsize=max_connections)
        self.active_connections = {}
        
    async def get_connection(self, server_uri: str) -> MCPClient:
        """從連接池獲取連接"""
        if server_uri in self.active_connections:
            return self.active_connections[server_uri]
            
        if not self.pool.empty():
            client = await self.pool.get()
            await client.connect_to(server_uri)
            self.active_connections[server_uri] = client
            return client
            
        # 建立新連接
        client = MCPClient(server_uri)
        await client.connect()
        self.active_connections[server_uri] = client
        return client
```

### 快取機制

```python
class CachedMCPClient:
    def __init__(self, cache_ttl: int = 300):  # 5 分鐘 TTL
        self.cache = {}
        self.cache_ttl = cache_ttl
        
    async def list_tools_cached(self) -> List[Tool]:
        """帶快取的工具列表"""
        cache_key = "tools_list"
        
        if cache_key in self.cache:
            cached_time, tools = self.cache[cache_key]
            if time.time() - cached_time < self.cache_ttl:
                return tools
                
        # 快取過期，重新獲取
        tools = await self.client.list_tools()
        self.cache[cache_key] = (time.time(), tools)
        return tools
```

## 小結：架構設計的核心價值

MCP 的 Client-Server 架構不僅僅是技術實現，更是一個**智慧化化、標準化、可擴展**的生態系統設計：

1. **智慧化協調**：Host 提供高層次決策，Client 處理協議細節，Server 專注領域專業
2. **標準化通訊**：統一的 JSON-RPC 2.0 協議確保互操作性
3. **彈性部署**：支援多種傳輸方式，適應不同部署需求
4. **安全可控**：內建的認證、授權和加密機制
5. **高可用性**：故障轉移和負載均衡確保服務穩定

這個架構為台灣企業提供了一個既能保持技術領先，又能確保安全可控的 AI 整合方案。

---

**下一頁：** [2-2 三大核心機制：Tools、Resources、Prompts](/s/mcp-core-mechanisms)