Blog

Cách nhanh chóng xây dựng máy chủ MCP cho Claude Code

Audrey Lopez

Audrey Lopez

12 tháng 6 2025

Cách nhanh chóng xây dựng máy chủ MCP cho Claude Code

Giao thức Ngữ cảnh Mô hình (MCP) cách mạng hóa cách các trợ lý AI tương tác với các công cụ và nguồn dữ liệu bên ngoài. Hãy coi MCP như một cổng USB-C phổ quát cho các ứng dụng AI—nó cung cấp một cách chuẩn hóa để kết nối Claude Code với hầu hết mọi nguồn dữ liệu, API hoặc công cụ mà bạn có thể tưởng tượng. Hướng dẫn toàn diện này sẽ hướng dẫn bạn xây dựng máy chủ MCP của riêng mình từ đầu, cho phép Claude Code truy cập các chức năng tùy chỉnh mở rộng khả năng của nó vượt xa các tính năng tích hợp sẵn.

Cho dù bạn muốn tích hợp cơ sở dữ liệu, API, hệ thống tệp hay tạo các công cụ hoàn toàn tùy chỉnh, MCP cung cấp nền tảng cho khả năng mở rộng không giới hạn. Cuối hướng dẫn này, bạn sẽ có một máy chủ MCP hoạt động và hiểu cách mở rộng nó cho mọi trường hợp sử dụng.

💡
Bạn muốn một công cụ Kiểm thử API tuyệt vời tạo ra Tài liệu API đẹp mắt?

Bạn muốn một nền tảng tích hợp, Tất cả trong Một cho Nhóm Phát triển của bạn làm việc cùng nhau với năng suất tối đa?

Apidog đáp ứng mọi yêu cầu của bạn và thay thế Postman với mức giá phải chăng hơn nhiều!
button

Máy chủ MCP là gì và Tại sao Mọi người Đều Nói về Nó

Điều Gì Làm MCP Khác Biệt

MCP (Model Context Protocol) là một giao thức mở được phát triển bởi Anthropic cho phép các mô hình AI giao tiếp với các máy chủ bên ngoài thông qua một giao diện chuẩn hóa. Không giống như các tích hợp API truyền thống, nơi bạn mã hóa cứng các điểm cuối cụ thể, MCP cung cấp một cách có cấu trúc để các trợ lý AI khám phá, hiểu và sử dụng các công cụ bên ngoài một cách linh hoạt.

Điểm xuất sắc của MCP nằm ở khả năng khám phá của nó. Khi Claude Code kết nối với máy chủ MCP của bạn, nó sẽ tự động tìm hiểu những công cụ nào có sẵn, cách sử dụng chúng và những tham số nào chúng chấp nhận. Điều này có nghĩa là bạn có thể thêm chức năng mới mà không cần cập nhật Claude Code.

Phân Tích Sâu Kiến Trúc MCP

Giao thức tuân theo kiến trúc máy khách-máy chủ với các vai trò được xác định rõ ràng:

Giải Thích Luồng Giao Tiếp

Khi Claude Code cần sử dụng một công cụ bên ngoài, đây là những gì xảy ra:

  1. Giai đoạn Khám phá: Claude Code truy vấn máy chủ của bạn để tìm các công cụ có sẵn
  2. Xác thực Schema: Máy chủ của bạn phản hồi bằng các định nghĩa công cụ và schema đầu vào
  3. Chọn Công cụ: Claude Code chọn các công cụ phù hợp dựa trên yêu cầu của người dùng
  4. Giai đoạn Thực thi: Claude Code gửi các lệnh gọi công cụ với các tham số đã được xác thực
  5. Xử lý Kết quả: Máy chủ của bạn xử lý yêu cầu và trả về kết quả có cấu trúc

Luồng này đảm bảo an toàn kiểu dữ liệu, xử lý lỗi thích hợp và hành vi nhất quán trên tất cả các tích hợp MCP.

Điều Kiện Tiên Quyết và Thiết Lập Môi Trường

Phân Tích Yêu Cầu Hệ Thống

Trước khi xây dựng máy chủ MCP của bạn, bạn cần hiểu môi trường phát triển của mình và chọn đúng công cụ. Máy chủ MCP có thể được xây dựng bằng nhiều ngôn ngữ, nhưng Python và TypeScript là những ngôn ngữ được hỗ trợ phổ biến nhất với bộ công cụ phong phú.

Đối với Phát triển Python:

Đối với Phát triển TypeScript/JavaScript:

Các Phụ thuộc Cốt lõi:

Chuẩn Bị Môi Trường Từng Bước

1. Cài đặt Claude Code CLI

Claude Code CLI là công cụ chính của bạn để quản lý máy chủ MCP. Cài đặt nó toàn cục để đảm bảo truy cập từ bất kỳ thư mục nào:

# Cài đặt Claude Code toàn cục
npm install -g @anthropic-ai/claude-code

Tại sao cài đặt toàn cục quan trọng: Cài đặt toàn cục đảm bảo lệnh claude có sẵn trên toàn hệ thống, ngăn ngừa các vấn đề liên quan đến đường dẫn khi đăng ký máy chủ MCP từ các thư mục khác nhau.

2. Xác minh Cài đặt

Kiểm tra xem Claude Code đã được cài đặt và truy cập đúng cách chưa:

# Xác minh cài đặt và kiểm tra phiên bản
claude --version

# Kiểm tra các lệnh có sẵn
claude --help

3. Thiết lập Quyền Quan Trọng Lần Đầu

Bước này là hoàn toàn cần thiết và thường bị bỏ qua:

# Chạy thiết lập ban đầu với bỏ qua quyền
claude --dangerously-skip-permissions

Lệnh này làm gì:

Tại sao nó được yêu cầu: Nếu không có bước này, máy chủ MCP không thể thiết lập kết nối an toàn với Claude Code, dẫn đến lỗi xác thực và hết thời gian kết nối.

Cân nhắc bảo mật: Cờ --dangerously-skip-permissions an toàn cho môi trường phát triển nhưng bỏ qua các lời nhắc bảo mật thông thường. Trong môi trường sản xuất, hãy xem xét cẩn thận từng yêu cầu quyền.

Cấu Hình Quan Trọng: Hiểu Về Phạm Vi MCP

Tại Sao Phạm Vi Cấu Hình Quan Trọng

Một trong những cạm bẫy phổ biến nhất khi xây dựng máy chủ MCP là quản lý phạm vi cấu hình không đúng. Hiểu về phạm vi là rất quan trọng vì chúng quyết định nơi và khi nào máy chủ MCP của bạn có sẵn cho Claude Code. Nhiều nhà phát triển dành hàng giờ để gỡ lỗi các lỗi "không tìm thấy máy chủ" bắt nguồn từ cấu hình phạm vi sai.

Claude Code sử dụng hệ thống cấu hình phân cấp được thiết kế để cung cấp sự linh hoạt đồng thời duy trì bảo mật. Mỗi phạm vi phục vụ một mục đích cụ thể và có các trường hợp sử dụng khác nhau.

Giải Thích Hệ Thống Phân Cấp Phạm Vi Cấu Hình

1. Phạm Vi Dự Án (.mcp.json) - Ưu Tiên Cao Nhất

Vị trí: Thư mục gốc dự án trong tệp .mcp.json

Mục đích: Các máy chủ MCP dành riêng cho dự án chỉ nên khả dụng khi làm việc trong dự án cụ thể đó

Trường hợp sử dụng: Kết nối cơ sở dữ liệu dành riêng cho dự án, các công cụ linting dành riêng cho dự án hoặc các công cụ xây dựng tùy chỉnh

Khi nào phạm vi dự án phù hợp:

2. Phạm Vi Người Dùng (-scope user) - Cấu Hình Toàn Cục

Vị trí: Cấu hình thư mục nhà của người dùng

Mục đích: Các máy chủ MCP khả dụng toàn cục trên tất cả các dự án và thư mục

Trường hợp sử dụng: Các công cụ đa năng như API thời tiết, công cụ tính toán hoặc các tiện ích hệ thống

Tại sao phạm vi người dùng thường được ưu tiên:

3. Phạm Vi Cục Bộ (mặc định) - Dành Riêng Cho Thư Mục

Vị trí: Ngữ cảnh thư mục làm việc hiện tại

Mục đích: Thiết lập máy chủ MCP nhanh chóng, tạm thời

Hạn chế: Chỉ hoạt động khi bạn chạy Claude Code từ thư mục cụ thể đó

Các Lỗi Cấu Hình Phổ Biến

❌ Cách tiếp cận sai (Phạm vi cục bộ - chức năng hạn chế):

claude mcp add my-server python3 /path/to/server.py

Vấn đề: Máy chủ này chỉ hoạt động khi bạn đang ở trong thư mục chính xác nơi bạn đã đăng ký nó.

✅ Cách tiếp cận đúng (Phạm vi người dùng - truy cập toàn cầu):

claude mcp add --scope user my-server python3 /path/to/server.py

Lợi ích: Máy chủ này hoạt động từ bất kỳ thư mục nào trên hệ thống của bạn.

Lập Kế Hoạch Thư Mục Chiến Lược

Cấu Trúc Thư Mục Được Khuyến Nghị

Tạo một cấu trúc thư mục được tổ chức tốt để dễ dàng bảo trì lâu dài:

# Tạo vị trí lưu trữ vĩnh viễn
mkdir -p ~/.claude-mcp-servers/

# Tổ chức theo chức năng
mkdir -p ~/.claude-mcp-servers/apis/
mkdir -p ~/.claude-mcp-servers/utilities/
mkdir -p ~/.claude-mcp-servers/development/

Lợi Ích Của Cấu Trúc Tổ Chức

Dễ bảo trì: Dễ dàng tìm và cập nhật máy chủ sau này

Bảo mật: Phân tách rõ ràng giữa các loại công cụ khác nhau

Sao lưu: Đơn giản để sao lưu tất cả các máy chủ MCP bằng cách sao lưu một thư mục

Chia sẻ: Dễ dàng chia sẻ cấu hình máy chủ với các thành viên trong nhóm

Hướng Dẫn Khắc Phục Sự Cố Phạm Vi

Chẩn Đoán Các Vấn Đề Phạm Vi

Nếu máy chủ MCP của bạn không xuất hiện, hãy làm theo trình tự chẩn đoán này:

  1. Kiểm tra cấu hình phạm vi hiện tại:
claude mcp list
  1. Xác minh bạn không ở trong thư mục có phạm vi dự án xung đột:
ls .mcp.json
  1. Kiểm tra từ các thư mục khác nhau:
cd ~ && claude mcp list
cd /tmp && claude mcp list

Khắc Phục Các Vấn Đề Phạm Vi

Vấn đề: Máy chủ chỉ hoạt động trong một thư mục

Giải pháp: Xóa cấu hình cục bộ và thêm lại với phạm vi người dùng

# Xóa cấu hình cục bộ có vấn đề
claude mcp remove my-server

# Thêm lại với phạm vi người dùng toàn cầu
claude mcp add --scope user my-server python3 /path/to/server.py

Xây Dựng Máy Chủ MCP Đầu Tiên Của Bạn

Hiểu Về Quy Trình Phát Triển

Xây dựng máy chủ MCP bao gồm việc hiểu cả giao thức MCP và các yêu cầu cụ thể của trường hợp sử dụng của bạn. Chúng ta sẽ bắt đầu với một máy chủ "Hello World" cơ bản để hiểu các nguyên tắc cơ bản, sau đó xây dựng dựa trên nền tảng đó.

Quy trình phát triển tuân theo các giai đoạn sau:

  1. Thiết lập Cấu trúc Máy chủ: Tạo cấu trúc tệp cơ bản và điểm vào
  2. Triển khai Giao thức: Triển khai các phương thức MCP bắt buộc
  3. Định nghĩa Công cụ: Xác định những công cụ nào máy chủ của bạn cung cấp
  4. Đăng ký & Kiểm thử: Thêm máy chủ vào Claude Code và xác minh chức năng
  5. Nâng cao & Sản xuất: Thêm chức năng thực tế và xử lý lỗi

Bước 1: Nền Tảng và Cấu Trúc Dự Án

Tạo Môi Trường Phát Triển

Đầu tiên, thiết lập một môi trường phát triển phù hợp cho máy chủ MCP của bạn:

# Di chuyển đến thư mục máy chủ MCP của bạn
cd ~/.claude-mcp-servers/

# Tạo một dự án máy chủ mới
mkdir my-first-server
cd my-first-server

# Khởi tạo cấu trúc dự án
touch server.py
touch requirements.txt
touch .env

Tại Sao Cấu Trúc Này Quan Trọng

Phát triển có tổ chức: Giữ mỗi máy chủ trong thư mục riêng của nó ngăn ngừa xung đột và giúp bảo trì dễ dàng hơn.

Cách ly phụ thuộc: Mỗi máy chủ có thể có các yêu cầu riêng mà không ảnh hưởng đến các máy chủ khác.

Quản lý cấu hình: Tệp môi trường cho phép cấu hình an toàn mà không cần mã hóa cứng các giá trị.

Hiểu Các Yêu Cầu Máy Chủ MCP

Mọi máy chủ MCP phải triển khai ba phương thức JSON-RPC cốt lõi:

  1. initialize: Thiết lập kết nối và khai báo khả năng của máy chủ
  2. tools/list: Trả về các công cụ có sẵn và schema của chúng
  3. tools/call: Thực thi các công cụ cụ thể với các tham số được cung cấp

Bước 2: Triển khai Khung Máy Chủ Cốt Lõi

Tạo một tệp có tên server.py với mẫu máy chủ MCP nền tảng:

#!/usr/bin/env python3
"""
Máy chủ MCP tùy chỉnh để tích hợp Claude Code
"""

import json
import sys
import os
from typing import Dict, Any, Optional

# Đảm bảo đầu ra không đệm cho giao tiếp MCP thích hợp
sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 1)
sys.stderr = os.fdopen(sys.stderr.fileno(), 'w', 1)

def send_response(response: Dict[str, Any]):
    """Gửi phản hồi JSON-RPC tới Claude Code"""
    print(json.dumps(response), flush=True)

def handle_initialize(request_id: Any) -> Dict[str, Any]:
    """Xử lý bắt tay khởi tạo MCP"""
    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "protocolVersion": "2024-11-05",
            "capabilities": {
                "tools": {}
            },
            "serverInfo": {
                "name": "my-custom-server",
                "version": "1.0.0"
            }
        }
    }

def handle_tools_list(request_id: Any) -> Dict[str, Any]:
    """Liệt kê các công cụ có sẵn cho Claude Code"""
    tools = [
        {
            "name": "hello_world",
            "description": "Một công cụ minh họa đơn giản",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "name": {
                        "type": "string",
                        "description": "Tên để chào"
                    }
                },
                "required": ["name"]
            }
        }
    ]

    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "tools": tools
        }
    }

def handle_tool_call(request_id: Any, params: Dict[str, Any]) -> Dict[str, Any]:
    """Thực thi các lệnh gọi công cụ từ Claude Code"""
    tool_name = params.get("name")
    arguments = params.get("arguments", {})

    try:
        if tool_name == "hello_world":
            name = arguments.get("name", "World")
            result = f"Xin chào, {name}! Máy chủ MCP của bạn đang hoạt động hoàn hảo."
        else:
            raise ValueError(f"Công cụ không xác định: {tool_name}")

        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "content": [
                    {
                        "type": "text",
                        "text": result
                    }
                ]
            }
        }
    except Exception as e:
        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "error": {
                "code": -32603,
                "message": str(e)
            }
        }

def main():
    """Vòng lặp máy chủ chính xử lý giao tiếp JSON-RPC"""
    while True:
        try:
            line = sys.stdin.readline()
            if not line:
                break

            request = json.loads(line.strip())
            method = request.get("method")
            request_id = request.get("id")
            params = request.get("params", {})

            if method == "initialize":
                response = handle_initialize(request_id)
            elif method == "tools/list":
                response = handle_tools_list(request_id)
            elif method == "tools/call":
                response = handle_tool_call(request_id, params)
            else:
                response = {
                    "jsonrpc": "2.0",
                    "id": request_id,
                    "error": {
                        "code": -32601,
                        "message": f"Không tìm thấy phương thức: {method}"
                    }
                }

            send_response(response)

        except json.JSONDecodeError:
            continue
        except EOFError:
            break
        except Exception as e:
            if 'request_id' in locals():
                send_response({
                    "jsonrpc": "2.0",
                    "id": request_id,
                    "error": {
                        "code": -32603,
                        "message": f"Lỗi nội bộ: {str(e)}"
                    }
                })

if __name__ == "__main__":
    main()

Giải Thích Kiến Trúc Mã

Thiết lập Đầu vào/Đầu ra: Vài dòng đầu tiên cấu hình I/O không đệm, điều này rất quan trọng cho giao tiếp MCP. Đầu ra đệm có thể gây chậm trễ gửi tin nhắn làm hỏng giao thức.

Xử lý JSON-RPC: Vòng lặp chính đọc các yêu cầu JSON-RPC từ stdin và ghi phản hồi vào stdout. Điều này tuân theo đặc tả MCP cho giao tiếp máy chủ cục bộ.

Chiến lược Xử lý Lỗi: Mã triển khai nhiều lớp xử lý lỗi:

Tuân thủ Giao thức: Mỗi phản hồi bao gồm trường jsonrpc: "2.0" bắt buộc và ID yêu cầu để tương quan đúng.

Bước 3: Chuẩn Bị và Kiểm Thử Máy Chủ

Làm Cho Máy Chủ Có Thể Chạy Được

# Làm cho máy chủ có thể chạy được
chmod +x server.py

Tại sao quyền thực thi quan trọng: Máy chủ MCP được khởi chạy như một tiến trình con bởi Claude Code. Nếu không có quyền thực thi, việc khởi chạy sẽ thất bại với các lỗi quyền khó hiểu.

Kiểm Thử Giao Thức Thủ Công

Trước khi đăng ký với Claude Code, hãy kiểm tra việc triển khai giao thức của máy chủ:

# Kiểm tra bắt tay khởi tạo
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | python3 server.py

Những gì mong đợi: Bạn sẽ thấy một phản hồi JSON chứa phiên bản giao thức và khả năng. Nếu bạn thấy thông báo lỗi hoặc không có đầu ra, hãy kiểm tra cài đặt Python và cú pháp script của bạn.

Các Bước Xác Thực

Thực hiện các kiểm tra xác thực này trước khi tiếp tục:

  1. Kiểm tra cú pháp: python3 -m py_compile server.py
  2. Kiểm tra nhập: python3 -c "import json, sys, os"
  3. Kiểm tra thực thi: Xác minh kiểm tra giao thức thủ công hoạt động

Bước 4: Đăng Ký Với Claude Code

Thêm Máy Chủ Của Bạn

Đăng ký máy chủ của bạn bằng cách sử dụng phạm vi phù hợp và đường dẫn tuyệt đối:

# Đăng ký với phạm vi người dùng toàn cầu để truy cập phổ quát
claude mcp add --scope user my-first-server python3 ~/.claude-mcp-servers/my-first-server/server.py

Chi tiết quan trọng:

Xác Minh và Khắc Phục Sự Cố

# Xác minh đăng ký
claude mcp list

# Kiểm tra bất kỳ vấn đề kết nối nào
claude mcp get my-first-server

Các vấn đề đăng ký phổ biến:

Ví Dụ Nâng Cao: Tích Hợp API Thời Tiết

Vượt Ra Ngoài "Hello World"

Bây giờ bạn đã hiểu cấu trúc máy chủ MCP cơ bản, hãy xây dựng một máy chủ thực tế hơn để minh họa các mẫu tích hợp trong thế giới thực. Máy chủ API thời tiết này sẽ dạy bạn:

Lập Kế Hoạch Tích Hợp API Của Bạn

Trước khi viết mã, hãy xem xét các khía cạnh tích hợp này:

Chọn API: Chúng ta sẽ sử dụng OpenWeatherMap API vì sự đơn giản và tầng miễn phí của nó

Luồng dữ liệu: Yêu cầu người dùng → Xác thực tham số → Gọi API → Định dạng phản hồi → Phản hồi của Claude

Các kịch bản lỗi: Lỗi mạng, khóa API không hợp lệ, phản hồi sai định dạng, giới hạn tốc độ

Bảo mật: Khóa API được lưu trữ trong biến môi trường, làm sạch đầu vào

Chiến Lược Triển Khai

Hãy xây dựng máy chủ này từng bước, triển khai từng phần với xử lý lỗi đầy đủ:

#!/usr/bin/env python3
import json
import sys
import os
import requests
from typing import Dict, Any

# Cấu hình - sử dụng biến môi trường để bảo mật
WEATHER_API_KEY = os.environ.get("OPENWEATHER_API_KEY", "your-api-key-here")

def get_weather(city: str) -> str:
    """Lấy dữ liệu thời tiết hiện tại cho một thành phố được chỉ định"""
    try:
        url = "<http://api.openweathermap.org/data/2.5/weather>"
        params = {
            "q": city,
            "appid": WEATHER_API_KEY,
            "units": "metric"
        }
        response = requests.get(url, params=params, timeout=10)
        data = response.json()

        if response.status_code == 200:
            temp = data["main"]["temp"]
            desc = data["weather"][0]["description"]
            humidity = data["main"]["humidity"]
            return f"Thời tiết ở {city}: {temp}°C, {desc.title()}, Độ ẩm: {humidity}%"
        else:
            return f"Lỗi khi lấy thời tiết: {data.get('message', 'Lỗi không xác định')}"
    except requests.RequestException as e:
        return f"Lỗi mạng: {str(e)}"
    except Exception as e:
        return f"Lỗi xử lý dữ liệu thời tiết: {str(e)}"

def handle_tools_list(request_id: Any) -> Dict[str, Any]:
    """Danh sách công cụ nâng cao với chức năng thời tiết"""
    tools = [
        {
            "name": "get_weather",
            "description": "Nhận điều kiện thời tiết hiện tại cho bất kỳ thành phố nào trên toàn thế giới",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Tên thành phố (ví dụ: 'London', 'Tokyo', 'New York')"
                    }
                },
                "required": ["city"]
            }
        }
    ]

    return {
        "jsonrpc": "2.0",
        "id": request_id,
        "result": {
            "tools": tools
        }
    }

def handle_tool_call(request_id: Any, params: Dict[str, Any]) -> Dict[str, Any]:
    """Thực thi công cụ nâng cao với chức năng thời tiết"""
    tool_name = params.get("name")
    arguments = params.get("arguments", {})

    try:
        if tool_name == "get_weather":
            city = arguments.get("city")
            if not city:
                raise ValueError("Tên thành phố là bắt buộc")
            result = get_weather(city)
        else:
            raise ValueError(f"Công cụ không xác định: {tool_name}")

        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "content": [
                    {
                        "type": "text",
                        "text": result
                    }
                ]
            }
        }
    except Exception as e:
        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "error": {
                "code": -32603,
                "message": str(e)
            }
        }

# Bao gồm hàm main() và các trình xử lý khác từ ví dụ cơ bản

Giải Thích Các Tính Năng Nâng Cao

Bảo mật Biến Môi Trường: Khóa API được tải từ biến môi trường, không bao giờ được mã hóa cứng. Điều này ngăn ngừa việc vô tình lộ thông tin trong kiểm soát phiên bản.

Xử lý Lỗi Mạnh mẽ: Hàm get_weather() xử lý nhiều kịch bản lỗi:

Schema Công cụ Nâng cao: Schema công cụ thời tiết bao gồm các mô tả và ví dụ chi tiết, giúp Claude Code hiểu cách sử dụng công cụ một cách hiệu quả.

Bước 5: Quản Lý Phụ Thuộc và Cấu Hình Chuyên Nghiệp

Tạo Tệp Yêu Cầu Phù Hợp

requests>=2.28.0
python-dotenv>=1.0.0

Chiến lược ghim phiên bản: Sử dụng yêu cầu phiên bản tối thiểu (>=) đảm bảo khả năng tương thích trong khi cho phép cập nhật bảo mật. Đối với máy chủ sản xuất, hãy cân nhắc ghim phiên bản chính xác.

Cấu Hình Môi Trường An Toàn

Tạo tệp .env để quản lý cấu hình:

# Cấu hình API thời tiết
OPENWEATHER_API_KEY=your_actual_api_key_here

# Cấu hình máy chủ
MCP_LOG_LEVEL=INFO
MCP_DEBUG=false

# Tùy chọn: Giới hạn tốc độ
MCP_MAX_REQUESTS_PER_MINUTE=60

Các thực hành tốt nhất về bảo mật:

Cài Đặt và Cách Ly Phụ Thuộc

# Tạo môi trường ảo để cách ly
python3 -m venv mcp-env
source mcp-env/bin/activate  # Trên Windows: mcp-env\\\\Scripts\\\\activate

# Cài đặt phụ thuộc
pip install -r requirements.txt

# Xác minh cài đặt
python3 -c "import requests; print('Dependencies installed successfully')"

Tại sao môi trường ảo quan trọng: Cách ly ngăn ngừa xung đột phụ thuộc giữa các máy chủ MCP khác nhau và cài đặt Python hệ thống của bạn.

Kiểm Thử và Gỡ Lỗi Máy Chủ MCP Của Bạn

Chiến Lược Kiểm Thử Toàn Diện

Kiểm thử máy chủ MCP đòi hỏi một cách tiếp cận đa lớp vì bạn đang xử lý cả việc tuân thủ giao thức và tính đúng đắn về chức năng. Một chiến lược kiểm thử có hệ thống ngăn ngừa các vấn đề xảy ra trong sản xuất và giúp việc gỡ lỗi dễ dàng hơn nhiều.

Kim Tự Tháp Kiểm Thử Cho Máy Chủ MCP

  1. Kiểm thử Đơn vị: Kiểm thử chức năng riêng lẻ
  2. Kiểm thử Giao thức: Xác minh tuân thủ JSON-RPC
  3. Kiểm thử Tích hợp: Kiểm thử tương tác với Claude Code
  4. Kiểm thử Đầu cuối: Xác thực toàn bộ luồng công việc

Lớp 1: Kiểm Thử Giao Thức Thủ Công

Kiểm Thử Các Phương Thức MCP Cốt Lõi

Trước bất kỳ tích hợp nào, hãy xác minh máy chủ của bạn triển khai giao thức MCP một cách chính xác:

# Kiểm tra bắt tay khởi tạo
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' | python3 server.py

Cấu trúc phản hồi mong đợi:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "protocolVersion": "2024-11-05",
    "capabilities": {"tools": {}},
    "serverInfo": {"name": "your-server", "version": "1.0.0"}
  }
}

Kiểm Thử Khám Phá Công Cụ

# Kiểm tra điểm cuối danh sách công cụ
echo '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' | python3 server.py

Danh sách kiểm tra xác thực:

Kiểm Thử Thực Thi Công Cụ

# Kiểm tra chức năng công cụ thực tế
echo '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_weather","arguments":{"city":"London"}}}' | python3 server.py

Những gì cần xác minh:

Lớp 2: Khung Kiểm Thử Tự Động

Tạo Các Script Kiểm Thử

Tạo một tệp test_server.py để kiểm thử tự động:

#!/usr/bin/env python3
import json
import subprocess
import sys

def test_mcp_method(method, params=None):
    """Kiểm thử một phương thức MCP cụ thể"""
    request = {
        "jsonrpc": "2.0",
        "id": 1,
        "method": method,
        "params": params or {}
    }

    try:
        result = subprocess.run(
            [sys.executable, "server.py"],
            input=json.dumps(request),
            capture_output=True,
            text=True,
            timeout=10
        )
        return json.loads(result.stdout.strip())
    except Exception as e:
        return {"error": str(e)}

# Bộ kiểm thử
tests = [
    ("initialize", None),
    ("tools/list", None),
    ("tools/call", {"name": "hello_world", "arguments": {"name": "Test"}})
]

for method, params in tests:
    response = test_mcp_method(method, params)
    print(f"Kiểm thử {method}: {'✓ PASS' if 'result' in response else '✗ FAIL'}")

Lớp 3: Kiểm Thử Tích Hợp Với Claude Code

Đăng Ký và Xác Minh Máy Chủ

# Đăng ký máy chủ của bạn
claude mcp add --scope user test-server python3 /full/path/to/server.py

# Xác minh đăng ký
claude mcp list | grep test-server

# Kiểm tra trạng thái máy chủ
claude mcp get test-server

Kiểm Thử Tích Hợp Trực Tiếp

# Khởi động Claude Code ở chế độ kiểm thử
claude

# Trong Claude Code, kiểm thử khám phá công cụ
/mcp

# Kiểm thử thực thi công cụ
mcp__test-server__hello_world name:"Integration Test"

Mẫu đặt tên công cụ: Claude Code tiền tố các công cụ bằng mcp__<tên-máy-chủ>__<tên-công-cụ> để tránh xung đột tên.

Các Kỹ Thuật Gỡ Lỗi Nâng Cao

Bật Ghi Nhật Ký Gỡ Lỗi

Thêm ghi nhật ký toàn diện vào máy chủ của bạn:

import logging
import sys

# Cấu hình ghi nhật ký vào stderr (sẽ không can thiệp vào JSON-RPC)
logging.basicConfig(
    level=logging.DEBUG,
    stream=sys.stderr,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

logger = logging.getLogger(__name__)

def handle_tool_call(request_id, params):
    logger.debug(f"Đã nhận lệnh gọi công cụ: {params}")
    # ... logic công cụ của bạn
    logger.debug(f"Thực thi công cụ đã hoàn thành thành công")

Phân Tích Nhật Ký Máy Chủ MCP

Claude Code duy trì nhật ký cho mỗi máy chủ MCP:

# Xem nhật ký gần đây (macOS)
tail -f ~/Library/Logs/Claude/mcp-server-*.log

# Xem nhật ký gần đây (Linux)
tail -f ~/.config/claude/logs/mcp-server-*.log

# Tìm kiếm lỗi
grep -i error ~/Library/Logs/Claude/mcp-server-*.log

Các Mẫu Gỡ Lỗi Phổ Biến

Vấn đề: Máy chủ khởi động nhưng công cụ không xuất hiện

Chẩn đoán: Kiểm tra định dạng phản hồi tools/list

Giải pháp: Xác thực tuân thủ JSON schema

Vấn đề: Lệnh gọi công cụ thất bại âm thầm

Chẩn đoán: Kiểm tra xử lý lỗi trong tools/call

Giải pháp: Thêm xử lý ngoại lệ toàn diện

Vấn đề: Kết nối máy chủ bị ngắt

Chẩn đoán: Kiểm tra I/O không đệm và xử lý ngoại lệ thích hợp

Giải pháp: Xác minh cấu hình sys.stdout và xử lý lỗi vòng lặp chính

Kiểm Thử Hiệu Năng và Độ Tin Cậy

Kiểm Thử Tải Máy Chủ Của Bạn

# Kiểm thử nhiều yêu cầu nhanh
for i in {1..10}; do
  echo '{"jsonrpc":"2.0","id":'$i',"method":"tools/list","params":{}}' | python3 server.py &
done
wait

Giám Sát Bộ Nhớ và Tài Nguyên

# Giám sát sử dụng tài nguyên máy chủ
python3 -m memory_profiler server.py

# Kiểm tra rò rỉ bộ nhớ trong quá trình hoạt động kéo dài
python3 -m tracemalloc server.py

Khắc Phục Các Vấn Đề Phổ Biến

Các Vấn Đề Cấp Giao Thức

  1. Phản hồi JSON không hợp lệ: Sử dụng json.loads() để xác thực đầu ra
  2. Thiếu các trường bắt buộc: Kiểm tra tuân thủ đặc tả MCP
  3. Mã lỗi không chính xác: Sử dụng mã lỗi JSON-RPC tiêu chuẩn

Các Vấn Đề Tích Hợp

  1. Máy chủ không xuất hiện: Xác minh quyền tệp và đường dẫn Python
  2. Công cụ không thể truy cập: Kiểm tra cấu hình phạm vi và đăng ký
  3. Lỗi xác thực: Đảm bảo khởi tạo MCP đúng cách

Các Thực Hành Tốt Nhất và Cân Nhắc Bảo Mật

Xử Lý Lỗi Sẵn Sàng Cho Sản Xuất

Triển Khai Xác Thực Mạnh Mẽ

Xử lý lỗi trong máy chủ MCP phải toàn diện vì các lỗi có thể làm hỏng toàn bộ chuỗi giao tiếp với Claude Code. Triển khai xác thực ở nhiều cấp độ:

def validate_arguments(arguments: Dict[str, Any], required: List[str]):
    """Xác thực các đối số bắt buộc có mặt"""
    missing = [field for field in required if field not in arguments]
    if missing:
        raise ValueError(f"Thiếu các trường bắt buộc: {', '.join(missing)}")

def handle_tool_call(request_id: Any, params: Dict[str, Any]) -> Dict[str, Any]:
    """Thực thi công cụ với xác thực phù hợp"""
    try:
        tool_name = params.get("name")
        arguments = params.get("arguments", {})

        # Xác thực trước khi xử lý
        if tool_name == "get_weather":
            validate_arguments(arguments, ["city"])

        # Xử lý logic công cụ ở đây

    except ValueError as ve:
        return create_error_response(request_id, -32602, str(ve))
    except Exception as e:
        return create_error_response(request_id, -32603, f"Lỗi nội bộ: {str(e)}")

Tiêu Chuẩn Phản Hồi Lỗi

Tuân theo quy ước mã lỗi JSON-RPC 2.0:

Khung Bảo Mật Toàn Diện

1. Quản Lý Bí Mật

Không bao giờ mã hóa cứng thông tin nhạy cảm. Sử dụng cách tiếp cận phân lớp cho cấu hình:

import os
from pathlib import Path

def load_config():
    """Tải cấu hình với hệ thống phân cấp dự phòng"""
    # 1. Biến môi trường (ưu tiên cao nhất)
    api_key = os.environ.get("API_KEY")

    # 2. Tệp .env cục bộ
    if not api_key:
        env_path = Path(".env")
        if env_path.exists():
            # Tải từ tệp .env
            pass

    # 3. Keyring hệ thống (sản xuất)
    if not api_key:
        try:
            import keyring
            api_key = keyring.get_password("mcp-server", "api_key")
        except ImportError:
            pass

    if not api_key:
        raise ValueError("Không tìm thấy khóa API trong bất kỳ nguồn cấu hình nào")

    return {"api_key": api_key}

2. Làm Sạch và Xác Thực Đầu Vào

Triển khai xác thực đầu vào nghiêm ngặt để ngăn chặn các cuộc tấn công injection:

import re
from typing import Any, Dict

def sanitize_string_input(value: str, max_length: int = 100) -> str:
    """Làm sạch đầu vào chuỗi"""
    if not isinstance(value, str):
        raise ValueError("Đầu vào chuỗi mong đợi")

    # Xóa các ký tự có khả năng nguy hiểm
    sanitized = re.sub(r'[<>"\\\\']', '', value)

    # Giới hạn độ dài để ngăn chặn DoS
    if len(sanitized) > max_length:
        raise ValueError(f"Đầu vào quá dài (tối đa {max_length} ký tự)")

    return sanitized.strip()

def validate_city_name(city: str) -> str:
    """Xác thực đầu vào tên thành phố"""
    sanitized = sanitize_string_input(city, 50)

    # Chỉ cho phép chữ cái, khoảng trắng và dấu câu phổ biến
    if not re.match(r'^[a-zA-Z\\\\s\\\\-\\\\.]+$', sanitized):
        raise ValueError("Định dạng tên thành phố không hợp lệ")

    return sanitized

3. Giới Hạn Tốc Độ và Bảo Vệ Tài Nguyên

Triển khai giới hạn tốc độ để ngăn chặn lạm dụng:

import time
from collections import defaultdict
from threading import Lock

class RateLimiter:
    def __init__(self, max_requests: int = 60, window_seconds: int = 60):
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.requests = defaultdict(list)
        self.lock = Lock()

    def allow_request(self, client_id: str = "default") -> bool:
        """Kiểm tra xem yêu cầu có được phép theo giới hạn tốc độ không"""
        now = time.time()

        with self.lock:
            # Làm sạch các yêu cầu cũ
            self.requests[client_id] = [
                req_time for req_time in self.requests[client_id]
                if now - req_time < self.window_seconds
            ]

            # Kiểm tra giới hạn
            if len(self.requests[client_id]) >= self.max_requests:
                return False

            # Ghi lại yêu cầu này
            self.requests[client_id].append(now)
            return True

# Thể hiện giới hạn tốc độ toàn cầu
rate_limiter = RateLimiter()

Ghi Nhật Ký và Giám Sát Nâng Cao

Triển Khai Ghi Nhật Ký Có Cấu Trúc

Sử dụng ghi nhật ký có cấu trúc để gỡ lỗi và giám sát tốt hơn:

import logging
import json
import sys
from datetime import datetime

class MCPFormatter(logging.Formatter):
    """Trình định dạng tùy chỉnh cho nhật ký máy chủ MCP"""

    def format(self, record):
        log_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "level": record.levelname,
            "message": record.getMessage(),
            "module": record.module,
            "function": record.funcName,
        }

        # Thêm ngữ cảnh bổ sung nếu có
        if hasattr(record, 'tool_name'):
            log_entry["tool_name"] = record.tool_name
        if hasattr(record, 'request_id'):
            log_entry["request_id"] = record.request_id

        return json.dumps(log_entry)

# Cấu hình ghi nhật ký có cấu trúc
logger = logging.getLogger(__name__)
handler = logging.StreamHandler(sys.stderr)
handler.setFormatter(MCPFormatter())
logger.addHandler(handler)
logger.setLevel(logging.INFO)

Giám Sát Hiệu Năng

Theo dõi các chỉ số hiệu năng máy chủ:

import time
import statistics
from collections import deque

class PerformanceMonitor:
    def __init__(self, max_samples: int = 1000):
        self.response_times = deque(maxlen=max_samples)
        self.error_count = 0
        self.request_count = 0

    def record_request(self, duration: float, success: bool):
        """Ghi lại các chỉ số yêu cầu"""
        self.request_count += 1
        self.response_times.append(duration)

        if not success:
            self.error_count += 1

    def get_stats(self) -> Dict[str, Any]:
        """Lấy thống kê hiệu năng hiện tại"""
        if not self.response_times:
            return {"no_data": True}

        return {
            "total_requests": self.request_count,
            "error_rate": self.error_count / self.request_count,
            "avg_response_time": statistics.mean(self.response_times),
            "p95_response_time": statistics.quantiles(self.response_times, n=20)[18],
            "p99_response_time": statistics.quantiles(self.response_times, n=100)[98]
        }

# Giám sát hiệu năng toàn cầu
perf_monitor = PerformanceMonitor()

Các Chiến Lược Triển Khai và Bảo Trì

Quản Lý Phiên Bản

Triển khai phiên bản phù hợp cho máy chủ MCP của bạn:

__version__ = "1.2.3"
__mcp_version__ = "2024-11-05"

def get_server_info():
    """Trả về thông tin máy chủ để khởi tạo MCP"""
    return {
        "name": "my-production-server",
        "version": __version__,
        "mcp_protocol_version": __mcp_version__,
        "capabilities": ["tools", "resources"],  # Khai báo những gì bạn hỗ trợ
    }

Triển Khai Kiểm Tra Trạng Thái

Thêm khả năng kiểm tra trạng thái để giám sát:

def handle_health_check(request_id: Any) -> Dict[str, Any]:
    """Điểm cuối kiểm tra trạng thái để giám sát"""
    try:
        # Kiểm tra chức năng cốt lõi
        test_db_connection()  # Ví dụ kiểm tra trạng thái
        test_external_apis()  # Ví dụ kiểm tra trạng thái

        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "status": "healthy",
                "timestamp": datetime.utcnow().isoformat(),
                "version": __version__,
                "uptime_seconds": time.time() - start_time,
                "performance": perf_monitor.get_stats()
            }
        }
    except Exception as e:
        return {
            "jsonrpc": "2.0",
            "id": request_id,
            "result": {
                "status": "unhealthy",
                "error": str(e),
                "timestamp": datetime.utcnow().isoformat()
            }
        }

Xử Lý Tắt Máy Nhẹ Nhàng

Triển khai dọn dẹp phù hợp khi máy chủ tắt:

import signal
import sys

class MCPServer:
    def __init__(self):
        self.running = True
        self.active_requests = set()

        # Đăng ký trình xử lý tín hiệu
        signal.signal(signal.SIGINT, self.shutdown_handler)
        signal.signal(signal.SIGTERM, self.shutdown_handler)

    def shutdown_handler(self, signum, frame):
        """Xử lý tắt máy nhẹ nhàng"""
        logger.info(f"Đã nhận tín hiệu {signum}, đang bắt đầu tắt máy nhẹ nhàng")
        self.running = False

        # Chờ các yêu cầu đang hoạt động hoàn thành
        timeout = 30  # giây
        start_time = time.time()

        while self.active_requests and (time.time() - start_time) < timeout:
            time.sleep(0.1)

        logger.info("Tắt máy hoàn thành")
        sys.exit(0)

Các Trường Hợp Sử Dụng Thực Tế và Ứng Dụng Nâng Cao

Các Mẫu Tích Hợp Doanh Nghiệp

Máy chủ MCP vượt trội trong môi trường doanh nghiệp nơi Claude Code cần tích hợp với các hệ thống kinh doanh hiện có. Dưới đây là các mẫu tích hợp đã được chứng minh:

Máy Chủ Tích Hợp Cơ Sở Dữ Liệu

Tự Động Hóa Luồng Công Việc Phát Triển

Giám Sát và Vận Hành Hệ Thống

Các Mẫu Kiến Trúc Nâng Cao

Điều Phối Nhiều Máy Chủ

Đối với các luồng công việc phức tạp, hãy thiết kế các máy chủ MCP phối hợp với nhau:

# Mẫu điều phối máy chủ
def coordinate_workflow(workflow_id: str, steps: List[Dict]) -> Dict:
    """Điều phối luồng công việc nhiều bước trên các máy chủ"""
    results = {}

    for step in steps:
        server_name = step["server"]
        tool_name = step["tool"]
        params = step["params"]

        # Gọi máy chủ MCP khác thông qua Claude Code
        result = call_mcp_tool(server_name, tool_name, params)
        results[step["id"]] = result

        # Xử lý phụ thuộc giữa các bước
        if step.get("depends_on"):
            inject_dependencies(params, results, step["depends_on"])

    return {"workflow_id": workflow_id, "results": results}

Bộ Nhớ Đệm và Tối Ưu Hóa Hiệu Năng

Triển khai bộ nhớ đệm thông minh cho dữ liệu được yêu cầu thường xuyên:

import hashlib
import pickle
from datetime import datetime, timedelta

class IntelligentCache:
    def __init__(self, default_ttl: int = 3600):
        self.cache = {}
        self.default_ttl = default_ttl

    def get_cache_key(self, tool_name: str, params: Dict) -> str:
        """Tạo khóa bộ nhớ đệm nhất quán"""
        key_data = f"{tool_name}:{json.dumps(params, sort_keys=True)}"
        return hashlib.md5(key_data.encode()).hexdigest()

    def get(self, tool_name: str, params: Dict) -> Optional[Any]:
        """Lấy kết quả được lưu trong bộ nhớ đệm nếu hợp lệ"""
        key = self.get_cache_key(tool_name, params)

        if key in self.cache:
            data, expiry = self.cache[key]
            if datetime.now() < expiry:
                return data
            else:
                del self.cache[key]

        return None

    def set(self, tool_name: str, params: Dict, result: Any, ttl: Optional[int] = None):
        """Lưu kết quả vào bộ nhớ đệm với TTL"""
        key = self.get_cache_key(tool_name, params)
        expiry = datetime.now() + timedelta(seconds=ttl or self.default_ttl)
        self.cache[key] = (result, expiry)

Các Chiến Lược Triển Khai Sản Xuất

Triển Khai Dạng Container

Đóng gói máy chủ MCP của bạn dưới dạng container Docker để triển khai nhất quán:

FROM python:3.11-slim

WORKDIR /app

# Cài đặt các phụ thuộc hệ thống
RUN apt-get update && apt-get install -y \\\\
    curl \\\\
    && rm -rf /var/lib/apt/lists/*

# Sao chép và cài đặt các phụ thuộc Python
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Sao chép mã ứng dụng
COPY server.py .
COPY config/ ./config/

# Tạo người dùng không phải root
RUN useradd -m -s /bin/bash mcpuser
USER mcpuser

# Kiểm tra trạng thái
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \\\\
    CMD python3 -c "import requests; requests.get('<http://localhost:8080/health>')"

CMD ["python3", "server.py"]

Triển Khai Kubernetes

Triển khai máy chủ MCP trong Kubernetes để có khả năng mở rộng và độ tin cậy:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-weather-server
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mcp-weather-server
  template:
    metadata:
      labels:
        app: mcp-weather-server
    spec:
      containers:
      - name: mcp-server
        image: your-registry/mcp-weather-server:latest
        ports:
        - containerPort: 8080
        env:
        - name: OPENWEATHER_API_KEY
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: openweather-api-key
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10

Cân Nhắc Về Khả Năng Mở Rộng và Hiệu Năng

Các Mẫu Mở Rộng Ngang

Thiết kế máy chủ MCP của bạn để hỗ trợ mở rộng ngang:

  1. Thiết kế Phi trạng thái: Giữ máy chủ phi trạng thái để dễ dàng nhân rộng
  2. Cân bằng Tải: Phân phối yêu cầu trên nhiều phiên bản máy chủ
  3. Kết nối Cơ sở dữ liệu: Sử dụng nhóm kết nối cho các máy chủ hỗ trợ cơ sở dữ liệu
  4. Các Chiến lược Bộ Nhớ Đệm: Triển khai Redis hoặc Memcached cho bộ nhớ đệm chia sẻ

Các Kỹ Thuật Tối Ưu Hóa Hiệu Năng

import asyncio
import aiohttp
from concurrent.futures import ThreadPoolExecutor

class HighPerformanceMCPServer:
    def __init__(self):
        self.executor = ThreadPoolExecutor(max_workers=10)
        self.session = None

    async def async_tool_call(self, tool_name: str, params: Dict) -> Dict:
        """Xử lý các lệnh gọi công cụ bất đồng bộ"""
        if not self.session:
            self.session = aiohttp.ClientSession()

        # Sử dụng các hoạt động bất đồng bộ cho các tác vụ giới hạn I/O
        if tool_name == "web_search":
            return await self.async_web_search(params)
        elif tool_name == "database_query":
            return await self.async_database_query(params)
        else:
            # Sử dụng nhóm luồng cho các tác vụ giới hạn CPU
            loop = asyncio.get_event_loop()
            return await loop.run_in_executor(
                self.executor,
                self.sync_tool_call,
                tool_name,
                params
            )

Kết Luận và Các Bước Tiếp Theo

Làm Chủ Phát Triển MCP

Xây dựng máy chủ MCP cho Claude Code thể hiện một sự thay đổi mô hình trong phát triển ứng dụng AI. Không giống như các tích hợp API truyền thống yêu cầu kết nối mã hóa cứng, MCP cung cấp một giao diện động, có thể khám phá làm cho các trợ lý AI thực sự có thể mở rộng.

Trong suốt hướng dẫn toàn diện này, bạn đã học được:

Các Kỹ Năng Nền Tảng:

Sẵn Sàng Cho Sản Xuất:

Các Khả Năng Nâng Cao:

Cách Tiếp Cận Phát Triển Chiến Lược

Giai đoạn 1: Xây Dựng Nền Tảng (Tuần 1-2)

Bắt đầu với các máy chủ đơn giản, có mục đích duy nhất để hiểu giao thức:

Giai đoạn 2: Mở Rộng Tích Hợp (Tuần 3-4)

Xây dựng các máy chủ phức tạp hơn tích hợp với các hệ thống hiện có:

Giai đoạn 3: Triển Khai Doanh Nghiệp (Tháng 2+)

Triển khai các máy chủ sẵn sàng cho sản xuất với hỗ trợ vận hành đầy đủ:

Các Chiến Lược Thành Công Dài Hạn

Tham Gia Cộng Đồng

Cải Tiến Liên Tục

Cơ Hội Đổi Mới

Tương Lai Của Phát Triển MCP

Giao thức Ngữ cảnh Mô hình là nền tảng cho một hệ sinh thái mới của các ứng dụng tích hợp AI. Khi bạn xây dựng máy chủ MCP, bạn không chỉ tạo công cụ cho Claude Code—bạn đang xây dựng các thành phần có thể tái sử dụng sẽ hoạt động trên hệ sinh thái ngày càng mở rộng của các trợ lý AI tương thích với MCP.

Khoản đầu tư của bạn vào phát triển MCP mang lại lợi ích thông qua:

Nhắc Nhở Thành Công Quan Trọng

Khi bạn bắt tay vào hành trình phát triển MCP, hãy nhớ những nguyên tắc thiết yếu này:

  1. Làm chủ phạm vi cấu hình: Luôn sử dụng -scope user cho máy chủ phát triển trừ khi bạn cần giới hạn cấp dự án cụ thể
  2. Bảo mật là trên hết: Không bao giờ mã hóa cứng bí mật, luôn xác thực đầu vào, triển khai giới hạn tốc độ
  3. Hoàn thiện xử lý lỗi: Dự đoán và xử lý tất cả các chế độ lỗi một cách nhẹ nhàng
  4. Kiểm thử kỹ lưỡng: Kiểm thử tuân thủ giao thức, chức năng và tích hợp
  5. Chất lượng tài liệu: Tài liệu hóa máy chủ của bạn để hợp tác nhóm và bảo trì

Tìm Kiếm Trợ Giúp và Tài Nguyên

Khi bạn gặp khó khăn:

Bắt đầu xây dựng ngay hôm nay, lặp lại nhanh chóng và tham gia cộng đồng các nhà phát triển đang mở rộng khả năng AI thông qua Giao thức Ngữ cảnh Mô hình. Máy chủ MCP tùy chỉnh của bạn sẽ mở khóa những khả năng mới cho các luồng công việc được hỗ trợ bởi AI mà chúng ta mới chỉ bắt đầu tưởng tượng.

Hãy nhớ: mọi tích hợp phức tạp đều bắt đầu bằng một máy chủ "Hello World" đơn giản. Bắt đầu với những điều cơ bản, làm chủ các nguyên tắc nền tảng và dần dần xây dựng các công cụ tích hợp AI sẽ biến đổi cách bạn làm việc.

💡
Bạn muốn một công cụ Kiểm thử API tuyệt vời tạo ra Tài liệu API đẹp mắt?

Bạn muốn một nền tảng tích hợp, Tất cả trong Một cho Nhóm Phát triển của bạn làm việc cùng nhau với năng suất tối đa?

Apidog đáp ứng mọi yêu cầu của bạn và thay thế Postman với mức giá phải chăng hơn nhiều!
button

Thực hành thiết kế API trong Apidog

Khám phá cách dễ dàng hơn để xây dựng và sử dụng API

Đăng ký miễn phíTải xuống