Posted inAI

Làm chủ Giao thức Ngữ cảnh Mô hình (MCP): Nâng cao năng lực AI với các công cụ bên ngoài

AI tutorial - IT technology blog
AI tutorial - IT technology blog

Bạn có thể đã trải nghiệm sự phấn khích khi xây dựng một ứng dụng AI, có thể là một chatbot hữu ích hoặc một trình tạo nội dung tự động. Nhưng chẳng mấy chốc, bạn có thể gặp phải một trở ngại phổ biến: AI của bạn hoạt động trong một môi trường khép kín.

Nó không thể tìm nạp dữ liệu thời gian thực, thực thi các hành động trong các hệ thống khác hoặc tương tác với vô số dịch vụ bên ngoài mà chúng ta sử dụng hàng ngày. Đây chính là lúc khái niệm mà tôi gọi là Giao thức Ngữ cảnh Mô hình (MCP) trở nên thiết yếu. Đây là khuôn khổ cho phép các mô hình AI của bạn vượt ra ngoài vùng hoạt động ngôn ngữ của chúng và tương tác một cách có ý nghĩa với thế giới thực.

Hãy coi MCP như một phương pháp tiêu chuẩn hóa. Nó cho phép AI của bạn hiểu, quyết định thời điểm sử dụng và sau đó diễn giải kết quả từ các hàm hoặc API bên ngoài. Mặc dù các nhà cung cấp AI khác nhau có thể sử dụng các thuật ngữ như ‘gọi hàm’ (function calling) hoặc ‘sử dụng công cụ’ (tool use), nhưng nguyên tắc cốt lõi vẫn nhất quán: cung cấp cho mô hình mô tả có cấu trúc về các công cụ có sẵn và một lớp điều phối để thực thi chúng.

Khởi đầu nhanh: Kết nối AI của bạn với một công cụ đơn giản (5 phút)

Để minh họa, hãy xem xét một ví dụ thực tế. Hãy tưởng tượng chúng ta muốn AI của mình tìm nạp thời tiết hiện tại cho bất kỳ thành phố nào. Một Mô hình Ngôn ngữ Lớn (LLM) một mình không thể làm điều này, nhưng nó có thể học cách yêu cầu thông tin này nếu chúng ta cung cấp ‘công cụ’ phù hợp.

Định nghĩa một công cụ đơn giản

Đầu tiên, chúng ta định nghĩa công cụ bên ngoài của mình. Điều này thường được biểu thị dưới dạng một hàm với mô tả và các tham số rõ ràng, thường sử dụng một lược đồ như JSON Schema. Dưới đây là một ví dụ về công cụ truy xuất thời tiết:


# tool_definitions.py
# Định nghĩa các công cụ

def get_current_weather(location: str, unit: str = "celsius") -> dict:
    """
    Tìm nạp thời tiết hiện tại cho một địa điểm cụ thể.

    Args:
        location (str): Thành phố và bang/quốc gia, ví dụ: "San Francisco, CA" hoặc "Paris, France".
        unit (str, optional): Đơn vị nhiệt độ, có thể là "celsius" hoặc "fahrenheit". Mặc định là "celsius".

    Returns:
        dict: Một từ điển chứa thông tin thời tiết (nhiệt độ, điều kiện, v.v.).
    """
    # Trong một ứng dụng thực tế, điều này sẽ kết nối với một API thời tiết bên ngoài như OpenWeatherMap hoặc AccuWeather.
    # Đối với phần khởi đầu nhanh này, chúng ta sẽ trả về một phản hồi giả.
    if "london" in location.lower():
        return {"location": location, "temperature": "10 C", "conditions": "Cloudy"}
    elif "new york" in location.lower():
        return {"location": new_york, "temperature": "50 F", "conditions": "Partly Cloudy"}
    else:
        # Phản hồi mặc định cho các địa điểm không được xử lý để đảm bảo hành vi có thể dự đoán được.
        return {"location": location, "temperature": "N/A", "conditions": "Unknown"}

# Đây là định nghĩa có cấu trúc mà chúng ta sẽ gửi tới LLM.
# Nó mô tả mục đích của công cụ và các đầu vào bắt buộc của nó.
weather_tool_schema = {
    "name": "get_current_weather",
    "description": "Lấy thời tiết hiện tại ở một địa điểm nhất định",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "Thành phố và bang, ví dụ San Francisco, CA",
            },
            "unit": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Đơn vị nhiệt độ",
            },
        },
        "required": ["location"],
    },
}

Tích hợp với một LLM cơ bản

Bây giờ, hãy cùng khám phá cách một LLM có thể được nhắc để sử dụng công cụ này. Ví dụ này giả định một API LLM giả định hỗ trợ tool calls. Ý tưởng cơ bản là cung cấp cho LLM lời nhắc của người dùng và các lược đồ của tất cả các công cụ có sẵn. Nếu mô hình xác định rằng cần có một công cụ, nó sẽ trả về một đối tượng ‘tool call’ thay vì phản hồi văn bản trực tiếp.


# ai_orchestrator.py
# Bộ điều phối AI
import json
from tool_definitions import get_current_weather, weather_tool_schema

# Tương tác LLM giả: Trong một hệ thống sản xuất, đây sẽ là một cuộc gọi API thực tế đến một nhà cung cấp như OpenAI, Anthropic hoặc Google Gemini.
class MockLLM:
    def predict_with_tools(self, user_prompt: str, tools: list):
        print(f"LLM đã nhận lời nhắc: '{user_prompt}' và các công cụ: {json.dumps(tools)}")
        # Mô phỏng quá trình ra quyết định của LLM dựa trên lời nhắc.
        if "weather" in user_prompt.lower() and "london" in user_prompt.lower():
            return {
                "tool_calls": [
                    {
                        "name": "get_current_weather",
                        "arguments": {"location": "London, UK", "unit": "celsius"}
                    }
                ]
            }
        elif "weather" in user_prompt.lower() and "new york" in user_prompt.lower():
             return {
                "tool_calls": [
                    {
                        "name": "get_current_weather",
                        "arguments": {"location": "New York, USA", "unit": "fahrenheit"}
                    }
                ]
            }
        else:
            # Nếu không cần công cụ nào, LLM sẽ cung cấp phản hồi văn bản trực tiếp.
            return {"text_response": "Hiện tại tôi không thể giúp về việc đó."}

llm = MockLLM()

# Vòng lặp điều phối chính: Thành phần này quản lý sự tương tác giữa người dùng, LLM và các công cụ bên ngoài.
def process_user_query(query: str):
    response = llm.predict_with_tools(query, [weather_tool_schema]) # Gửi truy vấn và các lược đồ công cụ có sẵn.

    if "tool_calls" in response:
        for tool_call in response["tool_calls"]:
            tool_name = tool_call["name"]
            tool_args = tool_call["arguments"]
            print(f"AI muốn gọi công cụ: {tool_name} với các đối số: {tool_args}")

            # Thực thi công cụ. Đây là nơi 'Giao thức Ngữ cảnh Mô hình' được kích hoạt.
            if tool_name == "get_current_weather":
                tool_result = get_current_weather(**tool_args)
                print(f"Kết quả công cụ: {tool_result}")
                
                # Đưa kết quả công cụ trở lại LLM để tạo phản hồi thân thiện với người dùng.
                # Trong một API thực tế, điều này thường liên quan đến một cuộc gọi LLM khác với đầu ra của công cụ làm ngữ cảnh.
                print(f"LLM sẽ tổng hợp: 'Thời tiết ở {tool_result['location']} là {tool_result['temperature']} và {tool_result['conditions']}.'")
            else:
                print(f"Công cụ không xác định: {tool_name}") # Xử lý các trường hợp trả về tên công cụ không mong muốn.
    else:
        print(f"Phản hồi của AI: {response['text_response']}")

# Các trường hợp thử nghiệm để thể hiện khả năng sử dụng công cụ của AI.
process_user_query("Thời tiết ở London như thế nào?")
process_user_query("Hãy cho tôi biết thời tiết ở New York.")
process_user_query("Kể cho tôi một câu chuyện cười.")
```

<pre><code class="language-bash">
# Đầu ra dự kiến khi chạy script Python trên:
# LLM đã nhận lời nhắc: 'Thời tiết ở London như thế nào?' và các công cụ: [{...}]
# AI muốn gọi công cụ: get_current_weather với các đối số: {'location': 'London, UK', 'unit': 'celsius'}
# Kết quả công cụ: {'location': 'London, UK', 'temperature': '10 C', 'conditions': 'Cloudy'}
# LLM sẽ tổng hợp: 'Thời tiết ở London, UK là 10 C và Cloudy.'
# LLM đã nhận lời nhắc: 'Hãy cho tôi biết thời tiết ở New York.' và các công cụ: [{...}]
# AI muốn gọi công cụ: get_current_weather với các đối số: {'location': 'New York, USA', 'unit': 'fahrenheit'}
# Kết quả công cụ: {'location': 'New York, USA', 'temperature': '50 F', 'conditions': 'Partly Cloudy'}
# LLM sẽ tổng hợp: 'Thời tiết ở New York, USA là 50 F và Partly Cloudy.'
# LLM đã nhận lời nhắc: 'Kể cho tôi một câu chuyện cười.' và các công cụ: [{...}]
# Phản hồi của AI: Hiện tại tôi không thể giúp về việc đó.

Đi sâu: Tìm hiểu Giao thức Ngữ cảnh Mô hình

Về cốt lõi, MCP giải quyết một hạn chế cơ bản của các mô hình ngôn ngữ lớn: chúng được huấn luyện trên các tập dữ liệu khổng lồ và xuất sắc trong việc tạo văn bản giống con người. Tuy nhiên, chúng vốn thiếu quyền truy cập thời gian thực vào internet, cơ sở dữ liệu hoặc khả năng thực hiện các hành động vật lý. Chúng không ‘biết’ thời tiết hiện tại, không thể đặt vé máy bay hoặc cập nhật hồ sơ quản lý quan hệ khách hàng (CRM). MCP đã bắc cầu hiệu quả cho khoảng cách này.

Giao thức thường bao gồm ba giai đoạn chính, tạo thành một vòng lặp tương tác liên tục:

  1. Mô tả Công cụ & Ngữ cảnh Mô hình: Bạn trang bị cho mô hình AI một danh sách các công cụ có sẵn. Mỗi công cụ bao gồm mô tả rõ ràng, súc tích bằng ngôn ngữ tự nhiên về chức năng của nó và một lược đồ có cấu trúc (như JSON Schema) định nghĩa các tham số đầu vào của nó. Mô hình sau đó tích hợp các mô tả này vào ngữ cảnh hoạt động của nó.
  2. Quyết định của Mô hình & Tạo lệnh gọi công cụ: Khi người dùng gửi một truy vấn, mô hình AI sẽ xử lý nó. Nếu nó xác định rằng một hành động bên ngoài là cần thiết để hoàn thành yêu cầu, nó sẽ không tạo ra phản hồi văn bản trực tiếp. Thay vào đó, nó sẽ tạo ra một đối tượng ‘tool call’. Đối tượng này chỉ định chính xác công cụ nào cần sử dụng và các đối số chính xác cần truyền cho công cụ đó, dựa trên sự hiểu biết của mô hình về ý định của người dùng và khả năng của công cụ.
  3. Điều phối & Tích hợp kết quả: Ứng dụng của bạn, hoạt động như ‘bộ điều phối’, chặn lệnh gọi công cụ này. Sau đó, nó thực thi công cụ được chỉ định với các đối số được cung cấp. Khi công cụ trả về một kết quả (thường được định dạng thành dạng văn bản), thông tin mới này sẽ được đưa trở lại mô hình AI. Mô hình sau đó tận dụng ngữ cảnh này để tạo ra một phản hồi cuối cùng, mạch lạc và hữu ích cho người dùng.

Chu trình năng động này làm cho các ứng dụng AI thực sự mạnh mẽ và dễ thích nghi. Theo kinh nghiệm của tôi, việc làm chủ giao thức này là rất quan trọng để chuyển đổi từ các khái niệm AI lý thuyết sang xây dựng các hệ thống thực tế, sẵn sàng sản xuất. Không có MCP, AI của bạn vẫn chủ yếu là một cơ sở kiến thức tĩnh; với nó, AI của bạn biến thành một tác nhân tích cực có khả năng tương tác với toàn bộ hệ sinh thái kỹ thuật số.

Sử dụng nâng cao: Điều phối các quy trình làm việc phức tạp

Khi bạn đã nắm vững các nguyên tắc cơ bản, MCP có thể được mở rộng để quản lý các tình huống phức tạp hơn nhiều, cho phép các tác nhân AI giải quyết các vấn đề nhiều bước một cách hiệu quả.

Xâu chuỗi công cụ và logic điều kiện

Thông thường, một yêu cầu duy nhất của người dùng đòi hỏi nhiều hơn một lệnh gọi công cụ. Ví dụ, để lập kế hoạch cho một chuyến đi nhiều chặng, AI của bạn có thể cần một công cụ để tìm các chuyến bay có sẵn. Sau đó, nó có thể sử dụng một công cụ khác để tìm kiếm các lựa chọn khách sạn dựa trên ngày bay đó. Cuối cùng, nó có thể sử dụng một công cụ thứ ba để ước tính tổng chi phí đi lại. Quá trình này liên quan đến các lệnh gọi công cụ tuần tự, trong đó đầu ra của một công cụ đóng vai trò là đầu vào cho công cụ tiếp theo.


# Ví dụ về một công cụ để lấy thông tin chuyến bay (được đơn giản hóa để minh họa)
flight_search_tool_schema = {
    "name": "find_flights",
    "description": "Tìm các chuyến bay có sẵn giữa điểm xuất phát và điểm đến vào một ngày cụ thể.",
    "parameters": {
        "type": "object",
        "properties": {
            "origin": {"type": "string", "description": "Mã sân bay khởi hành, ví dụ: 'NYC'"},
            "destination": {"type": "string", "description": "Mã sân bay đến, ví dụ: 'LAX'"},
            "date": {"type": "string", "format": "date", "description": "Ngày di chuyển ở định dạng YYYY-MM-DD"}
        },
        "required": ["origin", "destination", "date"]
    }
}

def find_flights(origin: str, destination: str, date: str) -> dict:
    # Dữ liệu chuyến bay giả. Trong một kịch bản thực tế, điều này sẽ truy vấn một API đặt vé máy bay như Skyscanner hoặc Google Flights.
    if origin == "NYC" and destination == "LAX" and date == "2024-07-20":
        return {"flights": [{"flight_number": "AA123", "price": "$300"}]}
    return {"flights": []}

# Bộ điều phối thể hiện logic xâu chuỗi: kết hợp tìm kiếm thời tiết và chuyến bay.
def process_travel_query(query: str):
    # Đầu tiên, LLM xác định xem có cần tìm kiếm chuyến bay hay không.
    response1 = llm.predict_with_tools(query, [flight_search_tool_schema, weather_tool_schema]) # Truyền tất cả các công cụ liên quan.

    if "tool_calls" in response1:
        flight_call = response1["tool_calls"][0] # Giả sử chỉ có một lệnh gọi công cụ cho bước này.
        if flight_call["name"] == "find_flights":
            flight_result = find_flights(**flight_call["arguments"])
            print(f"Kết quả công cụ chuyến bay: {flight_result}")

            if flight_result["flights"]:
                # Nếu tìm thấy chuyến bay, hệ thống sẽ hỏi LLM về thời tiết tại điểm đến.
                destination_city = flight_call['arguments']['destination'] # Trích xuất điểm đến từ đối số chuyến bay.
                travel_date = flight_call['arguments']['date']
                weather_query = f"Thời tiết ở {destination_city} vào ngày {travel_date} như thế nào?"
                
                response2 = llm.predict_with_tools(weather_query, [weather_tool_schema]) # Lệnh gọi LLM thứ hai cho thời tiết.
                if "tool_calls" in response2:
                    weather_call = response2["tool_calls"][0]
                    if weather_call["name"] == "get_current_weather":
                        weather_result = get_current_weather(**weather_call["arguments"])
                        print(f"Kết quả công cụ thời tiết: {weather_result}")
                        print(f"LLM sẽ tổng hợp: Các chuyến bay từ {flight_call['arguments']['origin']} đến {flight_call['arguments']['destination']} vào ngày {travel_date}: {flight_result['flights'][0]['flight_number']} với giá {flight_result['flights'][0]['price']}. Thời tiết sẽ là {weather_result['conditions']}.")
            else:
                print("Không tìm thấy chuyến bay nào cho truy vấn của bạn.")
    else:
        print("LLM không xác định được công cụ tìm kiếm chuyến bay cho truy vấn này.")

# Ví dụ sử dụng: Bỏ ghi chú để kiểm tra truy vấn nâng cao cụ thể này.
# process_travel_query("Tìm chuyến bay từ NYC đến LAX vào ngày 20 tháng 7 năm 2024 và cho tôi biết thời tiết ở đó.")

Logic điều kiện cũng rất quan trọng. Ví dụ, nếu có chuyến bay, hệ thống có thể tiếp tục kiểm tra giá khách sạn; nếu không, nó sẽ thông báo cho người dùng về việc không có sẵn. Điều này đòi hỏi quản lý trạng thái tỉ mỉ trong lớp điều phối của bạn.

Xử lý lỗi và khả năng phục hồi

Các công cụ bên ngoài, giống như bất kỳ thành phần phần mềm nào, có thể gặp sự cố. API có thể tạm thời ngoại tuyến, giới hạn tốc độ có thể bị vượt quá hoặc các tham số không chính xác có thể được cung cấp. Một triển khai MCP mạnh mẽ phải bao gồm:

  • Xác thực đầu vào: Trước khi gọi một công cụ, hãy xác thực nghiêm ngặt các đối số do LLM cung cấp so với lược đồ được định nghĩa của công cụ. Điều này ngăn chặn các yêu cầu bị lỗi định dạng tiếp cận các hệ thống bên ngoài.
  • Thử lại với khoảng thời gian chờ tăng dần: Triển khai các cơ chế để thử lại các lỗi API tạm thời, chờ đợi các khoảng thời gian ngày càng dài giữa các lần thử. Điều này giúp khắc phục các trục trặc mạng tạm thời hoặc gián đoạn dịch vụ.
  • Cơ chế dự phòng: Nếu một công cụ chính bị lỗi liên tục, bạn có thể chuyển sang một công cụ thay thế một cách duyên dáng không? Hoặc, ít nhất, AI có thể cung cấp một thông báo dự phòng hữu ích, lịch sự cho người dùng không?
  • Thời gian chờ: Cấu hình thời gian chờ thích hợp cho các lệnh gọi bên ngoài. Điều này ngăn ứng dụng của bạn bị treo vô thời hạn nếu một dịch vụ bên ngoài không phản hồi.

Lệnh gọi công cụ không đồng bộ

Một số công cụ, chẳng hạn như các công việc xử lý dữ liệu chạy dài hoặc các lệnh gọi API phức tạp, có thể mất một khoảng thời gian đáng kể để hoàn thành. Đối với những trường hợp này, hãy xem xét thực thi không đồng bộ. Bộ điều phối của bạn có thể khởi tạo lệnh gọi công cụ, ngay lập tức thông báo cho người dùng rằng quá trình đã bắt đầu và sau đó xử lý kết quả khi nó có sẵn, có thể thông qua webhook, hàng đợi tin nhắn hoặc cơ chế thăm dò.

Mẹo thực tế để triển khai MCP hiệu quả

Triển khai MCP một cách chu đáo có thể nâng cao đáng kể khả năng của các ứng dụng AI của bạn. Dưới đây là một số chiến lược đã được chứng minh:

Định nghĩa công cụ rõ ràng là tối quan trọng

Hiệu quả sử dụng công cụ của AI của bạn tương quan trực tiếp với chất lượng mô tả công cụ của bạn. Đảm bảo bạn cung cấp:

  • Tên chính xác: Chọn tên mô tả. Ví dụ, get_weather_forecast cung cấp nhiều thông tin hơn weather_function.
  • Mô tả chi tiết: Giải thích rõ ràng công cụ làm gì, cách thức hoạt động và quan trọng nhất là khi nào nên gọi nó. Sự rõ ràng này rất quan trọng để LLM đưa ra các quyết định chính xác.
  • Lược đồ chính xác: Đảm bảo rằng tên tham số, kiểu dữ liệu và mô tả là chính xác và không mơ hồ. Nếu một tham số chấp nhận một tập hợp các giá trị giới hạn (một enum), hãy chỉ định rõ ràng các tùy chọn này trong lược đồ.

Giám sát và ghi nhật ký toàn diện

Để thực sự hiểu và gỡ lỗi quá trình ra quyết định của AI, khả năng quan sát mạnh mẽ là điều cần thiết. Ghi nhật ký các tương tác quan trọng sau:

  • Các truy vấn của người dùng đã nhận được.
  • Các lệnh gọi công cụ được tạo bởi LLM, bao gồm tên công cụ cụ thể và các đối số của nó.
  • Kết quả được trả về bởi các công cụ bên ngoài.
  • Các phản hồi cuối cùng của AI được gửi đến người dùng.

Việc ghi nhật ký chi tiết này cung cấp thông tin chi tiết vô giá để gỡ lỗi, hiểu ý định người dùng tinh tế và liên tục tinh chỉnh các định nghĩa công cụ và logic điều phối của bạn.

Các cân nhắc về bảo mật: Ưu tiên hàng đầu

Khi kết nối AI với các hệ thống bên ngoài, bảo mật không bao giờ được là một suy nghĩ thứ cấp. Triển khai các phương pháp hay nhất này:

  • Quản lý khóa API: Không bao giờ nhúng khóa API trực tiếp vào mã của bạn. Thay vào đó, hãy sử dụng các biến môi trường an toàn, các dịch vụ quản lý bí mật chuyên dụng (ví dụ: AWS Secrets Manager, HashiCorp Vault) hoặc các giải pháp quản lý khóa đám mây.
  • Nguyên tắc đặc quyền tối thiểu: Đảm bảo các công cụ của bạn và các dịch vụ mà chúng truy cập chỉ có các quyền tối thiểu tuyệt đối cần thiết để thực hiện chức năng dự định của chúng.
  • Xử lý đầu vào: Luôn xử lý và xác thực nghiêm ngặt các đầu vào nhận được từ LLM trước khi chuyển chúng đến các hệ thống bên ngoài. Đây là một biện pháp phòng thủ quan trọng chống lại các cuộc tấn công injection và ngăn chặn hành vi không mong muốn hoặc độc hại.
  • Giới hạn tốc độ: Triển khai giới hạn tốc độ mạnh mẽ cho các lệnh gọi dịch vụ bên ngoài của bạn. Điều này bảo vệ API của bạn khỏi bị quá tải bởi các yêu cầu quá mức, dù là ngẫu nhiên (do lỗi) hay độc hại (một cuộc tấn công từ chối dịch vụ).

Phát triển lặp đi lặp lại: Bắt đầu nhỏ, phát triển thông minh

Áp dụng một cách tiếp cận lặp đi lặp lại. Bắt đầu bằng cách triển khai một hoặc hai công cụ, kiểm tra kỹ lưỡng chúng và cẩn thận quan sát cách AI của bạn tương tác với chúng. Khi sự tự tin và hiểu biết của bạn tăng lên, hãy dần dần giới thiệu thêm sự phức tạp và các công cụ bổ sung. Tránh cái bẫy cố gắng xây dựng một tác nhân phổ quát với hàng tá công cụ ngay từ ngày đầu tiên.

Chọn nhà cung cấp LLM phù hợp

Các nhà cung cấp LLM khác nhau (ví dụ: OpenAI, Anthropic, Google) cung cấp các mức độ tinh vi khác nhau và các giao diện hơi khác nhau để sử dụng công cụ (thường được gọi là ‘function calling’). Hãy làm quen với tài liệu và khả năng cụ thể của họ. Mặc dù khái niệm MCP cốt lõi vẫn nhất quán, nhưng các chi tiết triển khai chính xác sẽ thay đổi tự nhiên trên các nền tảng.

Làm chủ Giao thức Ngữ cảnh Mô hình biến AI của bạn từ một đối tác trò chuyện đơn thuần thành một người tham gia tích cực, có khả năng thực hiện các tác vụ trong thế giới thực. Đây là cơ chế mở khóa tiềm năng thực sự của tự động hóa AI và các tác nhân thông minh, chứng tỏ giá trị vô cùng lớn trong mọi thứ từ nâng cao dịch vụ khách hàng đến tối ưu hóa quy trình làm việc DevOps và hơn thế nữa.

Share:
Tags: