Integra el servidor de MCP de Developer Knowledge con agentes de IA personalizados

En este instructivo, se muestra cómo conectar el servidor de MCP de Developer Knowledge remoto a frameworks de agentes de IA personalizados creados con LangChain, LlamaIndex y AutoGen.

Si conectas tus agentes de IA personalizados al servidor remoto del Protocolo de contexto del modelo (MCP), tus agentes podrán buscar y recuperar de forma dinámica documentación autorizada y actualizada para desarrolladores de Google que abarque Google Cloud, Firebase, Android, Google Maps Platform, Chrome y mucho más.

Requisitos previos

Antes de comenzar, completa los siguientes requisitos previos:

  1. Genera una clave de la API de Developer Knowledge: Habilita la API de Developer Knowledge y crea una clave de API en tu proyecto de Google Cloud siguiendo la guía de configuración de la clave de API.
  2. Genera una clave de la API de Gemini: Crea una clave de API en Google AI Studio para autenticar los modelos de Gemini o reutiliza tu clave de API de Google Cloud si la API de Generative Language está habilitada en ella.

  3. Configura tus variables de entorno: Establece tus claves de API como variables de entorno en tu terminal:

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

  4. Instala Python: Verifica que tu entorno de desarrollo use Python 3.10 o una versión posterior.

Conéctate con LangChain

Las aplicaciones de LangChain pueden conectarse a servidores de MCP HTTP remotos con el paquete langchain-mcp-adapters o los transportes de clientes de MCP estándar.

Instala dependencias

Instala los paquetes de Python necesarios para LangChain, Gemini y MCP:

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

Configura el agente de LangChain

En el siguiente ejemplo, se conecta el servidor de MCP de Developer Knowledge a un agente de LangChain ReAct potenciado por Gemini. La secuencia de comandos crea una instancia de MultiServerMCPClient con el transporte streamable_http, adjunta el encabezado HTTP X-Goog-Api-Key y carga las herramientas remotas en 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())

Conéctate con LlamaIndex

LlamaIndex admite la integración del servidor de MCP a través de especificaciones de herramientas, lo que permite que los agentes de recuperación consulten documentos de Developer Knowledge durante el razonamiento.

Instala dependencias

Instala los paquetes principales de LlamaIndex, el LLM de Gemini y la integración de las herramientas de MCP:

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

Configura el agente de LlamaIndex

En el siguiente ejemplo, se conecta al servidor de MCP remoto con BasicMCPClient, se encapsula con McpToolSpec y se vinculan las herramientas recuperadas a un FunctionAgent de LlamaIndex potenciado por 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())

Conéctate con AutoGen

Los agentes de Microsoft AutoGen pueden interactuar con servidores MCP remotos a través de la extensión autogen-ext de MCP, lo que permite la colaboración de varios agentes con acceso a la documentación oficial para desarrolladores de Google.

Instala dependencias

Instala los paquetes principales de AutoGen y de la extensión de MCP:

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

Configura el agente de AutoGen

En el siguiente ejemplo, se conecta al servidor de MCP remoto con StreamableHttpServerParams y se registran las herramientas de Developer Knowledge con un AssistantAgent de AutoGen potenciado por 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())

Prácticas recomendadas para la integración de agentes

Cuando compiles agentes de IA personalizados con el servidor de MCP de Developer Knowledge, sigue estos lineamientos:

  • Cómo definir mejor las búsquedas: Incluye nombres de productos específicos y palabras clave relevantes en la búsqueda en lenguaje natural en lugar de términos genéricos, ya que las herramientas search_documents y answer_query coinciden con la semántica de la búsqueda.
  • Administra los tokens de la ventana de contexto: Usa answer_query para obtener respuestas directas extraídas del corpus de documentación y evita solicitar el contenido de páginas completas con get_documents, a menos que los detalles del fragmento de search_documents sean insuficientes.
  • Protege las claves de API: Almacena tus claves de API de Developer Knowledge y de Gemini en variables de entorno o sistemas de administración de secretos estándar, y nunca codifiques de forma rígida las credenciales en el código.

¿Qué sigue?

Explora los siguientes recursos para obtener más información sobre el servidor de MCP de Developer Knowledge: