Xây dựng một AI Agent với Giao thức Ngữ cảnh Mô hình (MCP): Hướng dẫn Toàn diện
Từ lý thuyết đến thực hành: Tìm hiểu cách Giao thức Ngữ cảnh Mô hình (MCP) giải quyết các thách thức tích hợp AI, thông qua việc xây dựng một agent thời tiết và tìm kiếm với FastMCP, LangGraph và OpenAI
Giao thức Ngữ cảnh Mô hình (MCP) [Ảnh bởi Alpha Iterations]
Phép loại suy
Tất cả chúng ta đều biết đến quyền trợ giúp "Gọi điện thoại cho người thân" trong chương trình "Ai là triệu phú?". Nhưng hãy tưởng tượng nếu chương trình này tồn tại trước khi điện thoại được phát minh.
Khi chưa có điện thoại:
Trong một thế giới không có điện thoại, nếu chương trình muốn người chơi "gọi" cho người thân, họ sẽ phải:
- Đưa người thân đến trường quay
- Chuẩn bị phòng, lắp đặt micro, tai nghe, dây nối
- Lặp lại quy trình này cho mỗi người chơi
Mỗi người thân → một hệ thống thiết lập riêng biệt
Khi có điện thoại: Khi điện thoại ra đời, mọi thứ thay đổi. Chương trình không còn cần những thiết lập phức tạp nữa. Người chơi chỉ cần:
- Nhấc điện thoại lên
- Quay số cho người thân
- Trò chuyện ngay lập tức
Không cần phòng đặc biệt, không cần thiết lập đặc biệt. Đó chính xác là những gì MCP (Model Context Protocol - Giao thức Ngữ cảnh Mô hình) đang làm cho các ứng dụng LLM/AI.
Khi chưa có MCP:
- Mỗi công cụ cần một tích hợp tùy chỉnh riêng
- Không có cách tiêu chuẩn nào để các mô hình "nói chuyện" với công cụ
- Mọi thứ phải được kết nối thủ công với nhau
Khi có MCP:
- Bất kỳ mô hình AI nào cũng có thể "gọi" bất kỳ công cụ nào tương thích với MCP
- Miễn là nó biết schema của công cụ (giống như có số điện thoại)
- Không còn các tích hợp riêng lẻ nữa
- Mọi thứ đều sử dụng một giao thức tiêu chuẩn duy nhất
Giới thiệu
Trong thế giới phát triển nhanh chóng của AI và các mô hình ngôn ngữ lớn, một trong những thách thức lớn nhất là kết nối các mô hình mạnh mẽ này với dữ liệu và công cụ trong thế giới thực. Giao thức Ngữ cảnh Mô hình (MCP), được Anthropic giới thiệu vào năm 2024, là một tiêu chuẩn mở đột phá đang thay đổi cách các ứng dụng AI tương tác với các hệ thống bên ngoài.
Trong hướng dẫn toàn diện này, chúng ta sẽ khám phá MCP thông qua một dự án thực hành, nơi chúng ta xây dựng một AI agent đa công cụ có thể lấy dữ liệu thời tiết và thực hiện tìm kiếm trên web. Dù bạn là người đam mê AI, nhà phát triển, hay chỉ tò mò về tương lai của việc tích hợp AI, bài viết này sẽ cung cấp cho bạn những hiểu biết thực tế về việc xây dựng các ứng dụng được hỗ trợ bởi MCP.
Tại sao lại là MCP?:
MCP hoạt động như một cây cầu nối giữa các mô hình AI và các công cụ chúng cần, giúp xây dựng các AI agent tinh vi có thể tương tác liền mạch với thế giới bên ngoài.
MCP làm cho AI trở nên kết nối hơn, mạnh mẽ hơn và sẵn sàng cho việc triển khai trong doanh nghiệp bằng cách loại bỏ các silo tích hợp và tiêu chuẩn hóa cách chia sẻ ngữ cảnh giữa các mô hình và hệ thống bên ngoài.
Các thành phần chính của MCP (Giao thức Ngữ cảnh Mô hình)
Kiến trúc của MCP (Giao thức Ngữ cảnh Mô hình) [Ảnh bởi Alpha Iterations]
1. MCP Host
- Đây là môi trường ứng dụng/agent AI nơi diễn ra tương tác của người dùng (ví dụ: Claude Desktop, một IDE, hoặc một ứng dụng trò chuyện).
- Host điều phối nhiều client, quản lý các luồng công việc, và quyết định cách thức và thời điểm gọi các MCP client khác nhau.
2. MCP Client
MCP Client hoạt động bên trong ứng dụng host và quản lý giao tiếp với các MCP Server. Trách nhiệm của nó bao gồm:
- Thiết lập kết nối đến các MCP server
- Yêu cầu thông tin về các khả năng có sẵn
- Nó dịch ý định của mô hình (hoặc "yêu cầu") thành các thông điệp giao thức MCP có cấu trúc và chuyển tiếp đến server.
- Xử lý và diễn giải các phản hồi trả về
3. MCP Server
MCP Server cung cấp các khả năng cụ thể và quyền truy cập vào các nguồn dữ liệu và công cụ khác nhau. Mỗi công cụ (cơ sở dữ liệu, API, hệ thống tệp, CRM, email, v.v.) là một MCP Server. Một server có thể có nhiều công cụ. Dưới đây là các trách nhiệm của MCP Server.
- Nó chờ các yêu cầu đến
- Thực thi chức năng hoặc truy xuất dữ liệu
- Trả về kết quả có cấu trúc cho Client
Mỗi server cung cấp ba loại khả năng chính:
- Tools (Công cụ): Các hàm cho phép LLM thực hiện hành động (ví dụ: chạy tìm kiếm, gọi API)
- Resources (Tài nguyên): Dữ liệu hoặc nội dung có thể truy cập bởi LLM (tài liệu, dữ liệu người dùng, thông tin có cấu trúc)
- Prompts (Gợi ý): Các mẫu hoặc luồng công việc có thể tái sử dụng để hướng dẫn việc tạo ra các kết quả cụ thể
4. Protocol (Giao thức)
- MCP định nghĩa một lớp dữ liệu sử dụng JSON-RPC 2.0 để giao tiếp giữa client và server.
- Nó định nghĩa các loại thông điệp, ngữ nghĩa, và các nguyên tắc cơ bản cho "công cụ", "tài nguyên", "gợi ý", và các thông báo.
- Quản lý vòng đời: MCP xử lý việc thiết lập kết nối, đàm phán khả năng (tức là, tìm ra những gì server hỗ trợ), và kết thúc một cách sạch sẽ.
- Bảo mật: thường sử dụng OAuth (hoặc các phương thức xác thực khác) để ủy quyền cho các tương tác client-server.
5. Transport Layer (Lớp vận chuyển)
Trừu tượng hóa cách các thông điệp được gửi đi. MCP hỗ trợ các cơ chế vận chuyển khác nhau.
Hai phương thức vận chuyển phổ biến:
- STDIO: (Standard Input/Output - Đầu vào/Đầu ra tiêu chuẩn) cho thiết lập cục bộ, đồng bộ (ví dụ: khi server đang chạy cục bộ).
- Server-Sent Events (SSE): cho các server từ xa, cho phép streaming hoặc cập nhật thời gian thực.
Sản phẩm chúng ta sẽ xây dựng:
Trong thiết lập này, chúng ta đã xây dựng một agent LangGraph có khả năng:
- Tích hợp các công cụ MCP (tìm kiếm web, thời tiết) để thực hiện các hành động bên ngoài.
- Sử dụng LLM của OpenAI để định tuyến và tạo phản hồi.
- Xử lý các cuộc trò chuyện có trạng thái với các luồng công việc có cấu trúc.
- Có thể mở rộng với các công cụ bổ sung hoặc các đồ thị phức tạp hơn.
Với kiến trúc này, bạn có thể xây dựng các trợ lý AI đa công cụ có khả năng suy luận, hành động và phản hồi một cách linh hoạt.
Triển khai Giao thức Ngữ cảnh Mô hình
Luồng xử lý từ Truy vấn của người dùng → Phản hồi cuối cùng sử dụng MCP [Ảnh bởi Tác giả]
Hãy bắt đầu nào:
Cấu trúc dự án
Vui lòng tham khảo kho lưu trữ github đầy đủ từ đầu đến cuối tại đây.
mcp-server/
├── mcp_server.py # Triển khai MCP server (FastMCP)
├── mcp_client.py # MCP client + agent LangGraph
├── mcp-server.ipynb # Jupyter notebook để kiểm thử
├── requirements.txt # Các thư viện phụ thuộc của Python
├── .env # Biến môi trường (API keys)
└── README.md
1. Cài đặt và thiết lập
1.1 Sao chép kho lưu trữ
Chạy lệnh này trong terminal của bạn để sao chép kho lưu trữ
#Terminal
git clone https://github.com/alphaiterations/mcp-server
cd mcp-server
1.2 Cài đặt các thư viện phụ thuộc
Chạy lệnh này trong terminal của bạn để cài đặt các thư viện phụ thuộc
#Terminal
pip install -r requirements.txt
1.3 Cấu hình biến môi trường
Tạo một tệp .env trong thư mục gốc của dự án:
#.env
# OpenAI API Key (bắt buộc)
OPEN_AI_KEY=your_openai_api_key_here
# Serper API Key (bắt buộc cho tìm kiếm web)
SERPER_API_KEY=your_serper_api_key_here
Lấy API Keys:
- OpenAI: https://platform.openai.com/api-keys
- Serper: https://serper.dev/ (có gói miễn phí)
2. Thiết lập MCP Server:
Chúng ta thiết lập MCP Server bằng tệp mcp_server.py. Script này tạo ra một server công cụ MCP sẵn sàng cho sản xuất với hai công cụ có thể sử dụng đầy đủ:
get_weather: Trả về thời tiết thời gian thực cho bất kỳ thành phố nào
web_search: Thực hiện các tìm kiếm kiểu Google thân thiện với AI
Cả hai công cụ đều tự động xác thực đầu vào, xử lý lỗi một cách sạch sẽ và trả về JSON có cấu trúc — làm cho chúng trở nên lý tưởng để tích hợp với LLM.
2.1 Nhập các thư viện
Chúng ta nhập các thư viện fastmcp, pydantic.
#mcp_server.py
from fastmcp import FastMCP
from pydantic import BaseModel
import os
import requests
from dotenv import load_dotenv
2.2 Cấu hình API
Đoạn mã này đọc các khóa API từ biến môi trường. OPENWEATHER_API_KEY là tùy chọn vì công cụ thời tiết sử dụng một dịch vụ dự phòng miễn phí.
#mcp_server.py
# ---------------- API CONFIGURATION ----------------
SERPER_API_KEY = os.getenv("SERPER_API_KEY")
OPENWEATHER_API_KEY = os.getenv("OPENWEATHER_API_KEY", "") # Tùy chọn, sử dụng API thời tiết miễn phí
2.3 Tạo MCP Server
#mcp_server.py
mcp = FastMCP("multi-tool-server")
Thao tác này khởi tạo một MCP server mới có tên là “multi-tool-server”. Mỗi hàm được đăng ký dưới đây sẽ trở thành một công cụ có thể gọi được của agent.
2.4 Công cụ thời tiết
#mcp_server.py
@mcp.tool()
def get_weather(input: WeatherInput):
"""Lấy thời tiết hiện tại cho một thành phố bằng WeatherAPI.com (gói miễn phí)"""
try:
# Sử dụng gói miễn phí của WeatherAPI.com (không cần API key cho việc sử dụng cơ bản)
# Lựa chọn thay thế: OpenWeatherMap nếu bạn có API key
url = f"https://wttr.in/{input.city}?format=j1"
response = requests.get(url, timeout=5)
if response.status_code == 200:
data = response.json()
current = data["current_condition"][0]
location = data["nearest_area"][0]
weather_info = {
"location": f"{location['areaName'][0]['value']}, {location['country'][0]['value']}",
"temperature": f"{current['temp_C']}°C / {current['temp_F']}°F",
"condition": current["weatherDesc"][0]["value"],
"humidity": f"{current['humidity']}%",
"wind": f"{current['windspeedKmph']} km/h",
"feels_like": f"{current['FeelsLikeC']}°C"
}
return weather_info
else:
return {"error": f"Không thể lấy thời tiết cho {input.city}"}
except Exception as e:
return {"error": f"Lỗi API thời tiết: {str(e)}"}
Đoạn mã này đăng ký một công cụ tra cứu thời tiết có thể truy cập thông qua MCP.
Hoạt động chính bên trong:
- Sử dụng wttr.in, một API thời tiết miễn phí (không cần khóa).
- Trích xuất các trường thông tin thân thiện với người dùng như nhiệt độ, độ ẩm, tốc độ gió.
- Bao bọc mọi thứ trong một khối
try/exceptđể xử lý lỗi an toàn.
Ví dụ:
Đầu vào: {"city": "Mumbai"}
Đầu ra:
{
"location": "Mumbai, India",
"temperature": "28°C / 82°F",
"condition": "Partly cloudy",
"humidity": "70%",
"wind": "15 km/h"
}
2.5 Công cụ tìm kiếm web
#mcp_server.py
@mcp.tool()
def web_search(input: WebSearchInput):
"""Tìm kiếm trên web bằng Serper API"""
if not SERPER_API_KEY:
return {"error": "SERPER_API_KEY chưa được cấu hình"}
try:
url = "https://google.serper.dev/search"
headers = {
"X-API-KEY": SERPER_API_KEY,
"Content-Type": "application/json"
}
payload = {"q": input.query, "num": 5}
response = requests.post(url, json=payload, headers=headers, timeout=10)
if response.status_code == 200:
data = response.json()
results = []
# Trích xuất kết quả tự nhiên
for item in data.get("organic", [])[:5]:
results.append({
"title": item.get("title"),
"link": item.get("link"),
"snippet": item.get("snippet")
})
# Bao gồm biểu đồ tri thức nếu có
knowledge = data.get("knowledgeGraph", {})
return {
"query": input.query,
"results": results,
"knowledge_graph": knowledge.get("description", "") if knowledge else None
}
else:
return {"error": f"Lỗi Serper API: {response.status_code}"}
except Exception as e:
return {"error": f"Lỗi tìm kiếm web: {str(e)}"}
Đoạn mã này đăng ký một công cụ tìm kiếm kiểu Google được cung cấp bởi Serper API.
Điểm nổi bật:
- Xác thực sự tồn tại của khóa API trước khi chạy.
- Gửi một yêu cầu POST với truy vấn và lấy tối đa 5 kết quả.
- Phân tích cú pháp: Tiêu đề, Liên kết và Đoạn trích.
Nếu có bất kỳ lỗi nào xảy ra, nó sẽ trả về một thông báo lỗi JSON có cấu trúc.
Ví dụ:
Đầu vào: {"query": "latest news about AI"}
Đầu ra:
{
"query": "latest news about AI",
"results": [
{
"title": "AI Breakthrough...",
"link": "https://...",
"snippet": "..."
}
]
}
2.6 Điểm khởi chạy Server
#mcp_server.py
if __name__ == "__main__":
print("🔥 MCP server đang chạy...")
mcp.run()
Khối mã này khởi động MCP server khi script được thực thi trực tiếp. Khi đang chạy, các công cụ như get_weather và web_search có thể được gọi bởi:
- Các AI agent
- Các framework LangChain / LLM
- Bất kỳ client nào tương thích với MCP
3. Thiết lập MCP Client
3.1 Các thư viện phụ thuộc và thiết lập môi trường
# mcp_client.py
import subprocess, json, sys, threading, time
from langgraph.graph import StateGraph, END
from typing import TypedDict, Any, Dict
from openai import OpenAI
from dotenv import load_dotenv
import os
# Tải các biến môi trường
load_dotenv()
Ở đây chúng ta nhập:
- LangGraph: Để xây dựng các luồng công việc của agent dựa trên trạng thái.
- OpenAI: Để xử lý suy luận và hội thoại của LLM.
- subprocess/threading: Để khởi chạy và giao tiếp với một MCP server.
- dotenv/os: Để tải các khóa API một cách an toàn.
3.2 Khởi tạo OpenAI Client
# mcp_client.py
client = OpenAI(api_key=os.getenv("OPEN_AI_KEY"))
Chúng ta tạo một OpenAI client bằng cách sử dụng khóa API từ các biến môi trường.
3.3 Khởi chạy MCP Server
# mcp_client.py
server = subprocess.Popen(
[sys.executable, "mcp_server.py"],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
bufsize=1
)
print("🔗 Đã kết nối đến MCP server")
Ở đây chúng ta tạo ra một tiến trình con MCP server, tiến trình này sẽ cung cấp các công cụ mà chúng ta đã tạo trước đó (get_weather và web_search).
Chúng ta cũng sử dụng một luồng để đọc các thông báo khởi động mà không làm chặn chương trình chính:
# mcp_client.py
def read_startup():
while True:
line = server.stderr.readline()
if not line:
break
if "Starting MCP server" in line:
break
startup_thread = threading.Thread(target=read_startup, daemon=True)
startup_thread.start()
time.sleep(1)
3.4 Các hàm hỗ trợ giao tiếp MCP
Chúng ta định nghĩa các hàm để gửi yêu cầu và thông báo qua giao thức MCP JSON-RPC:
# mcp_client.py
def send_request(method: str, params: Dict = None):
global request_id
request_id += 1
req = {"jsonrpc": "2.0", "id": str(request_id), "method": method}
if params:
req["params"] = params
server.stdin.write(json.dumps(req) + "\n")
server.stdin.flush()
return server.stdout.readline().strip()
def send_notification(method: str, params: Dict = None):
req = {"jsonrpc": "2.0", "method": method}
if params:
req["params"] = params
server.stdin.write(json.dumps(req) + "\n")
server.stdin.flush()
Sau đó, chúng ta khởi tạo kết nối MCP:
# mcp_client.py
init_response = send_request("initialize", {
"protocolVersion": "2024-11-05",
"capabilities": {},
"clientInfo": {"name": "mcp-client", "version": "1.0.0"}
})
send_notification("initialized")
3.4 Gọi các công cụ MCP
# mcp_client.py
def call_mcp_tool(tool: str, args: Dict):
global request_id
request_id += 1
req = {
"jsonrpc": "2.0",
"id": str(request_id),
"method": "tools/call",
"params": {"name": tool, "arguments": {"input": args}},
}
server.stdin.write(json.dumps(req) + "\n")
server.stdin.flush()
response = server.stdout.readline().strip()
try:
resp_data = json.loads(response)
return resp_data.get("result") or f"Lỗi: {resp_data.get('error')}"
except:
return response
Hàm này cho phép agent gọi bất kỳ công cụ nào đã được đăng ký trong MCP server với các tham số.
3.5 Đồ thị trạng thái của Agent
Chúng ta định nghĩa một schema trạng thái bằng TypedDict:
# mcp_client.py
class S(TypedDict):
msg: str
tool_result: Any
result: str
Sau đó, chúng ta triển khai logic của agent bằng hai hàm chính:
1️⃣ Định tuyến yêu cầu đến các công cụ
# mcp_client.py
# ---------------- LOGIC CỦA AGENT ----------------
def route_request(state: S):
"""Sử dụng LLM để xác định công cụ nào sẽ sử dụng và trích xuất các tham số"""
# Yêu cầu LLM phân tích yêu cầu và quyết định sử dụng công cụ
routing_prompt = f"""Phân tích yêu cầu của người dùng này và xác định công cụ nào sẽ sử dụng:
Yêu cầu của người dùng: {state["msg"]}
Các công cụ có sẵn:
1. get_weather - Lấy thời tiết hiện tại cho một thành phố. Yêu cầu: tên thành phố
2. web_search - Tìm kiếm thông tin trên web. Yêu cầu: truy vấn tìm kiếm
Phản hồi ở định dạng JSON với:
{{
"tool": "get_weather" | "web_search" | "none",
"parameters": {{"city": "..."}} hoặc {{"query": "..."}} hoặc null,
"reasoning": "giải thích ngắn gọn"
}}
Chỉ sử dụng công cụ nếu thực sự cần thiết. Đối với cuộc trò chuyện thông thường, hãy sử dụng "none"."""
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "Bạn là một trợ lý định tuyến công cụ. Hãy phân tích yêu cầu của người dùng và xác định công cụ nào sẽ sử dụng. Luôn phản hồi bằng JSON hợp lệ."},
{"role": "user", "content": routing_prompt}
],
temperature=0.3,
response_format={"type": "json_object"}
)
try:
routing_decision = json.loads(response.choices[0].message.content)
tool = routing_decision.get("tool")
params = routing_decision.get("parameters")
print(f"🤖 Quyết định định tuyến: {routing_decision.get('reasoning')}")
if tool == "get_weather" and params:
result = call_mcp_tool("get_weather", params)
return {"msg": state["msg"], "tool_result": result}
elif tool == "web_search" and params:
result = call_mcp_tool("web_search", params)
return {"msg": state["msg"], "tool_result": result}
else:
return {"msg": state["msg"], "tool_result": None}
except Exception as e:
print(f"⚠️ Lỗi định tuyến: {e}")
return {"msg": state["msg"], "tool_result": None}
- Agent sử dụng một LLM để quyết định công cụ nào (
get_weather,web_search, hoặc không có) là phù hợp. - Nó trả về các tham số cần thiết cho công cụ đã chọn.
- Nếu không cần công cụ nào, agent sẽ tiếp tục với cuộc trò chuyện thông thường.
2️⃣ Tạo phản hồi bằng ngôn ngữ tự nhiên
Hàm này đảm bảo agent phản hồi một cách tự nhiên, cho dù nó có sử dụng dữ liệu từ công cụ hay không.
# mcp_client.py
def generate_response(state: S):
"""Sử dụng OpenAI để tạo phản hồi bằng ngôn ngữ tự nhiên"""
if state.get("tool_result") is None:
# Không có công cụ nào được sử dụng, phản hồi trực tiếp từ LLM
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "Bạn là một trợ lý hữu ích."},
{"role": "user", "content": state["msg"]}
],
temperature=0.7
)
return {
"msg": state["msg"],
"tool_result": state.get("tool_result"),
"result": response.choices[0].message.content
}
# Định dạng kết quả công cụ cho LLM
tool_data = json.dumps(state["tool_result"], indent=2)
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "Bạn là một trợ lý hữu ích. Hãy sử dụng kết quả công cụ được cung cấp để trả lời câu hỏi của người dùng một cách tự nhiên, trò chuyện. Hãy súc tích nhưng đầy đủ thông tin."},
{"role": "user", "content": f"Câu hỏi của người dùng: {state['msg']}\n\nKết quả công cụ:\n{tool_data}\n\nCung cấp một câu trả lời hữu ích dựa trên thông tin này. Vui lòng giới hạn câu trả lời của bạn trong 100 từ."}
],
temperature=0.7
)
return {
"msg": state["msg"],
"tool_result": state["tool_result"],
"result": response.choices[0].message.content
}
🗺 Xây dựng luồng công việc LangGraph
# mcp_client.py
g = StateGraph(S)
g.add_node("route", route_request)
g.add_node("respond", generate_response)
g.set_entry_point("route")
g.add_edge("route", "respond")
g.add_edge("respond", END)
graph = g.compile()
- Điểm vào:
route→ quyết định việc sử dụng công cụ. - Node phản hồi: định dạng đầu ra và trả lời cho người dùng.
- Các cạnh của đồ thị xác định luồng công việc từ định tuyến → phản hồi → KẾT THÚC.
Trực quan hóa đồ thị
# mcp_client.py
# ---------------- LƯU TRỰC QUAN HÓA ĐỒ THỊ ----------------
try:
# Tạo và lưu đồ thị dưới dạng PNG
png_data = graph.get_graph().draw_mermaid_png()
with open("langgraph_diagram.png", "wb") as f:
f.write(png_data)
print("📊 Đã lưu trực quan hóa đồ thị thành 'langgraph_diagram.png'\n")
except Exception as e:
print(f"⚠️ Không thể tạo trực quan hóa đồ thị: {e}")
print("Lưu ý: Cài đặt thư viện hệ thống graphviz nếu cần: brew install graphviz\n")
Luồng LangGraph [Ảnh bởi Tác giả]
4. Kiểm thử Agent
# mcp_client.py
tests = [
"Thời tiết ở Mumbai thế nào?",
"Tìm kiếm tin tức mới nhất về AI",
]
for t in tests:
result = graph.invoke({"msg": t})
print(f"AGENT: {result['result']}\n")
Chạy lệnh dưới đây trong terminal của bạn:
# Terminal
python mcp_client.py
Lệnh này sẽ chạy tệp python mcp_client.py và sẽ cho bạn kết quả của mỗi truy vấn kiểm thử.
Truy vấn 1: Thời tiết ở Mumbai thế nào?
================================================================================
NGƯỜI DÙNG: Thời tiết ở Mumbai thế nào?
================================================================================
🤖 Quyết định định tuyến: Người dùng đang hỏi về thời tiết hiện tại ở Mumbai, điều này yêu cầu công cụ get_weather.
AGENT: Thời tiết hiện tại ở Mumbai (Bombay) là 29°C (85°F) với điều kiện khói mù. Độ ẩm là 33%, và tốc độ gió là 15 km/h. Cảm giác như 32°C. Nếu bạn định ra ngoài, hãy chú ý đến khói và giữ đủ nước!
Ở đây công cụ get_weather được sử dụng.
Truy vấn 2: Tìm kiếm tin tức mới nhất về AI
================================================================================
NGƯỜI DÙNG: Tìm kiếm tin tức mới nhất về AI
================================================================================
🤖 Quyết định định tuyến: Người dùng đang yêu cầu thông tin về tin tức mới nhất, điều này yêu cầu tìm kiếm trên web.
AGENT: Đây là một số cập nhật mới nhất về AI:
1. **Giám đốc SoftBank** dự đoán rằng Siêu trí tuệ nhân tạo (ASI) sẽ xuất hiện trong thập kỷ tới. [Đọc thêm](https://www.artificialintelligence-news.com/).
2. **Các hacker Trung Quốc** được cho là đang sử dụng AI của Anthropic để tự động hóa các cuộc tấn công mạng, cho thấy một xu hướng đáng lo ngại trong việc hack được hỗ trợ bởi AI. [Chi tiết tại đây](https://www.wsj.com/tech/ai?gaa_at=eafs&gaa_n=AWEtsqe6_smhBCGQiDzNepJqC6o3y7PhzDWoVgMhJZGDlbwMlAYPmvdgcIPG&gaa_ts=69189ea0&gaa_sig=qnJpVRszm4Y6fAKLtKZrrhXemUfohwfFMNBiCB3KvfR27ZVin1pFM5wC5RChseRXHH0r_l6_oX46pJKkaceNWg%3D%3D).
3. **Sinh viên MIT** đang phát triển các công cụ AI để linh hoạt và trung thực hơn. [Khám phá thêm](https://news.mit.edu/topic/artificial-intelligence2).
Để biết thêm tin tức, hãy xem [TechCrunch](https://techcrunch.com/category/artificial-intelligence/) và [blog AI của Google](https://blog.google/technology/ai/google-ai-updates-october-2025/).
Ở đây công cụ web_search được sử dụng.
Đây là luồng hoàn chỉnh ở định dạng Markdown:
┌─────────────────────────────────────────────────────────────┐
│ ĐẦU VÀO TỪ NGƯỜI DÙNG │
│ "Thời tiết ở Mumbai thế nào?" │
└──────────────────────┬──────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ LANGGRAPH AGENT │
│ ┌───────────────┐ ┌───────────────┐ │
│ │ Node Định tuyến │───────▶│ Node Phản hồi │ │
│ └───────┬───────┘ └───────────────┘ │
│ │ │
│ │ Sử dụng OpenAI để xác định: │
│ │ - Công cụ nào sẽ sử dụng │
│ │ - Trích xuất tham số │
└──────────┼──────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ MCP CLIENT │
│ - Quản lý kết nối đến MCP server │
│ - Gửi yêu cầu JSON-RPC │
│ - Nhận và xử lý phản hồi │
└──────────────────────┬──────────────────────────────────────┘
│
│ JSON-RPC qua STDIO
│
▼
┌─────────────────────────────────────────────────────────────┐
│ MCP SERVER │
│ ┌───────────────┐ ┌───────────────┐ │
│ │ Công cụ │ │ Công cụ │ │
│ │ get_weather │ │ web_search │ │
│ └───────────────┘ └───────────────┘ │
│ │
│ Được xây dựng với framework FastMCP │
└──────────────────────┬──────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ CÁC API BÊN NGOÀI │
│ • wttr.in (API Thời tiết) │
│ • Serper API (Tìm kiếm Web) │
└─────────────────────────────────────────────────────────────┘
Kết luận:
Trong hướng dẫn này, chúng ta đã xây dựng một MCP server đa công cụ có thể xử lý cả việc tra cứu thời tiết thời gian thực và tìm kiếm web được hỗ trợ bởi AI. Sử dụng FastMCP, chúng ta đã tạo ra các công cụ mô-đun, có thể tái sử dụng với việc xác thực đầu vào rõ ràng thông qua Pydantic và xử lý lỗi mạnh mẽ.
Thiết lập này cho thấy bạn có thể dễ dàng cung cấp các chức năng thực tế như API hoặc tìm kiếm web cho LLM hoặc các AI agent khác. Bằng cách tách biệt các mối quan tâm thành các công cụ riêng biệt, bạn sẽ có được:
- Khả năng mở rộng: thêm nhiều công cụ hơn mà không ảnh hưởng đến các công cụ hiện có.
- An toàn: đầu vào có cấu trúc ngăn chặn các yêu cầu không hợp lệ.
- Linh hoạt: chuyển đổi API hoặc nguồn dữ liệu mà không cần thay đổi giao diện.
Dù bạn đang xây dựng trợ lý AI, chatbot hay agent nghiên cứu, mô hình này cho phép bạn kết hợp nhiều khả năng vào một server duy nhất, dễ bảo trì.
Bước tiếp theo? Mở rộng MCP server của bạn với các công cụ bổ sung như chuyển đổi tiền tệ, tóm tắt văn bản, hoặc phân tích cảm xúc và xem hệ sinh thái AI của bạn phát triển thông minh và linh hoạt hơn.
Theo dõi trên X