Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Recapitulativo e Prática Prática

Aula 12 de 12 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. O que Abordámos
  2. Os Seis Parâmetros de Relance
  3. Verificações Antes de Passar para Produção
  4. O Seu Primeiro Agente, em Três Passos
  5. O que Permanece Verdadeiro Após Este Curso
  6. Pontos-chave
  7. Teste os Seus Conhecimentos

O que Abordámos

Este curso levou-o do conceito do Model Context Protocol até uma configuração pronta para produção. Se só se lembrar de uma coisa, que seja esta: o MCP permite ao Grok ligar-se a servidores de ferramentas externos via HTTPS, descobrindo e utilizando automaticamente as ferramentas expostas sem necessidade de configuração manual no lado do cliente.

Arquiteturalmente, quatro pontos estruturam todo o resto. O MCP remoto funciona exclusivamente sobre HTTPS, excluindo HTTP simples, localhost e o transporte stdio para servidores locais. São suportados dois transportes: o moderno Streaming HTTP sem estado e o SSE persistente, sendo que é o servidor que dita qual dos dois utilizar — não é uma escolha sua. Por fim, três interfaces fornecem acesso a este mecanismo: o SDK nativo da xAI (recomendado), a API de Responses para compatibilidade com a OpenAI e a API Voice Agent para agentes de voz.

Os Seis Parâmetros de Relance

ParâmetroObrigatórioFunção
server_urlSimEndereço HTTPS do servidor MCP
server_labelSimIdentificador único, prefixa as ferramentas
server_descriptionNãoDescrição em linguagem natural para orientar o Grok
allowed_tool_namesNãoLista de permissão de ferramentas acessíveis
authorizationNãoToken de autenticação (Bearer, chave de API)
headersNãoCabeçalhos HTTP adicionais

Dois obrigatórios, quatro opcionais: esta é toda a superfície de configuração para o MCP remoto. Contudo, os opcionais não são apenas funcionalidades de conforto. O allowed_tool_names gere a sua segurança, e o server_description garante uma seleção precisa quando coexistem vários servidores.

Verificações Antes de Passar para Produção

Três categorias de controlos exigem verificação explícita. No âmbito da segurança, assegure-se de que os URLs utilizam HTTPS com certificados válidos, que cada servidor interno possui o seu token de autenticação, que estes tokens residem em variáveis de ambiente, que as ferramentas estão restritas ao mínimo necessário e que a rotação regular de tokens é planeada, e não apenas esperada.

No âmbito da configuração, cada servidor deve ter um server_label único e descritivo, e o seu server_description deve ser preciso e atualizado — uma descrição que se refira a uma versão anterior do servidor induz o modelo em erro. Mantenha o número total de ferramentas razoável, cerca de dez a vinte por sessão, e remova da configuração os servidores cujas ferramentas já ninguém invoca.

No âmbito da observabilidade, planeie incidentes antecipadamente: registo de chamadas de ferramentas nos seus logs, alertas sobre erros de ligação ao MCP, monitorização do uso de tokens por servidor e medição da latência das chamadas. Esta última é frequentemente negligenciada, embora constitua o primeiro sinal de degradação de um servidor.

O Seu Primeiro Agente, em Três Passos

A melhor forma de consolidar este curso é construir progressivamente. Comece com um servidor público, sem autenticação, para validar que a mecânica funciona de ponta a ponta.

from xai_sdk import Client
from xai_sdk.tools import mcp
import os

client = Client(api_key=os.getenv("XAI_API_KEY"))

chat = client.chat.create(
    model="grok-4.20-0309-reasoning",
    tools=[
        mcp(
            server_url="https://mcp.deepwiki.com/mcp",
            server_label="deepwiki"
        )
    ],
)

Teste com um pedido que force efetivamente o modelo a consultar o repositório, como «explique-me a arquitetura do projeto fastapi/fastapi». Se a resposta chegar e citar a estrutura real do projeto, a sua ligação MCP está operacional.

De seguida, adicione uma ferramenta nativa para ver o Grok a arbitrar entre duas fontes de naturezas diferentes. A descrição do servidor torna-se útil aqui, precisamente porque agora há uma escolha a fazer.

tools=[
    mcp(
        server_url="https://mcp.deepwiki.com/mcp",
        server_label="deepwiki",
        server_description="Documentação para projetos open-source no GitHub"
    ),
    {"type": "web_search"},
]

Finalmente, dê o passo para um servidor interno, com autenticação e restrição de ferramentas. É neste passo que tudo o que viu sobre segurança se torna concreto.

tools=[
    mcp(server_url="https://mcp.deepwiki.com/mcp", server_label="deepwiki"),
    mcp(
        server_url="https://api.your-server.com/mcp",
        server_label="internal",
        server_description="Dados e ferramentas internos da empresa",
        authorization=f"Bearer {os.getenv('INTERNAL_TOKEN')}",
        allowed_tool_names=["search", "get_document"]
    ),
    {"type": "web_search"},
]

O que Permanece Verdadeiro Após Este Curso

Quatro limitações acompanharão todos os seus projetos MCP com o Grok. A API de Responses no formato OpenAI não suporta nem require_approval nem connector_id, o que o remete para o SDK nativo sempre que desejar validação humana antes da execução. O transporte stdio, e consequentemente os servidores MCP locais, permanece fora de alcance: apenas HTTPS. Cada ferramenta exposta consome contexto, tornando o minimalismo uma decisão arquitetural e não um pensamento posterior. E a latência de rede acumula-se a cada chamada, pelo que um agente que encadeie várias ferramentas MCP responderá mais lentamente do que um agente que chame apenas uma.

Nenhuma destas restrições são bloqueantes. Todas são contornadas por escolhas de design feitas com pleno conhecimento, que é precisamente o que este curso lhe proporcionou.

Pontos-chave

  • O MCP remoto liga o Grok a ferramentas externas via HTTPS em poucas linhas de configuração
  • Seis parâmetros bastam para configurar um servidor MCP (dois obrigatórios, quatro opcionais)
  • A segurança assenta no trio HTTPS + autenticação + restrição de ferramentas
  • Comece com um servidor público (DeepWiki) e progrida para múltiplos servidores autenticados
  • Combine MCP e ferramentas nativas para criar agentes versáteis

Teste os Seus Conhecimentos

Servidores MCP remotos na API do Grok: ganhou este recapitulativo.

1. O que permite o suporte de MCP na API do Grok?

Resposta: Ligar servidores MCP remotos como ferramentas do modelo: o Grok invoca as suas capacidades durante a geração — os seus sistemas e o ecossistema MCP tornam-se extensões.

2. Como declara um servidor MCP num pedido?

Resposta: Através de server_url e server_label, com descrição e lista de permissão de ferramentas autorizadas — e os cabeçalhos de autenticação necessários para o acesso.

3. O que permite a configuração multi-servidor?

Resposta: Combinar vários servidores MCP num único pedido — cada um rotulado — e misturá-los com ferramentas integradas (web, X): a orquestração permanece com o modelo.

4. Quais os transportes suportados?

Resposta: Streaming HTTP e SSE — os transportes remotos do protocolo: o servidor reside onde quiser, a API liga-se a ele.

5. Quais as regras de segurança para servidores remotos?

Resposta: Autorize apenas as ferramentas necessárias, autentique-se seriamente e trate as respostas do servidor como dados a validar — um servidor MCP de terceiros é uma superfície de ataque potencial.

Declare, restrinja, autentique, combine: o MCP remoto estende o Grok aos seus sistemas — sob as suas regras.