Blog

Các máy chủ MCP là gì? Giải thích rõ ràng.

中村 拓也

中村 拓也

20 tháng 6 2025

Các máy chủ MCP là gì? Giải thích rõ ràng.

Giao thức Ngữ cảnh Mô hình (MCP), được giới thiệu bởi Anthropic vào ngày 26 tháng 11 năm 2024, là một tiêu chuẩn mở nhằm thu hẹp khoảng cách giữa các mô hình AI và các nguồn dữ liệu bên ngoài. Giao thức này giải quyết một thách thức quan trọng: ngay cả những Mô hình Ngôn ngữ Lớn (LLMs) tiên tiến, mặc dù mạnh mẽ trong việc tạo ra văn bản, thường bị cô lập với dữ liệu và công cụ theo thời gian thực, hạn chế tiện ích thực tiễn của chúng. Các Máy chủ MCP, với vai trò là thành phần không thể thiếu, cho phép các trợ lý AI như Claude truy cập vào các tệp, cơ sở dữ liệu, API và hơn thế nữa, nâng cao khả năng cung cấp các phản hồi liên quan và có thể hành động.

Ý nghĩa của MCP nằm ở khả năng tiêu chuẩn hóa các tích hợp, giảm thiểu sự phân mảnh đã ảnh hưởng đến phát triển AI. Bằng cách cung cấp một giao thức toàn cầu, nó nhằm giúp các mô hình tiên phong tạo ra các phản hồi tốt hơn và có liên quan hơn bằng cách phá vỡ các silo thông tin và rào cản của hệ thống kế thừa.

Tính đến ngày 25 tháng 3 năm 2025, hệ sinh thái đang phát triển nhanh chóng, với sự đóng góp từ cộng đồng và các doanh nghiệp áp dụng, như những người dùng sớm như Block và Apollo tích hợp MCP vào hệ thống của họ.

💡
Cần tìm công cụ thay thế Postman tốt nhất tích hợp tất cả quy trình kiểm thử API của bạn vào một nơi?
Tải xuống Apidog miễn phí hôm nay và khám phá cách nó có thể biến đổi quy trình của bạn!
button

Máy chủ MCP là gì?

Các máy chủ MCP, là một phần của Giao thức Ngữ cảnh Mô hình (MCP), là các chương trình đặc biệt giúp các mô hình AI, như những mô hình của Anthropic, kết nối và sử dụng dữ liệu và công cụ bên ngoài. Được giới thiệu vào tháng 11 năm 2024, chúng cho phép AI làm nhiều hơn chỉ là tạo ra văn bản bằng cách truy cập các thứ như tệp trên máy tính của bạn, cơ sở dữ liệu hoặc thậm chí các dịch vụ như GitHub, tất cả đều theo cách an toàn và tiêu chuẩn hóa.

Hãy coi các máy chủ MCP như những cây cầu cho phép AI tương tác với thế giới bên ngoài, tương tự như cách các cổng USB cho phép bạn cắm các thiết bị khác nhau vào máy tính của bạn. Ví dụ, nếu bạn yêu cầu AI tóm tắt một tài liệu, nó có thể truy xuất tệp trực tiếp từ hệ thống của bạn. Hoặc, nếu bạn cần tạo một vấn đề GitHub, AI cũng có thể làm điều đó, nhờ vào một máy chủ MCP. Chúng có thể cung cấp dữ liệu (như tệp), công cụ (như các cuộc gọi API), hoặc các trình nhắc (hướng dẫn cho sự tương tác), làm cho AI hữu ích hơn cho các nhiệm vụ như lập trình, nghiên cứu, hoặc quản lý dự án.

Nguồn: Blog của Norah Sakal

Một chi tiết bất ngờ là cộng đồng đã lớn nhanh như thế nào, với hơn 250 máy chủ đã có sẵn, bao gồm cả các tích hợp chính thức và sự đóng góp từ cộng đồng, cho thấy một hệ sinh thái năng động đang phát triển nhanh chóng.

Máy chủ MCP hoạt động như thế nào (và chúng khác với APIs như thế nào)

MCP hoạt động dựa trên mô hình client-server, như được nêu trong tài liệu. Kiến trúc bao gồm:

Nguồn: Tahir

Giao thức dựa trên JSON-RPC 2.0, đảm bảo các kết nối có trạng thái và thỏa thuận khả năng giữa các khách hàng và máy chủ. Nền tảng kỹ thuật này cho phép giao tiếp mạnh mẽ và an toàn, với các tính năng như theo dõi tiến độ, hủy bỏ, và báo cáo lỗi tăng cường độ tin cậy.

Vậy, MCP thực sự có thể làm gì?

Các máy chủ MCP được thiết kế để linh hoạt, phục vụ một loạt nhu cầu. Chúng có thể chạy cục bộ hoặc từ xa, tùy thuộc vào việc triển khai, và được xây dựng với các nguyên tắc bảo mật đầu tiên. Mỗi máy chủ kiểm soát tài nguyên của riêng mình, duy trì ranh giới hệ thống rõ ràng để ngăn chặn quyền truy cập trái phép.

Việc bảo mật này rất quan trọng, đặc biệt khi xử lý dữ liệu nhạy cảm, đảm bảo rằng các kết nối là an toàn và quyền truy cập được quản lý chặt chẽ.

Về mặt kỹ thuật, các máy chủ cung cấp khả năng của chúng thông qua các điểm cuối JSON-RPC, cho phép các khách hàng truy vấn các tài nguyên, công cụ và nhắc nhở có sẵn.

Ví dụ, một máy chủ có thể cung cấp một tài nguyên "readFile" để trả về nội dung của một tệp chỉ định, hoặc một công cụ "createIssue" tương tác với API của GitHub. Giao thức cũng hỗ trợ các hành vi do máy chủ khởi xướng như lấy mẫu, cho phép các tương tác AI có tính chất tác động, có thể được đệ quy và động, như mô tả trong tài liệu.

Quan tâm đến Máy chủ MCP? Bạn có thể thử những điều này ngay bây giờ

Hệ sinh thái các máy chủ MCP rất phong phú và đang phát triển, với nhiều ví dụ minh họa cho tiện ích của chúng, được liệt kê trong kho tại GitHub - awesome-mcp-servers:

💡
Muốn khám phá hơn 1000 Máy chủ MCP nữa?

Tìm hiểu thêm tại Himcp.ai!
button

Sự khác biệt giữa Máy chủ MCP và APIs là gì?

Nguồn: Blog của Norah Sakal

Trong khi cả máy chủ MCP và API truyền thống cho phép phần mềm tương tác với các dịch vụ bên ngoài, mục đích của chúng khác nhau trong ngữ cảnh AI:

Ví dụ, trong một thiết lập truyền thống, AI có thể cần gọi một API REST để lấy dữ liệu thời tiết, phân tích các phản hồi JSON và tích hợp chúng vào ngữ cảnh của mình. Với một máy chủ MCP, máy chủ có thể cung cấp một công cụ "get_weather", và AI chỉ cần gọi nó với các tham số, nhận dữ liệu đã định dạng sẵn sàng để sử dụng.

Cách thiết lập Máy chủ MCP (với Claude làm ví dụ)

Giao thức Ngữ cảnh Mô hình (MCP) là một framework mạnh mẽ cho phép

Các máy chủ MCP có thể cung cấp ba loại khả năng chính:

Thiết lập môi trường của bạn

Trước khi bắt đầu, hãy đảm bảo bạn có:

Cài đặt Trình quản lý gói UV

UV là trình quản lý gói được khuyên dùng cho các dự án MCP bằng Python:

# MacOS/Linux
curl -LsSf <https://astral.sh/uv/install.sh> | sh

# Hãy chắc chắn khởi động lại terminal của bạn sau đó

Xây dựng một Máy chủ MCP

Hãy xây dựng một máy chủ thời tiết đơn giản làm ví dụ.

Máy chủ này sẽ cung cấp hai công cụ: get-alerts và get-forecast.

Bước 1: Thiết lập cấu trúc dự án

# Tạo một thư mục mới cho dự án của chúng tôi
uv init weather
cd weather

# Tạo môi trường ảo và kích hoạt nó
uv venv
source .venv/bin/activate  # Trên Windows: .venv\\\\Scripts\\\\activate

# Cài đặt các phụ thuộc
uv add "mcp[cli]" httpx

# Tạo tệp máy chủ của chúng tôi
touch weather.py

Bước 2: Thực hiện Máy chủ

Dưới đây là một triển khai hoàn chỉnh của máy chủ thời tiết của chúng tôi (trong weather.py):

from typing import Any
import httpx
from mcpserver.fastmcp import FastMCP

# Khởi tạo máy chủ FastMCP
mcp = FastMCP("weather")

# Hằng số
NWS_API_BASE = "<https://api.weather.gov>"
USER_AGENT = "weather-app/1.0"

async def make_nws_request(url: str) -> dict[str, Any] | None:
    """Thực hiện một yêu cầu đến API NWS với việc xử lý lỗi phù hợp."""
    headers = {
        "User-Agent": USER_AGENT,
        "Accept": "application/geo+json"
    }
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=headers, timeout=30.0)
            response.raise_for_status()
            return response.json()
        except Exception:
            return None

def format_alert(feature: dict) -> str:
    """Định dạng một đặc điểm cảnh báo thành một chuỗi dễ đọc."""
    props = feature["properties"]
    return f"""
Sự kiện: {props.get('event', 'Không xác định')}
Khu vực: {props.get('areaDesc', 'Không xác định')}
Mức độ nghiêm trọng: {props.get('severity', 'Không xác định')}
Mô tả: {props.get('description', 'Không có mô tả nào có sẵn')}
Hướng dẫn: {props.get('instruction', 'Không có hướng dẫn cụ thể nào được cung cấp')}
"""

@mcp.tool()
async def get_alerts(state: str) -> str:
    """Lấy cảnh báo thời tiết cho một tiểu bang của Mỹ.

    Tham số:
        state: Mã tiểu bang hai chữ cái của Mỹ (ví dụ: CA, NY)
    """
    url = f"{NWS_API_BASE}/alerts/active/area/{state}"
    data = await make_nws_request(url)

    if not data or "features" not in data:
        return "Không thể lấy cảnh báo hoặc không có cảnh báo nào được tìm thấy."

    if not data["features"]:
        return "Không có cảnh báo nào đang hoạt động cho tiểu bang này."

    alerts = [format_alert(feature) for feature in data["features"]]
    return "\\\\n---\\\\n".join(alerts)

@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
    """Lấy dự báo thời tiết cho một vị trí.

    Tham số:
        latitude: Vĩ độ của vị trí
        longitude: Kinh độ của vị trí
    """
    # Đầu tiên lấy điểm cuối lưới dự báo
    points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
    points_data = await make_nws_request(points_url)

    if not points_data:
        return "Không thể lấy dữ liệu dự báo cho vị trí này."

    # Lấy URL dự báo từ phản hồi điểm
    forecast_url = points_data["properties"]["forecast"]
    forecast_data = await make_nws_request(forecast_url)

    if not forecast_data:
        return "Không thể lấy dự báo chi tiết."

    # Định dạng các khoảng thời gian thành một dự báo dễ đọc
    periods = forecast_data["properties"]["periods"]
    forecasts = []
    for period in periods[:5]:  # Chỉ hiển thị 5 khoảng thời gian tiếp theo
        forecast = f"""
{period['name']}: Nhiệt độ: {period['temperature']}°{period['temperatureUnit']}
Gió: {period['windSpeed']} {period['windDirection']}
Dự báo: {period['detailedForecast']}
"""
        forecasts.append(forecast)

    return "\\\\n---\\\\n".join(forecasts)

if __name__ == "__main__":
    # Khởi tạo và chạy máy chủ
    mcp.run(transport='stdio')

Bước 3: Chạy Máy chủ của bạn

Để thử nghiệm máy chủ của bạn trực tiếp, hãy chạy:

uv run weather.py

Kết nối với Claude cho Desktop

Claude cho Desktop là cách đơn giản để tương tác với các máy chủ MCP của bạn.

Bước 1: Cài đặt Claude cho Desktop

Đảm bảo bạn đã cài đặt Claude cho Desktop và cập nhật lên phiên bản mới nhất.

Bước 2: Cấu hình Claude cho Desktop

  1. Mở cấu hình ứng dụng Claude cho Desktop trong một trình soạn thảo văn bản:
# macOS
code ~/Library/Application\\\\ Support/Claude/claude_desktop_config.json

2. Thêm cấu hình máy chủ của bạn:

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": [
        "--directory",
        "/ABSOLUTE/PATH/TO/PARENT/FOLDER/weather",
        "run",
        "weather.py"
      ]
    }
  }
}

Đảm bảo:

Bước 3: Khởi động lại Claude cho Desktop

Sau khi lưu cấu hình, hãy khởi động lại hoàn toàn Claude cho Desktop.

Bước 4: Kiểm tra Máy chủ của bạn

Tìm biểu tượng búa ở góc dưới bên phải của hộp nhập liệu Claude cho Desktop. Nhấp vào nó sẽ hiển thị các công cụ của máy chủ của bạn.

Bạn có thể hỏi Claude các câu hỏi như:

Xây dựng một Client MCP tùy chỉnh cho Các máy chủ MCP của Claude

Thay vì sử dụng Claude cho Desktop, bạn có thể xây dựng một client tùy chỉnh của riêng bạn.

Bước 1: Thiết lập Dự án Client

# Tạo thư mục dự án
uv init mcp-client
cd mcp-client

# Tạo môi trường ảo
uv venv
source .venv/bin/activate  # Trên Windows: .venv\\\\Scripts\\\\activate

# Cài đặt các gói cần thiết
uv add mcp anthropic python-dotenv

# Tạo tệp chính của chúng tôi
touch client.py

Bước 2: Thiết lập Khóa API của bạn

Tạo một tệp .env với khóa API của Anthropic:

ANTHROPIC_API_KEY=<khóa của bạn ở đây>

Bước 3: Thực hiện Client

Dưới đây là một triển khai client cơ bản (trong client.py):

import asyncio
import sys
from typing import Optional
from contextlib import AsyncExitStack

from mcp.client.stdio import ClientSession, StdioServerParameters, stdio_client
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()  # tải các biến môi trường từ .env

class MCPClient:
    def __init__(self):
        # Khởi tạo các phiên và đối tượng client
        self.session: Optional[ClientSession] = None
        self.exit_stack = AsyncExitStack()
        self.anthropic = Anthropic()

    async def connect_to_server(self, server_script_path: str):
        """Kết nối với một máy chủ MCP

        Tham số:
            server_script_path: Đường dẫn đến tệp kịch bản máy chủ (py hoặc js)
        """
        is_python = server_script_path.endswith('.py')
        is_js = server_script_path.endswith('.js')

        if not (is_python or is_js):
            raise ValueError("Tệp kịch bản máy chủ phải là tệp .py hoặc .js")

        command = "python" if is_python else "node"
        server_params = StdioServerParameters(command=command, args=[server_script_path], env=None)

        stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
        self.stdio, self.write = stdio_transport
        self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
        await self.session.initialize()

        # Liệt kê các công cụ có sẵn
        response = await self.session.list_tools()
        tools = response.tools
        print("\\\\nKết nối với máy chủ với các công cụ:", [tool.name for tool in tools])

    async def process_query(self, query: str) -> str:
        """Xử lý một truy vấn sử dụng Claude và các công cụ có sẵn"""
        messages = [
            {
                "role": "user",
                "content": query
            }
        ]

        response = await self.session.list_tools()
        available_tools = [{
            "name": tool.name,
            "description": tool.description,
            "input_schema": tool.input_schema
        } for tool in response.tools]

        # Cuộc gọi API đầu tiên của Claude
        response = self.anthropic.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1000,
            messages=messages,
            tools=available_tools
        )

        # Xử lý phản hồi và xử lý các cuộc gọi công cụ
        final_text = []
        assistant_message_content = []

        for content in response.content:
            if content.type == 'text':
                final_text.append(content.text)
                assistant_message_content.append(content)
            elif content.type == 'tool_use':
                tool_name = content.name
                tool_args = content.input

                # Thực hiện cuộc gọi công cụ
                result = await self.session.call_tool(tool_name, tool_args)
                final_text.append(f"[Gọi công cụ {tool_name} với các tham số {tool_args}]")
                assistant_message_content.append(content)

                messages.append({
                    "role": "assistant",
                    "content": assistant_message_content
                })

                messages.append({
                    "role": "user",
                    "content": [
                        {
                            "type": "tool_result",
                            "tool_use_id": content.id,
                            "content": result
                        }
                    ]
                })

                # Lấy phản hồi tiếp theo từ Claude
                response = self.anthropic.messages.create(
                    model="claude-3-5-sonnet-20241022",
                    max_tokens=1000,
                    messages=messages,
                    tools=available_tools
                )

                final_text.append(response.content[0].text)

        return "\\\\n".join(final_text)

    async def chat_loop(self):
        """Chạy một vòng hội thoại tương tác"""
        print("\\\\nKhách hàng MCP đã bắt đầu!")
        print("Nhập truy vấn của bạn hoặc 'quit' để thoát.")

        while True:
            try:
                query = input("\\\\nTruy vấn: ").strip()
                if query.lower() == 'quit':
                    break

                response = await self.process_query(query)
                print("\\\\n" + response)
            except Exception as e:
                print(f"\\\\nLỗi: {str(e)}")

    async def cleanup(self):
        """Dọn dẹp tài nguyên"""
        await self.exit_stack.aclose()

async def main():
    if len(sys.argv) < 2:
        print("Cách sử dụng: python client.py <đường dẫn đến tệp kịch bản máy chủ>")
        sys.exit(1)

    client = MCPClient()

    try:
        await client.connect_to_server(sys.argv[1])
        await client.chat_loop()
    finally:
        await client.cleanup()

if __name__ == "__main__":
    asyncio.run(main())

Bước 4: Chạy Client

Để sử dụng client của bạn với máy chủ thời tiết của bạn:

uv run client.py /path/to/weather.py

Sử dụng các Máy chủ MCP đã có sẵn với Claude cho Desktop

Claude cho Desktop hỗ trợ một loạt các máy chủ MCP đã được xây dựng sẵn. Hãy xem cách sử dụng máy chủ hệ thống tệp làm ví dụ.

Bước 1: Cấu hình Máy chủ Hệ thống tệp

  1. Mở cài đặt Claude cho Desktop và nhấp vào "Chỉnh sửa Cấu hình"
  2. Cập nhật tệp cấu hình của bạn với:
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop",
        "/Users/username/Downloads"
      ]
    }
  }
}

Thay thế username bằng tên đăng nhập thực tế của bạn và điều chỉnh các đường dẫn khi cần thiết.

Bước 2: Khởi động lại và Kiểm tra

Sau khi khởi động lại Claude cho Desktop, bạn có thể sử dụng các công cụ hệ thống tệp để:

Các nhắc nhở ví dụ:

Kết luận

Các máy chủ MCP đại diện cho một sự tiến bộ đáng kể trong chức năng AI, thu hẹp khoảng cách giữa các mô hình ngôn ngữ mạnh mẽ và các công cụ bên ngoài. Bằng cách làm theo hướng dẫn này, bạn đã học được cách tạo ra, cấu hình và sử dụng các máy chủ MCP để nâng cao khả năng của Claude.

Cách tiếp cận tiêu chuẩn hóa của Giao thức Ngữ cảnh Mô hình đảm bảo rằng các mô hình AI có thể truy cập dữ liệu theo thời gian thực, thực hiện các hành động và tương tác với các hệ thống theo cách an toàn và có kiểm soát. Điều này làm cho các trợ lý AI trở nên thực tiễn hơn cho các ứng dụng trong thế giới thực trong phát triển, phân tích dữ liệu, tạo nội dung, và hơn thế nữa.

Khi hệ sinh thái MCP tiếp tục phát triển, các nhà phát triển đang tạo ra ngày càng nhiều máy chủ phức tạp mở rộng những gì có thể với AI. Cho dù bạn đang sử dụng các máy chủ đã xây dựng sẵn hay phát triển các giải pháp tùy chỉnh, MCP cung cấp một nền tảng linh hoạt để xây dựng các ứng dụng AI có khả năng hơn.


Khi bạn tiếp tục làm việc với các máy chủ MCP thường liên quan đến các tích hợp API, bạn có thể muốn khám phá Apidog, một nền tảng phát triển API toàn diện có thể bổ sung cho quy trình triển khai MCP của bạn.

Apidog cung cấp một giải pháp toàn diện cho thiết kế API, tài liệu, gỡ lỗi và kiểm thử tự động. Giao diện trực quan của nó giúp bạn dễ dàng:

Khi phát triển các máy chủ MCP tương tác với các API bên ngoài, Apidog có thể giúp bạn xác thực các điểm cuối, hiểu các cấu trúc phản hồi, và đảm bảo rằng các tích hợp của bạn hoạt động đúng trước khi triển khai chúng vào mã máy chủ của bạn.

Để bắt đầu với Apidog cùng với phát triển MCP của bạn, hãy truy cập trang web Apidog và khám phá cách nó có thể nâng cao quy trình phát triển API của bạn.

button


Bằng cách kết hợp các máy chủ MCP với các công cụ phát triển API hiệu quả như Apidog, bạn có thể tạo ra các kết nối mạnh mẽ, đáng tin cậy giữa các hệ thống AI và các dịch vụ bên ngoài, làm cho các ứng dụng AI của bạn trở nên mạnh mẽ hơn.


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