Integrar o servidor MCP de conhecimento do desenvolvedor com agentes de IA personalizados

Neste tutorial, mostramos como conectar o servidor MCP remoto do Developer Knowledge a frameworks de agentes de IA personalizados criados com LangChain, LlamaIndex e AutoGen.

Ao conectar seus agentes de IA personalizados ao servidor remoto do Protocolo de Contexto de Modelo (MCP), eles podem pesquisar e recuperar dinamicamente documentação autorizada e atualizada para desenvolvedores do Google sobre o Google Cloud, o Firebase, o Android, a plataforma Google Maps, o Chrome e muito mais.

Pré-requisitos

Conclua os seguintes pré-requisitos antes de começar:

  1. Gerar uma chave da API Developer Knowledge: ative a API Developer Knowledge e crie uma chave de API no seu projeto na nuvem do Google Cloud seguindo o guia de configuração de chaves de API.
  2. Gere uma chave da API Gemini: crie uma chave de API no Google AI Studio para autenticar modelos do Gemini ou reutilize sua chave de API do Google Cloud se a API Generative Language estiver ativada nela.

  3. Defina as variáveis de ambiente: defina as chaves de API como variáveis de ambiente no terminal:

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

  4. Instale o Python: verifique se o ambiente de desenvolvimento usa Python 3.10 ou mais recente.

Conectar usando o LangChain

Os aplicativos LangChain podem se conectar a servidores MCP HTTP remotos usando o pacote langchain-mcp-adapters ou transportes padrão de clientes MCP.

Instalar dependências

Instale os pacotes Python necessários para LangChain, Gemini e MCP:

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

Configurar o agente do LangChain

O exemplo a seguir conecta o servidor MCP do Developer Knowledge a um agente ReAct do LangChain com tecnologia do Gemini. O script cria uma instância de MultiServerMCPClient usando o transporte streamable_http, anexa o cabeçalho HTTP X-Goog-Api-Key e carrega as ferramentas remotas em 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())

Conectar usando o LlamaIndex

O LlamaIndex oferece suporte à integração do servidor MCP por meio de especificações de ferramentas, permitindo que os agentes de recuperação consultem documentos do Developer Knowledge durante o raciocínio.

Instalar dependências

Instale os pacotes principais do LlamaIndex, o LLM do Gemini e a integração de ferramentas do MCP:

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

Configurar o agente do LlamaIndex

O exemplo a seguir se conecta ao servidor MCP remoto usando BasicMCPClient, o encapsula com McpToolSpec e vincula as ferramentas recuperadas a um LlamaIndex FunctionAgent com tecnologia do 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())

Conectar usando o AutoGen

Os agentes do Microsoft AutoGen podem interagir com servidores MCP remotos usando a extensão autogen-ext do MCP, permitindo a colaboração de vários agentes com acesso à documentação oficial para desenvolvedores do Google.

Instalar dependências

Instale os pacotes principais do AutoGen e da extensão MCP:

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

Configurar o agente do AutoGen

O exemplo a seguir se conecta ao servidor MCP remoto usando StreamableHttpServerParams e registra ferramentas de conhecimento do desenvolvedor com um AutoGen AssistantAgent com tecnologia do 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áticas recomendadas para integração de agentes

Ao criar agentes de IA personalizados com o servidor MCP de conhecimento do desenvolvedor, siga estas diretrizes:

  • Refine as consultas de pesquisa: inclua nomes de produtos específicos e palavras-chave relevantes na consulta em linguagem natural em vez de termos genéricos, porque as ferramentas search_documents e answer_query correspondem à semântica da consulta.
  • Gerenciar tokens de janela de contexto: use answer_query para respostas diretas extraídas do corpus de documentação e evite solicitar o conteúdo completo da página com get_documents, a menos que os detalhes do snippet de search_documents sejam insuficientes.
  • Proteja as chaves de API: armazene as chaves da API Developer Knowledge e da API Gemini em variáveis de ambiente ou sistemas padrão de gerenciamento de secrets e nunca codifique credenciais no código.

A seguir

Confira os recursos a seguir para saber mais sobre o servidor MCP de conhecimento do desenvolvedor: