Intégrer le serveur MCP Developer Knowledge avec des agents IA personnalisés

Ce tutoriel vous explique comment connecter le serveur MCP Developer Knowledge distant à des frameworks d'agents d'IA personnalisés créés avec LangChain, LlamaIndex et AutoGen.

En connectant vos agents IA personnalisés au serveur MCP (Model Context Protocol) distant, vos agents peuvent rechercher et récupérer de manière dynamique la documentation Google pour les développeurs faisant autorité et à jour sur Google Cloud, Firebase, Android, Google Maps Platform, Chrome et plus encore.

Prérequis

Avant de commencer, assurez-vous de remplir les conditions préalables suivantes :

  1. Générez une clé API Developer Knowledge : activez l'API Developer Knowledge et créez une clé API dans votre projet Google Cloud en suivant le guide de configuration des clés API.
  2. Générez une clé API Gemini : créez une clé API dans Google AI Studio pour authentifier les modèles Gemini, ou réutilisez votre clé API Google Cloud si l'API Generative Language y est activée.

  3. Définissez vos variables d'environnement : définissez vos clés API en tant que variables d'environnement dans votre terminal :

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

  4. Installez Python : vérifiez que votre environnement de développement utilise Python 3.10 ou version ultérieure.

Se connecter à l'aide de LangChain

Les applications LangChain peuvent se connecter à des serveurs MCP HTTP distants à l'aide du package langchain-mcp-adapters ou des transports clients MCP standards.

Installer des dépendances

Installez les packages Python requis pour LangChain, Gemini et MCP :

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

Configurer l'agent LangChain

L'exemple suivant connecte le serveur MCP Developer Knowledge à un agent LangChain ReAct optimisé par Gemini. Le script instancie MultiServerMCPClient à l'aide du transport streamable_http, associe l'en-tête HTTP X-Goog-Api-Key et charge les outils distants dans 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())

Se connecter à l'aide de LlamaIndex

LlamaIndex est compatible avec l'intégration du serveur MCP via les spécifications d'outils, ce qui permet aux agents de récupération d'interroger les documents Developer Knowledge lors du raisonnement.

Installer des dépendances

Installez les packages LlamaIndex Core, Gemini LLM et l'intégration des outils MCP :

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

Configurer l'agent LlamaIndex

L'exemple suivant se connecte au serveur MCP distant à l'aide de BasicMCPClient, l'encapsule avec McpToolSpec et lie les outils récupérés à un FunctionAgent LlamaIndex optimisé par 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())

Se connecter à l'aide d'AutoGen

Les agents Microsoft AutoGen peuvent interagir avec des serveurs MCP distants à l'aide de l'extension MCP autogen-ext, ce qui permet une collaboration multi-agents avec accès à la documentation officielle pour les développeurs Google.

Installer des dépendances

Installez les packages principaux AutoGen et d'extension MCP :

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

Configurer l'agent AutoGen

L'exemple suivant se connecte au serveur MCP distant à l'aide de StreamableHttpServerParams et enregistre les outils Developer Knowledge avec un AutoGen AssistantAgent optimisé par 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())

Bonnes pratiques pour l'intégration d'agents

Lorsque vous créez des agents d'IA personnalisés avec le serveur MCP Developer Knowledge, suivez ces consignes :

  • Affinez vos requêtes de recherche : incluez des noms de produits spécifiques et des mots clés pertinents dans la requête en langage naturel plutôt que des termes génériques, car les outils search_documents et answer_query correspondent à la sémantique des requêtes.
  • Gérez les jetons de la fenêtre de contexte : utilisez answer_query pour obtenir des réponses directes issues du corpus de documentation et évitez de demander le contenu complet d'une page avec get_documents, sauf si les détails de l'extrait de search_documents sont insuffisants.
  • Sécurisez vos clés API : stockez vos clés API Developer Knowledge et Gemini dans des variables d'environnement ou des systèmes de gestion des secrets standards, et ne codez jamais en dur les identifiants dans le code.

Étape suivante

Pour en savoir plus sur le serveur MCP Developer Knowledge, consultez les ressources suivantes :