Google MCP Servers Tutorial: Implantando IA Agente no GCP

Os grandes modelos de linguagem (LLMs) revolucionaram a forma como interagimos com a IA, mas ainda estão, em grande parte, presos às interfaces de chat. Pedir pra uma IA analisar seus dados de vendas mais recentes no BigQuery ou checar a saúde do cluster no GKE normalmente exige escrever código de ligação pra cada ferramenta, cada modelo e cada fluxo de trabalho.

Conheça os servidores MCP gerenciados pelo Google: a solução empresarial que conecta agentes de IA à poderosa infraestrutura da nuvem do Google, como BigQuery, Google Maps, Compute Engine (GCE) e Kubernetes Engine (GKE), sem precisar de conectores personalizados. 

Feitos com base no padrão aberto Model Context Protocol (MCP) da Anthropic, esses servidores remotos totalmente gerenciados oferecem acesso seguro e padronizado, permitindo que qualquer cliente compatível com MCP (como Gemini CLI ou Claude Desktop) transforme a IA em um operador proativo.

Neste guia, vou mostrar a arquitetura prática do MCP e do portfólio de servidores do Google, além de explicar os passos exatos para implantar um servidor MCP pronto para produção. Seja para basear a IA em dados empresariais ou automatizar tarefas de DevOps, você estará pronto para começar em poucos minutos.

É novo na nuvem do Google? Recomendo começar com o curso gratuito Introdução ao GCP para aprender sobre faturamento, projetos e serviços básicos.

O que é o Protocolo de Contexto Modelo?

O Protocolo de Contexto do Modelo (MCP) é um padrão de código aberto que a Anthropic lançou em novembro de 2024. Ele funciona como uma interface universal — muitas vezes chamada de “USB-C para IA” — que padroniza como os modelos e agentes de IA se conectam a fontes de dados, ferramentas e sistemas externos.

Antes do MCP, integrar um agente de IA com ferramentas como bancos de dados, APIs ou serviços em nuvem exigia a criação de conectores personalizados para cada modelo de IA (por exemplo, código separado para Claude, Gemini ou GPT). Isso fez com que surgissem um monte de integrações fragmentadas. 

O MCP resolve isso definindo um protocolo único e consistente: os desenvolvedores implementam uma ferramenta ou fonte de dados uma vez como um servidor MCP, e qualquer cliente de IA compatível com MCP (como Claude Desktop, Gemini CLI ou agentes personalizados) pode descobri-lo e usá-lo perfeitamente.

A principal vantagem é a interoperabilidade e a redução da duplicação de dados. Escreva um servidor MCP para o BigQuery uma vez, e ele vai funcionar em todos os modelos de IA compatíveis sem precisar de adaptadores extras. Isso acelera o desenvolvimento de sistemas de IA agênicos, nos quais os agentes não apenas respondem a consultas, mas também raciocinam ativamente, consultam dados e executam ações no mundo real.

O cliente descobre as ferramentas disponíveis nos servidores conectados, o LLM decide quais chamar e os resultados voltam para mais raciocínio, tudo padronizado pelo protocolo baseado em JSON-RPC do MCP.

Esse design de “tradutor universal” é o motivo pelo qual o Google (e outros) adotaram rapidamente o MCP: seus servidores gerenciados se encaixam diretamente nesse ecossistema, tornando os serviços da nuvem do Google instantaneamente acessíveis a qualquer cliente MCP.

O que é um servidor MCP do Google?

Os servidores MCP do Google são implementações remotas e totalmente gerenciadas pelo Google do Protocolo de Contexto de Modelo (MCP). Lançados em dezembro de 2025, esses servidores de nível empresarial oferecem serviços poderosos da nuvem Google, começando com BigQuery, Google Maps, GCE e GKE, como ferramentas padronizadas e fáceis de encontrar que qualquer cliente de IA compatível com MCP pode usar na hora.

Diferente dos servidores MCP comunitários ou de código aberto, que exigem hospedagem própria, manutenção, dimensionamento e reforço de segurança personalizado, os servidores gerenciados do Google funcionam na infraestrutura do Google. Eles oferecem:

• Sem custos de implantação: É só ativar o serviço no seu projeto e direcionar seu cliente para o endpoint oficial (por exemplo, https://bigquery.googleapis.com/mcp).
• Confiabilidade empresarial: Alta disponibilidade, dimensionamento automático e pontos finais globais.
• Segurança integrada: Autenticação baseada em IAM, Model Armor (firewall LLM do Google para proteção contra injeção de prompts e exfiltração), registro de auditoria e controles de privilégios mínimos.
• Governança: Ativação/desativação centralizada por projeto ou organização.

Essa tecnologia libera fluxos de trabalho agenticos. Em vez de uma IA só explicar como uma consulta SQL funciona, ela pode realmente executar a consulta no BigQuery, analisar os resultados e sugerir o próximo passo comercial. 

Embora esses agentes possam agir de forma autônoma, a implementação do Google dá suporte a configurações “human-in-the-loop”, garantindo que um humano possa revisar e aprovar mudanças críticas na infraestrutura antes que elas aconteçam.

Portfólio de servidores MCP do Google

O Google oferece um conjunto cada vez maior de servidores MCP totalmente gerenciados que disponibilizam instantaneamente serviços essenciais na nuvem como ferramentas para agentes de IA. Esses servidores são categorizados por função, permitindo que os agentes cuidem de tudo, desde análise de dados até gerenciamento de infraestrutura, sem precisar de código personalizado.

O ecossistema divide os servidores em duas categorias principais:

• Inteligência de dados: Focado em consultar, analisar e basear-se em dados do mundo real.
• Operações de infraestrutura: Permitindo o controle e o monitoramento dos recursos de computação.

Servidores de inteligência de dados

Os servidores BigQuery e Maps MCP oferecem oportunidades incríveis para incluir dados no seu fluxo de trabalho.

BigQuery

O servidor BigQuery MCP permite que os agentes:

• Execute consultas SQL diretamente em conjuntos de dados
• Lista de conjuntos de dados e tabelas disponíveis
• Recuperar metadados do esquema e dados de amostra
• Execute tarefas analíticas, incluindo inferência de ML por meio do BigQuery ML

Isso permite que os agentes façam análises complexas de dados, criem relatórios ou prevejam tendências de forma autônoma.

Google Maps

O servidor MCP do Google Maps é alimentado pelo Grounding Lite e pela API Places, e suporta:

• Geocodificação e geocodificação reversa
• Pesquisa de locais e recuperação de detalhes
• Cálculo de rotas e direções
• Cálculos da matriz de distâncias

: Inteligência empresarial em tempo real e otimização logística. Um agente pode consultar dados de vendas no BigQuery, cruzar informações com o Maps para obter insights geográficos e recomendar otimizações de rotas de entrega, tudo em um único ciclo de raciocínio.

Servidores de operações de infraestrutura

No lado da infraestrutura, você pode usar o Kubernetes Engine (GKE) e os servidores MCP do Compute Engine (GCE).

Google Kubernetes Engine

O servidor GKE MCP oferece operações como:

• Listando clusters, nós e pods
• Verificando a saúde do cluster e a utilização dos recursos
• Registros de leitura e eventos
• Dimensionamento de implantações (com permissões IAM apropriadas)

Google Compute Engine

O servidor GCE MCP permite:

• Listar, iniciar, parar e reiniciar instâncias de VM
• Lista de discos ou tipos de máquina
• Consultando metadados e status da instância

: Solução automatizada de problemas e “ChatOps” para equipes de DevOps. Um agente pode detectar uma falha no pod por meio das ferramentas GKE, correlacionar com as métricas da VM do GCE e iniciar etapas de correção, reduzindo o tempo médio de resolução de horas para minutos.

O Google continua a expandir esse portfólio (com serviços como Cloud Storage e AlloyDB em pré-visualização no início de 2026), tornando mais do Google Cloud acessível de forma nativa por agentes.

Arquitetura central do servidor MCP do Google

O poder do MCP está nas suas camadas de comunicação flexíveis, mas padronizadas, que permitem conexões perfeitas, seja você fazendo protótipos localmente ou executando agentes prontos para produção em grande escala. Os servidores MCP gerenciados pelo Google usam principalmente HTTP remoto transmissível para implantações empresariais, enquanto o desenvolvimento local usa stdio. 

Comunicação local via stdio

O transporte de entrada/saída padrão ( stdio ) é a maneira mais simples de executar um servidor MCP. Aqui, o cliente MCP (por exemplo, Claude Desktop ou um agente personalizado) inicia o servidor como um subprocesso na mesma máquina, comunicando-se por meio de canais diretos e sem qualquer rede envolvida.

Prós:

• Configuração super fácil para desenvolvimento e testes
• Segurança embutida (sem portas expostas ou superfície de ataque à rede)
• Baixa latência

Contras:

• Não pode ser compartilhado entre máquinas ou equipes
• Escalabilidade limitada (ligada ao host do cliente)
• Sem concorrência integrada para várias sessões

Esse modo é perfeito pra experimentar servidores MCP personalizados ou testar conexões antes de entrar no modo remoto.

Comunicação remota via HTTP transmissível

Para produção e uso empresarial, os servidores gerenciados do Google (e os personalizados auto-hospedados) usam HTTP transmitível em um único ponto de extremidade persistente. Isso substitui a abordagem anterior de Eventos enviados pelo servidor (SSE) por um design mais robusto que oferece suporte a:

• Solicitações HTTP POST para todas as interações
• Streaming bidirecional opcional para respostas grandes ou incrementais (por exemplo, streaming de resultados do BigQuery)
• IDs de sessão para conversas com estado
• Conexões simultâneas para chamadas paralelas de várias ferramentas

Os terminais gerenciados pelo Google seguem um padrão consistente, por exemplo:

• BigQuery: https://bigquery.googleapis.com/mcp
• Mapas: https://mapstools.googleapis.com/mcp
• Calcular: https://compute.googleapis.com/mcp

Todo o tráfego é protegido com tokens de identificação do Google (OAuth2), garantindo que as chamadas sejam autenticadas e autorizadas por meio do IAM.

É assim que um fluxo de sequência poderia ser:

1. O cliente manda a descoberta/solicitação da ferramenta via POST para /mcp.

2. O servidor verifica a identidade e encaminha para o serviço de back-end.

3. O backend faz a execução (por exemplo, roda SQL no BigQuery).

4. As respostas são enviadas em blocos (formato JSON-RPC) para um tratamento eficiente de grandes volumes de dados.

Introdução ao servidor Google MCP

Uma das maiores vantagens dos servidores MCP do Google é que eles precisam de pouca configuração em comparação com as alternativas auto-hospedadas. Vamos diferenciar claramente entre servidores gerenciados e personalizados à medida que avançamos nas etapas.

• Servidores MCP do Google gerenciados: São pra serviços como BigQuery, Maps, GCE e GKE, e são totalmente hospedados pelo Google. Você não precisa implantar nada — basta habilitar os endpoints no seu projeto, conceder permissões IAM e configurar seu cliente. Eles estão prontos para usar assim que saem da caixa.
• Servidores MCP personalizados: Para ferramentas internas, APIs de terceiros ou extensões avançadas, você cria e implementa seu próprio servidor (por exemplo, usando a MCP Toolbox do Google). Eles geralmente são colocados no Cloud Run pra ter escalabilidade.

Configurando oambiente da nuvem Googlepara servidores gerenciados

Siga estas etapas (baseadas no tutorial oficial) para habilitar e preparar servidores MCP gerenciados.

Pré-requisitos

• Um projeto da nuvem do Google com faturamento ativado

• Acesso ao Google Cloud Console e Cloud Shell (ou CLI local do gcloud )

• Sua conta de usuário é autenticada por meio de gcloud auth login

Configuração do projeto e ativação da API

1. Crie ou escolha um projeto no Google Cloud Console.
2. Ative o faturamento, se ainda não tiver feito isso.
3. Ative as APIs do serviço principal (no Cloud Shell ou terminal local):

gcloud auth list  # Verify you're logged in
gcloud config list project  # Check current project
gcloud config set project YOUR_PROJECT_ID  # If needed

gcloud services enable bigquery.googleapis.com \
  compute.googleapis.com \
  container.googleapis.com \
  mapstools.googleapis.com

Lembre-se de que o MCP do Maps precisa de uma chave API própria para cobrança e cota. Crie um com o seguinte comando:

gcloud alpha services api-keys create --display-name="Maps-MCP-Key"

Copie o endereço keyStringexibido — você vai precisar dele para a configuração do cliente.

Ativar servidores MCP gerenciados (beta)

Os serviços MCP precisam de ativação beta explícita:

export PROJECT_ID=$(gcloud config get-value project)
export USER_EMAIL=$(gcloud config get-value account)

gcloud beta services mcp enable bigquery.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable mapstools.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable compute.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable container.googleapis.com --project=$PROJECT_ID

Configuração do IAM

Dê à ferramenta MCP uma função de usuário na sua conta:

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="user:$USER_EMAIL" \
  --role="roles/mcp.toolUser"

Adicione funções específicas do serviço para acesso com privilégios mínimos, por exemplo:

• BigQuery: roles/bigquery.jobUser e roles/bigquery.dataViewer

• Computação/GKE: roles/compute.viewer ou roles/container.viewer

Os servidores gerenciados já estão prontos! Pontos finais:

• BigQuery: https://bigquery.googleapis.com/mcp
• Mapas: https://mapstools.googleapis.com/mcp
• Computação (GCE e GKE): https://compute.googleapis.com/mcp

Implantando servidores MCP remotos personalizados na Nuvem Run

Para ferramentas personalizadas além do portfólio gerenciado pelo Google, crie seu próprio servidor MCP usando bibliotecas como FastMCP (Python) e implante no Cloud Run para obter escalabilidade e compartilhamento em equipe. Não vamos entrar em muitos detalhes aqui, mas vamos dar uma visão geral do processo.

Etapas de alto nível:

1. Crie um projeto Python e adicione o FastMCP como dependência (usando ferramentas como uv).

2. Implemente o código do seu servidor (por exemplo, server.py) definindo ferramentas personalizadas, usando transport="streamable-http".

3. Escreva um Dockerfile leve (baseado em python:slim) para instalar dependências e rodar o servidor em $PORT.

4. Habilite as APIs necessárias (Cloud Run, Artifact Registry, Cloud Build).

5. Implemente diretamente da fonte ou crie/envie um contêiner.

6. Garanta o serviço: Exigir autenticação IAM (--no-allow-unauthenticated), conceder roles/run.invoker a entidades autorizadas e usar tokens de identidade para conexões de clientes.

gcloud run deploy your-mcp-server \
  --source . \
  --region=us-central1 \
  --no-allow-unauthenticated

Esse processo leva menos de 10 minutos para servidores simples e oferece hospedagem de nível de produção com autoescalonamento.

Configuração e integração do cliente do servidor MCP do Google

Um servidor MCP implantado (ou habilitado) fica realmente poderoso quando conectado a um cliente de IA. Essa seção fala sobre como configurar clientes populares para usar os servidores MCP gerenciados pelo Google e criar agentes programáticos.

Testando com o MCP Inspector

O MCP Inspector oferece uma interface de usuário web simples para explorar qualquer servidor MCP, incluindo os gerenciados pelo Google. É super útil pra resolver problemas de autenticação, descobrir nomes/parâmetros exatos de ferramentas e ver respostas reais.

O processo é assim:

1. Inicie o Inspector
2. Conecte-se a um servidor MCP gerenciado pelo Google
3. Explore e teste as ferramentas

Para abrir o Inspector, digite este comando no seu terminal:

npx @modelcontextprotocol/inspector

Isso inicia um servidor web local e abre a interface do usuário do Inspector no seu navegador padrão. 

Depois, vamos conectar ao servidor MCP do Google. Vamos começar com o Google Maps como exemplo. 

Na interface do usuário do Inspector, no lado esquerdo, vamos configurar o MCP Inspector para se conectar ao nosso servidor MCP do Google Maps. Siga as instruções e insira os valores específicos:

1. Tipo de transporte: Selecione HTTP transmissível

2. URL: Enter https://mapstools.googleapis.com/mcp

3. Tipo de conexão: Escolha via proxy (isso faz a autenticação do Google de forma segura usando suas credenciais de login do gcloud).

4. Cabeçalhos personalizados: Adicionar um cabeçalho

   • Chave: X-Goog-Api-Key

   • Valor: Sua chave API do Maps (o keyString da configuração anterior).

5. Clique em Conectar.

Se tudo der certo, você deve ver o MCP Inspector conectando-se com sucesso ao servidor. No painel direito, você vai poder acessar as ferramentas compatíveis com o Google Maps MCP Server clicando em“ ” (Acessar ferramentas).

Vamos explorar e testar as ferramentas:

• Escolha qualquer ferramenta para ver o esquema JSON completo: descrição, parâmetros (com tipos e campos obrigatórios) e exemplos. 
• Preencha os parâmetros (por exemplo, consulta: “melhor café em Pune, Maharashtra”) e clique em Invocar.
• Os resultados reais aparecem na hora, transmitidos em partes para respostas grandes.

Para os servidores BigQuery e Compute, o processo é igual, mas mais simples, já que não precisa de cabeçalho de chave de API. A autenticação rola automaticamente pelo proxy.

Configurando a CLI do Gemini

O Gemini CLI é o agente de terminal oficial de código aberto do Google, com integração nativa profunda para servidores MCP. É a maneira mais fácil de começar a criar fluxos de trabalho de agentes. 

Configurando a CLI do Gemini

Instale o Gemini CLI usando o seguinte comando:

npm install -g @google/gemini-cli@latest

Adicionando servidores e testando a conexão

Vamos usar o Maps como exemplo de novo. Para adicionar o servidor MCP do Google Maps, use o comando a seguir e lembre-se de substituir YOUR_MAPS_API_KEY pela chave da API do Maps que criamos anteriormente.

gemini mcp add -s user -t http -H 'X-Goog-Api-Key: YOUR_MAPS_API_KEY' maps-grounding-lite-mcp https://mapstools.googleapis.com/mcp

Em uma nova sessão do Gemini, dá uma olhada na conexão com o comando ` /mcp list`.

Na nossa primeira interação, fazemos uma pergunta simples em linguagem natural: 

“Quais são alguns lugares econômicos para tomar café da manhã em Nova York?”

O Gemini escolhe automaticamente as ferramentas do Maps. Depois que você aceitar a execução, ele chama eles e mostra os resultados formatados.

Funcionou! Recebemos a seguinte resposta:

Here are some economical breakfast places in New York:
Good Morning Breakfast is a breakfast restaurant located at 1216 Broadway, New York, NY 10001. It is open from 6:00 AM to 12:00 PM on weekdays and 6:30 AM to 12:30 PM on Saturdays. They serve breakfast and lunch and have vegetarian options. The price range is $1-$10.
Andrews NYC Diner is a diner located at 463 7th Ave, New York, NY 10018. They are open from 6:00 AM to 10:00 PM on weekdays, 6:00 AM to 11:00 PM on Fridays and Saturdays, and 7:00 AM to 11:00 PM on Sundays.
They serve breakfast, lunch, and dinner, and have outdoor seating and a children's menu.
The price range is $10-$20.
George's is an American restaurant located at 89 Greenwich St, New York, NY 10006. They are open from 7:00 AM to 6:00 PM daily. They serve breakfast, lunch, and dinner, and have outdoor seating and a children's menu. The price range is $10-$20.
New York Luncheonette is an American restaurant located at 135 E 50th St, New York, NY 10022. They are open from 7:00 AM to 10:00 PM daily. They serve breakfast, lunch, and dinner, and have a children's menu.
The price range is $10-$20.

O clássico momento “Hello World” na CLI do Gemini: lista de ferramentas limpa depois de adicionar servidores, seguida por consultas em linguagem natural que acionam chamadas reais da ferramenta Maps. 

Usando o Gemini CLI com o servidor MCP do Google Maps

Pra testar habilidades de raciocínio mais avançadas junto com os dados do Maps, estamos passando o seguinte prompt: 

Planeje uma rota de carro de Mumbai a Goa com uma parada panorâmica para almoçar no meio do caminho. Me dê uma dica de um bom restaurante por lá.

Quando você manda esse comando, o agente de IA (Gemini ou Claude) faz um raciocínio sofisticado em várias etapas usando só as ferramentas MCP do Google Maps:

1. Calculando a rota completa: O agente liga para compute_routes com origem em “Mumbai” e destino em “Goa”. O resultado é uma distância de cerca de 566 km com uma duração de aproximadamente 11 horas e 41 minutos (levando em conta o trânsito).

2. Raciocinando sobre o ponto médio: O agente calcula que a metade do caminho (~280–300 km) fica na região de Konkan, mais especificamente perto de Chiplun, que é famosa pelas vistas do rio, ghats e beleza cênica.

3. Procurando restaurantes com vista legal: Ele usa o site search_places com pesquisas voltadas para Chiplun/Ratnagiri, filtrando por avaliações altas, vistas externas/panorâmicas e disponibilidade de almoço.

4. Escolhendo e descrevendo a melhor opção: Por fim, escolhe um lugar que se destaca (no seu caso, o restaurante The Riverview, em Chiplun) e destaca sua área externa e ambiente relaxante.

Essa resposta é gerada ao vivo. A duração do trajeto vem direto da chamada da ferramenta compute_routes que você viu na saída de depuração, e a recomendação do restaurante é baseada em dados reais da API do Google Places: nada de fatos codificados, nada de alucinações, só o uso seguro e atualizado da ferramenta.

É assim que a CLI Gemini chama a ferramenta e mostra sua recomendação:

compute_routes (maps-grounding-lite-mcp MCP Server) {"destination": {"address": "Goa"}, "origin": {"address": "Mumbai" }}
{
  "routes": [
    {
      "distanceMeters": 566414,
      "duration": "42095s"
    }
  ]
}
* A great place to stop for a scenic lunch on your drive from Mumbai to Goa is Chiplun, which is roughly halfway. I recommend The Riverview Restaurant in Chiplun. It offers outdoor seating and is a great spot to relax and enjoy a meal with a view.
The drive from Mumbai to Goa is approximately 566 km and will take about 11 hours and 40 minutes without stops. Enjoy your trip

Integração programática com LangChain ou LangGraph

Além de clientes interativos como Gemini CLI ou Claude Desktop, o verdadeiro poder dos servidores MCP gerenciados pelo Google aparece quando você cria agentes de IA personalizados e prontos para produção em código. O ecossistema de código aberto LangChain torna isso bem simples com o pacote langchain-mcp-adapters, que transforma qualquer servidor MCP remoto em ferramentas padrão do LangChain.

Essa abordagem oferece visibilidade completa da descoberta, autenticação e invocação de ferramentas: perfeita para depuração, criação de roteadores de ferramentas personalizados ou integração em fluxos de trabalho assíncronos existentes.

Usando o LangChain para conectar ao servidor BigQuery MCP

Para entender melhor, vamos mostrar isso com um exemplo. O script completo e executável a seguir mostra como:

• Autentique-se na nuvem do Google usando as credenciais padrão do aplicativo

• Conecte-se ao endpoint MCP gerenciado do BigQuery por meio de HTTP transmitível.

• Descubra todas as ferramentas disponíveis

• Use uma ferramenta específica (list_dataset_ids) e veja os resultados reais.

import asyncio
import google.auth
import google.auth.transport.requests
import httpx

from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client
from langchain_mcp_adapters.tools import load_mcp_tools

async def list_and_invoke_bigquery():
    # 1. Authenticate with Google Cloud (run: gcloud auth application-default login)
    credentials, project_id = google.auth.default(
        scopes=["https://www.googleapis.com/auth/cloud-platform"]
    )
    auth_request = google.auth.transport.requests.Request()
    credentials.refresh(auth_request)

    url = "https://bigquery.googleapis.com/mcp"
    print(f"Connecting to: {url}...")

    # 2. Setup authenticated HTTP client
    async with httpx.AsyncClient(headers={
        "Authorization": f"Bearer {credentials.token}",
        "x-goog-user-project": project_id,
        "Content-Type": "application/json"
    }) as http_client:
        
        # 3. Establish streamable HTTP transport and MCP session
        async with streamable_http_client(url, http_client=http_client) as (read, write, _):
            async with ClientSession(read, write) as session:
                await session.initialize()
                
                # 4. Discover all tools exposed by Google's BigQuery MCP server
                tools = await load_mcp_tools(session)
                
                print(f"\n--- DISCOVERY: Found {len(tools)} tools ---")
                for tool in tools:
                    print(f"Tool: {tool.name}")
                
                # 5. Invoke a specific tool: list_dataset_ids
                print(f"\n--- INVOCATION: Fetching datasets for project '{project_id}' ---")
                
                dataset_tool = next((t for t in tools if t.name == "list_dataset_ids"), None)
                if dataset_tool:
                    try:
                        result = await dataset_tool.ainvoke({"project_id": project_id})
                        print("SUCCESS! Datasets in your project:")
                        print(result)
                    except Exception as e:
                        print(f"Error invoking tool: {e}")
                else:
                    print("Tool 'list_dataset_ids' not found.")

if __name__ == "__main__":
    asyncio.run(list_and_invoke_bigquery())

Quando executado em um projeto GCP configurado corretamente, esse script gera resultados como:

Connecting to: https://bigquery.googleapis.com/mcp…

--- DISCOVERY: Found 5 tools ---
Tool: list_dataset_ids
Tool: get_dataset_info
Tool: list_table_ids
Tool: get_table_info
Tool: execute_sql

--- INVOCATION: Fetching datasets for ‘project’ ---
SUCCESS! Output from BigQuery: (...)

Isso confirma:

• Autenticação segura via ADC
• Apertos de mão bem-sucedidos com o servidor remoto gerenciado do Google
• Descoberta completa de ferramentas
• Execução ao vivo retornando seus conjuntos de dados reais do BigQuery

Esse padrão de baixo nível é super útil quando:

• Depurando problemas de conexão ou permissão
• Criando uma lógica personalizada para escolher ferramentas
• Integrando o MCP em serviços FastAPI, trabalhadores em segundo plano ou aplicativos de streaming
• Precisando de controle preciso sobre fluxos assíncronos

Depois de verificar a conectividade dessa forma, você pode, com confiança, passar para estruturas de nível superior, como agentes LangGraph (como mostrado nos exemplos anteriores), ou usar essas ferramentas em qualquer sistema compatível com LangChain.

Com essa base, os servidores Google MCP se tornam uma extensão segura e pronta para produção da sua pilha de IA Python, sem precisar de nenhum código personalizado.

Melhores práticas de segurança para o servidor Google MCP

A segurança não é uma preocupação secundária com os servidores MCP gerenciados pelo Google. Em vez disso, foi construído do zero. Ao rodar na infraestrutura do Google e se integrar profundamente com o gerenciamento de identidade e acesso do Google na nuvem, esses servidores oferecem proteções de nível empresarial que superam em muito as alternativas auto-hospedadas ou experimentais.

Gerenciamento de identidade e acesso

O Google Cloud usa sua estrutura robusta de IAM (Gerenciamento de Identidade e Acesso) para controlar quem (ou o que) pode acessar suas ferramentas MCP.

No Controle de Acesso Baseado em Função (RBAC), cada agente de IA deve ter sua própria conta de serviço dedicada. Esse controle depende de duas camadas distintas de autorização:

• Função de gateway: Para usar qualquer ferramenta do Google MCP, a identidade precisa ter a função roles/mcp.toolUser.

• Permissões específicas do serviço: Como mcp.toolUser só permite a conexão, você ainda precisa dar permissões específicas para a ação. Por exemplo, se a IA precisa consultar dados, ela precisa de um roles/bigquery.jobUser. Por outro lado, se ele só precisa ver o status da VM, você deve fornecer roles/compute.viewer, e não roles/compute.admin.

Modelo de blindagem

O Model Armor é um serviço da nuvem do Google feito pra melhorar a segurança e proteção dos seus aplicativos de IA. Ele funciona analisando proativamente as solicitações e respostas do LLM, protegendo contra vários riscos e garantindo práticas responsáveis de IA. 

Se você está usando IA no Google Cloud ou em outros provedores de nuvem, o Model Armor pode te ajudar a evitar entradas maliciosas, verificar a segurança do conteúdo, proteger dados confidenciais, manter a conformidade e aplicar suas políticas de segurança e proteção de IA de forma consistente em todos os seus aplicativos de IA.

O Model Armor funciona como um Web Application Firewall (WAF) especializado para IA:

• Higienização imediata: Ele verifica cada solicitação recebida em busca de ataques de injeção e tentativas de jailbreak antes que a solicitação chegue ao seu servidor MCP.
• Segurança do conteúdo: Ele filtra conteúdos prejudiciais e pode ser configurado com modelos de Proteção de Dados Confidenciais (SDP) para ocultar informações pessoais identificáveis (nomes, números de segurança social, números de cartão de crédito) tanto em prompts como em resultados de ferramentas.
• Configurações do piso: O Google recomenda um “nível mínimo de segurança” específico para o MCP, que inclui a verificação obrigatória de URLs maliciosos e padrões de injeção imediata.

Observabilidade e conformidade

Cada chamada de ferramenta feita por meio de um servidor Google MCP é um evento registrado.

• Registro em nuvem: As ações do MCP são automaticamente encaminhadas para o Cloud Logging. Isso inclui o ID do agente, o ID da sessão, a ferramenta específica chamada e a carga útil.

• Trilhas de auditoria: Ao ativar os registros de acesso aos dados para o serviço mcp.googleapis.com, você pode manter um registro permanente para análises de conformidade, o que te permite responder: “Quem (qual agente) acessou quais dados e quando?”

Conclusão

Chega de conectores personalizados frágeis para cada modelo ou ferramenta: Os servidores MCP gerenciados pelo Google são um ponto de virada para a IA agênica na nuvem do Google. Ao adotar o padrão MCP aberto e oferecer implementações totalmente hospedadas e de nível empresarial para BigQuery, Google Maps, Compute Engine e GKE, o Google eliminou as maiores barreiras para a criação de agentes confiáveis e capazes de agir.

Como vimos neste guia, essa arquitetura padronizada acaba com o pesadelo do “código cola” e permite que você passe de protótipos locais para implantações do Cloud Run sem precisar reescrever ferramentas para cada cliente. Além disso, com o Google Cloud IAM e o Model Armor, seus agentes ficam protegidos de forma nativa contra as ameaças modernas de IA.

A mudança do “Chatbot” para o “Agente” tá rolando agora. Ao dominar os servidores MCP do Google, você não está apenas criando uma IA que responde a perguntas, mas também um colega de equipe digital capaz de operar sua nuvem na velocidade do pensamento.

Pronto pra transformar tudo o que você aprendeu neste guia em conhecimento profissional? Inscreva-se no nosso Engenheiro de IA Associado para Desenvolvedores.