MCP-Server für Entwicklerwissen in benutzerdefinierte KI-Agenten einbinden

In dieser Anleitung erfahren Sie, wie Sie den Remote-MCP-Server für Entwicklerwissen mit benutzerdefinierten KI-Agent-Frameworks verbinden, die mit LangChain, LlamaIndex und AutoGen erstellt wurden.

Wenn Sie Ihre benutzerdefinierten KI-Agenten mit dem Remote-MCP-Server (Model Context Protocol) verbinden, können Ihre Agenten dynamisch nach maßgeblicher, aktueller Google-Entwicklerdokumentation zu Google Cloud, Firebase, Android, der Google Maps Platform, Chrome und mehr suchen und diese abrufen.

Vorbereitung

Erfüllen Sie die folgenden Voraussetzungen, bevor Sie beginnen:

  1. Developer Knowledge API-Schlüssel generieren: Aktivieren Sie die Developer Knowledge API und erstellen Sie einen API-Schlüssel in Ihrem Google Cloud-Projekt. Folgen Sie dazu der Anleitung zum Einrichten von API-Schlüsseln.
  2. Gemini API-Schlüssel generieren: Erstellen Sie in Google AI Studio einen API-Schlüssel, um Gemini-Modelle zu authentifizieren. Sie können auch Ihren Google Cloud API-Schlüssel wiederverwenden, wenn die Generative Language API darauf aktiviert ist.

  3. Umgebungsvariablen festlegen: Legen Sie Ihre API-Schlüssel als Umgebungsvariablen in Ihrem Terminal fest:

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

  4. Python installieren: Prüfen Sie, ob in Ihrer Entwicklungsumgebung Python 3.10 oder höher verwendet wird.

Über LangChain verbinden

LangChain-Anwendungen können über das langchain-mcp-adapters-Paket oder standardmäßige MCP-Clienttransporte eine Verbindung zu Remote-HTTP-MCP-Servern herstellen.

Abhängigkeiten installieren

Installieren Sie die erforderlichen Python-Pakete für LangChain, Gemini und MCP:

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

LangChain-Agenten konfigurieren

Im folgenden Beispiel wird der MCP-Server für Entwicklerwissen mit einem LangChain ReAct-Agenten verbunden, der auf Gemini basiert. Das Skript instanziiert MultiServerMCPClient mit dem streamable_http-Transport, fügt den X-Goog-Api-Key-HTTP-Header an und lädt die Remote-Tools in 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())

Verbindung über LlamaIndex herstellen

LlamaIndex unterstützt die MCP-Serverintegration über Tool-Spezifikationen, sodass Retrieval-Agents während der Entscheidungsfindung Developer Knowledge-Dokumente abfragen können.

Abhängigkeiten installieren

Installieren Sie die LlamaIndex-Kernpakete, Gemini LLM und die MCP-Tools-Integration:

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

LlamaIndex-Agent konfigurieren

Im folgenden Beispiel wird eine Verbindung zum Remote-MCP-Server mit BasicMCPClient hergestellt, der Server wird mit McpToolSpec umschlossen und die abgerufenen Tools werden an einen LlamaIndex-FunctionAgent gebunden, der von Gemini unterstützt wird:

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())

Über AutoGen verbinden

Microsoft AutoGen-Agents können über die autogen-ext-MCP-Erweiterung mit Remote-MCP-Servern interagieren. So ist die Zusammenarbeit mehrerer Agents mit Zugriff auf die offizielle Google-Entwicklerdokumentation möglich.

Abhängigkeiten installieren

Installieren Sie die AutoGen-Kern- und MCP-Erweiterungspakete:

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

AutoGen-Agent konfigurieren

Im folgenden Beispiel wird eine Verbindung zum Remote-MCP-Server über StreamableHttpServerParams hergestellt und es werden Developer Knowledge-Tools mit einem AutoGen-AssistantAgent, das auf Gemini basiert, registriert:

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())

Best Practices für die Agent-Integration

Wenn Sie benutzerdefinierte KI-Agents mit dem MCP-Server für Entwicklerwissen erstellen, sollten Sie die folgenden Richtlinien beachten:

  • Suchanfragen optimieren: Geben Sie in der Anfrage in natürlicher Sprache bestimmte Produktnamen und relevante Keywords anstelle von allgemeinen Begriffen an, da die Tools search_documents und answer_query semantische Übereinstimmungen für Anfragen verwenden.
  • Tokens für das Kontextfenster verwalten: Verwenden Sie answer_query für direkte Antworten aus dem Dokumentationskorpus und vermeiden Sie es, mit get_documents vollständige Seiteninhalte anzufordern, es sei denn, die Snippet-Details aus search_documents reichen nicht aus.
  • API-Schlüssel schützen: Speichern Sie Ihre Developer Knowledge API- und Gemini API-Schlüssel in Umgebungsvariablen oder Standard-Secret-Verwaltungssystemen und codieren Sie Anmeldedaten niemals fest im Code.

Nächste Schritte

Weitere Informationen zum MCP-Server für Entwicklerwissen finden Sie in den folgenden Ressourcen: