Integrare il server MCP per Developer Knowledge con agenti AI personalizzati

Questo tutorial mostra come connettere il server MCP Developer Knowledge remoto a framework di agenti AI personalizzati creati con LangChain, LlamaIndex e AutoGen.

Se connetti i tuoi agenti AI personalizzati al server Model Context Protocol (MCP) remoto, i tuoi agenti possono cercare e recuperare dinamicamente documentazione per lo sviluppo autorevole e aggiornata di Google Developers che copre Google Cloud, Firebase, Android, Google Maps Platform, Chrome e altro ancora.

Prerequisiti

Prima di iniziare, completa i seguenti prerequisiti:

  1. Genera una chiave API Developer Knowledge: attiva l'API Developer Knowledge e crea una chiave API nel tuo progetto Google Cloud seguendo la guida alla configurazione della chiave API.
  2. Genera una chiave API Gemini: crea una chiave API in Google AI Studio per autenticare i modelli Gemini o riutilizza la tua chiave API Google Cloud se l'API Generative Language è abilitata.

  3. Imposta le variabili di ambiente: imposta le chiavi API come variabili di ambiente nel terminale:

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

  4. Installa Python: verifica che l'ambiente di sviluppo utilizzi Python 3.10 o versioni successive.

Connettiti utilizzando LangChain

Le applicazioni LangChain possono connettersi a server MCP HTTP remoti utilizzando il pacchetto langchain-mcp-adapters o i trasporti client MCP standard.

Installa le dipendenze

Installa i pacchetti Python richiesti per LangChain, Gemini e MCP:

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

Configura l'agente LangChain

L'esempio seguente connette il server MCP Developer Knowledge a un agente LangChain ReAct basato su Gemini. Lo script crea un'istanza di MultiServerMCPClient utilizzando il trasporto streamable_http, collega l'intestazione HTTP X-Goog-Api-Key e carica gli strumenti remoti 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())

Connettiti utilizzando LlamaIndex

LlamaIndex supporta l'integrazione del server MCP tramite le specifiche degli strumenti, consentendo agli agenti di recupero di eseguire query sui documenti di Developer Knowledge durante il ragionamento.

Installa le dipendenze

Installa i pacchetti principali di LlamaIndex, Gemini LLM e l'integrazione degli strumenti MCP:

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

Configura l'agente LlamaIndex

L'esempio seguente si connette al server MCP remoto utilizzando BasicMCPClient, lo racchiude con McpToolSpec e associa gli strumenti recuperati a un indice LlamaIndex FunctionAgent basato su 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())

Connettiti utilizzando AutoGen

Gli agenti Microsoft AutoGen possono interfacciarsi con i server MCP remoti utilizzando l'estensione autogen-ext MCP, consentendo la collaborazione multi-agente con accesso alla documentazione ufficiale per sviluppatori di Google.

Installa le dipendenze

Installa i pacchetti di estensione principali di AutoGen e MCP:

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

Configurare l'agente AutoGen

Il seguente esempio si connette al server MCP remoto utilizzando StreamableHttpServerParams e registra gli strumenti Developer Knowledge con un AutoGen AssistantAgent basato su 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())

Best practice per l'integrazione degli agenti

Quando crei agenti AI personalizzati con il server MCP per Developer Knowledge, segui queste linee guida:

  • Perfeziona le query di ricerca: includi nomi di prodotti specifici e parole chiave pertinenti nella query in linguaggio naturale anziché termini generici, perché gli strumenti search_documents e answer_query corrispondono alla semantica della query.
  • Gestisci i token della finestra contestuale: utilizza answer_query per risposte dirette estratte dal corpus della documentazione ed evita di richiedere i contenuti della pagina completa con get_documents, a meno che i dettagli dello snippet di search_documents non siano sufficienti.
  • Chiavi API sicure: memorizza le chiavi API Developer Knowledge e Gemini in variabili di ambiente o sistemi di gestione dei secret standard e non codificare le credenziali nel codice.

Passaggi successivi

Esplora le seguenti risorse per scoprire di più sul server MCP per Developer Knowledge: