שילוב של שרת MCP עם ידע למפתחים עם סוכני AI בהתאמה אישית

במדריך הזה נסביר איך לחבר את שרת ה-MCP המרוחק של Developer Knowledge למסגרות מותאמות אישית של סוכני AI שנבנו באמצעות LangChain,‏ LlamaIndex ו-AutoGen.

כשמחברים את סוכני ה-AI המותאמים אישית לשרת Model Context Protocol‏ (MCP) מרוחק, הסוכנים יכולים לחפש באופן דינמי ולאחזר מסמכי תיעוד רשמיים ועדכניים למפתחים של Google בנושאים כמו Google Cloud,‏ Firebase,‏ Android,‏ Google Maps Platform,‏ Chrome ועוד.

דרישות מוקדמות

לפני שמתחילים, צריך לבצע את הפעולות הבאות:

  1. יצירת מפתח Developer Knowledge API: מפעילים את Developer Knowledge API ויוצרים מפתח API בפרויקט Google Cloud באמצעות מדריך ההגדרה של מפתח API.
  2. יצירת מפתח Gemini API: יוצרים מפתח API ב-Google AI Studio כדי לאמת מודלים של Gemini, או משתמשים מחדש במפתח Google Cloud API אם Generative Language API מופעל בו.

  3. הגדרת משתני הסביבה: מגדירים את מפתחות ה-API כמשתני סביבה במסוף:

    export DEVELOPERKNOWLEDGE_API_KEY="YOUR_API_KEY"
export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"

  4. מתקינים את Python: מוודאים שבסביבת הפיתוח נעשה שימוש ב-Python 3.10 ואילך.

חיבור באמצעות LangChain

אפליקציות LangChain יכולות להתחבר לשרתי HTTP MCP מרוחקים באמצעות חבילת langchain-mcp-adapters או באמצעות העברות סטנדרטיות של לקוחות MCP.

התקנת יחסי תלות

מתקינים את חבילות Python הנדרשות ל-LangChain, ל-Gemini ול-MCP:

pip install langgraph langchain-google-genai langchain-mcp-adapters mcp

הגדרת סוכן LangChain

בדוגמה הבאה, שרת ה-MCP של Developer Knowledge מתחבר לסוכן LangChain ReAct שמבוסס על Gemini. הסקריפט יוצר מופע של MultiServerMCPClient באמצעות העברת streamable_http, מצרף את כותרת ה-HTTP‏ X-Goog-Api-Key וטוען את הכלים המרוחקים אל create_react_agent:

import asyncio
import os

from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

async def run_langchain_agent():
    api_key = os.environ.get("DEVELOPERKNOWLEDGE_API_KEY")
    if not api_key:
        raise ValueError(
            "DEVELOPERKNOWLEDGE_API_KEY environment variable is required."
        )

    gemini_api_key = os.environ.get("GEMINI_API_KEY")
    if not gemini_api_key:
        raise ValueError("GEMINI_API_KEY environment variable is required.")

    # Configure remote MCP connection for Developer Knowledge
    client = MultiServerMCPClient(
        {
            "google-developer-knowledge": {
                "url": "https://developerknowledge.googleapis.com/mcp",
                "transport": "streamable_http",
                "headers": {
                    "X-Goog-Api-Key": api_key,
                },
            }
        }
    )
    tools = await client.get_tools()

    # Initialize Gemini model and ReAct agent
    llm = ChatGoogleGenerativeAI(
        model="gemini-2.5-flash",
        temperature=0,
        google_api_key=gemini_api_key,
    )
    agent = create_react_agent(llm, tools)

    # Run agent query
    response = await agent.ainvoke(
        {
            "messages": [
                (
                    "user",
                    "How do I list Google Cloud Storage buckets in Python?",
                )
            ]
        }
    )
    print("\nAgent Response:\n", response["messages"][-1].content)

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

חיבור באמצעות LlamaIndex

‫LlamaIndex תומך בשילוב של שרת MCP באמצעות מפרטי כלים, ומאפשר לסוכני אחזור לשלוח שאילתות למסמכי Developer Knowledge במהלך הנימוק.

התקנת יחסי תלות

מתקינים את חבילות הליבה של LlamaIndex, את Gemini LLM ואת השילוב של כלי MCP:

pip install llama-index llama-index-tools-mcp llama-index-llms-google-genai

הגדרת סוכן LlamaIndex

בדוגמה הבאה מתחברים לשרת MCP מרוחק באמצעות BasicMCPClient, עוטפים אותו ב-McpToolSpec ומקשרים את הכלים שאוחזרו ל-LlamaIndex FunctionAgent שמבוסס על Gemini:

import asyncio
import os

from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.google_genai import GoogleGenAI
from llama_index.tools.mcp import BasicMCPClient, McpToolSpec

async def run_llamaindex_agent():
    api_key = os.environ.get("DEVELOPERKNOWLEDGE_API_KEY")
    if not api_key:
        raise ValueError(
            "DEVELOPERKNOWLEDGE_API_KEY environment variable is required."
        )

    gemini_api_key = os.environ.get("GEMINI_API_KEY")
    if not gemini_api_key:
        raise ValueError("GEMINI_API_KEY environment variable is required.")

    # Connect to the remote Developer Knowledge MCP endpoint
    mcp_client = BasicMCPClient(
        "https://developerknowledge.googleapis.com/mcp",
        headers={"X-Goog-Api-Key": api_key},
    )
    mcp_tool_spec = McpToolSpec(client=mcp_client)
    tools = await mcp_tool_spec.to_tool_list_async()

    # Create LlamaIndex FunctionAgent with Gemini
    llm = GoogleGenAI(model="gemini-2.5-flash", api_key=gemini_api_key)
    agent = FunctionAgent(tools=tools, llm=llm)

    # Query the agent
    response = await agent.run(
        "What are the default limits and quotas for the Developer Knowledge"
        " API?"
    )
    print("\nAgent Response:\n", str(response))

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

חיבור באמצעות AutoGen

סוכני Microsoft AutoGen יכולים ליצור אינטראקציה עם שרתי MCP מרוחקים באמצעות התוסף autogen-ext MCP, וכך לאפשר שיתוף פעולה בין כמה סוכנים עם גישה לתיעוד הרשמי למפתחים של Google.

התקנת יחסי תלות

מתקינים את חבילות הליבה של AutoGen ואת התוסף MCP:

pip install autogen-agentchat "autogen-ext[mcp,openai]"

הגדרת סוכן AutoGen

בדוגמה הבאה מתחברים לשרת MCP מרוחק באמצעות StreamableHttpServerParams ורושמים כלי ידע למפתחים באמצעות AutoGen AssistantAgent שמבוסס על Gemini:

import asyncio
import os

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import StreamableHttpServerParams, mcp_server_tools

async def run_autogen_agent():
    api_key = os.environ.get("DEVELOPERKNOWLEDGE_API_KEY")
    if not api_key:
        raise ValueError(
            "DEVELOPERKNOWLEDGE_API_KEY environment variable is required."
        )

    gemini_api_key = os.environ.get("GEMINI_API_KEY")
    if not gemini_api_key:
        raise ValueError("GEMINI_API_KEY environment variable is required.")

    # Retrieve remote MCP tools for Developer Knowledge by using Streamable HTTP
    server_params = StreamableHttpServerParams(
        url="https://developerknowledge.googleapis.com/mcp",
        headers={"X-Goog-Api-Key": api_key},
    )
    dk_tools = await mcp_server_tools(server_params)

    # Initialize model client with Gemini and assistant agent
    model_client = OpenAIChatCompletionClient(
        model="gemini-2.5-flash",
        api_key=gemini_api_key,
        base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
    )
    developer_assistant = AssistantAgent(
        name="google_docs_assistant",
        model_client=model_client,
        tools=dk_tools,
        system_message=(
            "You are a developer assistant specializing in Google APIs and"
            " SDKs. Use Developer Knowledge tools to retrieve verified"
            " documentation."
        ),
    )

    # Run query with team runner
    team = RoundRobinGroupChat([developer_assistant], max_turns=5)
    stream = team.run_stream(
        task=(
            "Explain how to configure Firebase Cloud Messaging topic"
            " subscriptions."
        )
    )

    async for message in stream:
        print(message)

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

שיטות מומלצות לשילוב סוכנים

כשיוצרים סוכני AI בהתאמה אישית באמצעות שרת ה-MCP של Developer Knowledge, חשוב לפעול לפי ההנחיות הבאות:

  • מחדדים את שאילתות החיפוש: כוללים בשאילתת השפה הטבעית שמות מוצרים ספציפיים ומילות מפתח רלוונטיות במקום מונחים כלליים, כי הכלים search_documents ו-answer_query מתאימים לשאילתות סמנטיות.
  • ניהול טוקנים של חלון ההקשר: כדאי להשתמש ב-answer_query כדי לקבל תשובות ישירות שמבוססות על מאגר התיעוד, ולא לבקש את התוכן המלא של הדף באמצעות get_documents, אלא אם פרטי התקציר מ-search_documents לא מספיקים.
  • אבטחת מפתחות API: אחסנו את מפתחות ה-API של Developer Knowledge ו-Gemini במשתני סביבה או במערכות סטנדרטיות לניהול סודות, ואל תקודדו אישורים בקוד.

המאמרים הבאים

כדי לקבל מידע נוסף על שרת ה-MCP של Developer Knowledge, אפשר לעיין במקורות המידע הבאים: