Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

Protocolos de Integração entre Modelos Computacionais


Protocolos para conectar modelos computacionais distintos são conjuntos de regras, formatos e padrões que permitem a integração, comunicação e interoperabilidade entre diferentes sistemas, algoritmos ou arquiteturas de modelagem. Eles atuam como pontes semânticas e estruturais, garantindo que os modelos compartilhem informações contextuais, metadados, entradas e saídas, mesmo quando desenvolvidos com linguagens, objetivos ou arquiteturas diferentes. Esses protocolos são fundamentais em cenários como sistemas multiagentes, gêmeos digitais, orquestração de modelos de IA, fluxos RAG e infraestruturas de MLOps, onde é necessário manter consistência, rastreabilidade e colaboração inteligente entre os diversos componentes do sistema.

Imagem ilustrando os protocolos de integração entre agentes de IA.

Figure 1:Imagem ilustrando os protocolos de integração entre agentes de IA.

Antes de abordarmos os protocolos de integração entre modelos computacionais, é importante garantir a compreensão de alguns conceitos fundamentais relacionados a redes, APIs, agentes inteligentes e fluxo de dados.

Além dos conhecimentos teóricos, também é recomendável familiaridade com determinadas ferramentas e bibliotecas que viabilizam a implementação prática desses protocolos, como plataformas de orquestração, frameworks de agentes e ambientes de teste com suporte à integração por API.

Alguns protocolos de integração entre agentes de IA e sistemas computacionais vêm sendo desenvolvidos com o objetivo de padronizar a comunicação entre modelos, agentes e ambientes. Entre os principais, destacam-se:

Neste e-book, optamos por aprofundar o Model Context Protocol (MCP) por três motivos principais:

Model Context Protocol

O Model Context Protocol (MCP) (MCP) é uma iniciativa aberta e recente que busca padronizar a comunicação entre modelos de linguagem e aplicações. Seu objetivo central é permitir que diferentes agentes de IA interajam com fontes de dados, APIs e sistemas legados de forma segura, consistente e escalável — sem a necessidade de integrações manuais e fragmentadas.

Imagine que você tem um assistente de IA superinteligente (como o ChatGPT ou o Claude), mas ele está isolado, sem acesso aos seus arquivos, e-mails, agendas ou sistemas corporativos. O MCP funciona como uma “ponte universal”, que permite conectar esse assistente a tudo isso, garantindo controle, segurança e estrutura na troca de informações.

Essa padronização torna-se essencial em ecossistemas mais complexos, nos quais coexistem LLMs proprietários, aplicações empresariais, repositórios sensíveis e ferramentas de automação. Ao criar uma interface comum entre esses elementos, o MCP promove interoperabilidade real e reduz drasticamente os atritos técnicos.

Além disso, o protocolo foi desenvolvido com foco em modularidade e clareza. Em vez de construir integrações do zero para cada agente, você pode utilizar os blocos definidos no MCP para orquestrar fluxos, registrar raciocínios e controlar interações com outros sistemas.

Você pode se aprofundar acessando a documentação oficial do Model Context Protocol ou outras fontes como Canal YouTube (2024)Sakal (2024).

Por que o MCP Existe?

O Problema Antes do MCP

A Solução do MCP

Cada empresa criava sua própria forma de conectar IA aos seus sistemas

Um padrão único que funciona para todas as aplicações de IA

Muito trabalho duplicado e incompatibilidade entre soluções

Qualquer ferramenta que implemente MCP pode ser usada por qualquer aplicação de IA compatível

Desenvolvedores precisavam criar integrações específicas para cada ferramenta

Redução drástica do tempo de desenvolvimento

Usuários ficavam limitados aos sistemas que cada aplicação de IA conseguia acessar

Maior segurança e controle sobre as integrações

A Filosofia e Motivação por Trás do MCP

A motivação central por trás do MCP, especialmente para a Anthropic, é a premissa de que “modelos são tão bons quanto o contexto que lhes fornecemos”. Há alguns anos, a integração de contexto em chatbots ou aplicações de IA era muitas vezes feita por meio de copiar e colar ou digitação manual. No entanto, a evolução levou a sistemas onde os modelos precisam de “ganchos” diretos em seus dados e contexto, tornando-os mais poderosos e personalizados.

O que a Anthropic observou antes do MCP era uma grande fragmentação na forma como as empresas e equipes construíam sistemas de IA. Cada equipe criava suas próprias implementações personalizadas para conectar LLMs a dados e ferramentas, com lógicas de prompt e formas de federação de acesso diferentes. Isso resultava em um problema “N vezes M”, onde havia inúmeras permutações para a interação entre aplicações cliente e servidores.

O MCP nasceu para padronizar esse desenvolvimento de IA, atuando como uma camada intermediária que “achata” essa complexidade. Ele busca ser para as aplicações de IA o que as APIs foram para a interação entre frontend e backend da web, ou o que o Language Server Protocol (LSP) é para a padronização da interação de IDEs com ferramentas específicas de linguagem.

MCP versus Outras Soluções

Para entender melhor o valor do MCP, vamos compará-lo com outras abordagens existentes:

AspectoMCPAPIs REST TradicionaisWebhooksPlugins Específicos
PadronizaçãoProtocolo únicoCada API é diferenteImplementação variaEspecífico por aplicação
BidirecionalidadeCliente ↔ ServidorPrincipalmente Cliente → ServidorServidor → ClienteVaria
Tempo RealSuporte nativoPolling necessárioPush notificationsVaria
Descoberta AutomáticaCapacidades expostasDocumentação manualConfiguração manualManual
Controle de AcessoGranular e padronizadoVaria por APILimitadoVaria
Facilidade de IntegraçãoUma vez implementado, funciona com todosIntegração por APIConfiguração por webhookPor aplicação

Para ajudar na escolha do protocolo mais adequado ao seu cenário, a tabela a seguir compara MCP, APIs REST, Webhooks e Plugins Específicos em diferentes situações de uso. Ela mostra, de forma visual, onde cada abordagem é recomendada ✅, possível mas com limitações ⚠️ ou não recomendada ❌.

Situação de UsoMCPAPIs RESTWebhooksPlugins Específicos
Conectar IA a múltiplos sistemas✅❌❌❌
Solução padronizada e reutilizável✅❌❌❌
Aproveitar ecossistema existente✅❌❌❌
Comunicação bidirecional em tempo real✅❌⚠️ (limitada)❌
Integração simples e específica❌✅⚠️✅
Sem necessidade de IA avançada❌✅✅✅
Já existe API REST disponível❌✅❌❌
Notificações simples❌❌✅❌
Comunicação unidirecional❌✅✅✅
Requisitos específicos de tempo real❌❌✅❌
Aplicação única❌✅✅✅
Funcionalidades muito específicas❌⚠️✅✅
Aplicação sem suporte a MCP❌✅✅✅

Arquitetura Central do MCP

A arquitetura central do MCP se baseia em uma estrutura cliente-servidor robusta e modular, projetada para facilitar a integração entre modelos de IA e sistemas externos. Para quem deseja se aprofundar nos detalhes dessa arquitetura, recomendamos a leitura da documentação oficial e de recursos complementares disponíveis em Anthropic (2024)DeepLearning.AI (2024)Microsoft (2024).

Componentes Detalhados

Fluxo de Comunicação

  1. Inicialização: Host inicia e configura conexões com servidores

  2. Descoberta: Cliente solicita capacidades de cada servidor

  3. Disponibilização: Servidor informa suas ferramentas, recursos e prompts

  4. Uso: Usuário interage com Host, que decide quando usar cada capacidade

  5. Execução: Cliente invoca ferramentas do servidor conforme necessário

  6. Resultado: Servidor processa e retorna resultados ao cliente/host

Na prática:

Componentes Primários do protocolo

O MCP padroniza as interações em três interfaces principais, além de outras funcionalidades:

1. Ferramentas (Tools)

As ferramentas no contexto do Model Context Protocol (MCP) são funcionalidades expostas pelo servidor MCP que podem ser utilizadas pelos modelos de linguagem (LLMs) durante a execução de tarefas. Elas funcionam como extensões das capacidades do modelo, permitindo que ele interaja com o mundo externo de maneira programada.

Essas ferramentas são o que transformam um modelo estático em um agente dinâmico e funcional, capaz de realizar operações complexas, acessar bancos de dados, interagir com APIs, ou controlar outros sistemas integrados.

Exemplos de Ferramentas:

Pense neste bloco de código JSON abaixo como o “cardápio” ou a “etiqueta de instruções” de uma ferramenta. Este JSON não é a ferramenta que executa a ação, mas sim a definição que o protocolo (MCP) lê para entender o que a ferramenta faz e o que ela precisa.

{
  "name": "send_email",
  "description": "Enviar email para um destinatário",
  "inputSchema": {
    "type": "object",
    "properties": {
      "to": {
        "type": "string",
        "description": "Email do destinatário"
      },
      "subject": {
        "type": "string",
        "description": "Assunto do email"
      },
      "body": {
        "type": "string",
        "description": "Corpo do email"
      }
    },
    "required": ["to", "subject", "body"]
  }
}

Uso Prático

Imagine que você está conversando com um agente de IA e pede:

Usuário diz(Você): “Envie um email para a equipe@empresa.com sobre a Reunião Semanal. Avise que o link da chamada foi atualizado.”

A IA, então, usa a definição (o seu JSON) como um “formulário” para preencher, e assim poder passar como argumento, para a função em python(ou qualquer outra linguagem de programação) que de fato vai executar a ação “send_email”.

A IA traduz seu pedido de linguagem natural para a estrutura exata que a definição da ferramenta exige:

{
  "name": "send_email",
  "arguments": {
    "to": "equipe@empresa.com",
    "subject": "Reunião Semanal",
    "body": "Aviso: o link da chamada foi atualizado."
  }
}

A ferramenta real de envio de email é executada(A função em python) no servidor e retorna uma confirmação:

{
  "status": "sucesso",
  "destinatario": "equipe@empresa.com",
  "horario_envio": "2025-11-13T15:15:00Z"
}
2. Recursos (Resources)

Os recursos no contexto do MCP são dados disponibilizados pela aplicação (ou MCP Host) para enriquecer o contexto da conversa. Diferentemente das ferramentas, os recursos não são invocados diretamente pelo LLM. Em vez disso, são anexados ao contexto de forma automática, fornecendo informações adicionais que auxiliam o modelo a gerar respostas mais completas e contextualizadas.

Exemplos de Recursos:

Este JSON abaixo não é o dado em si, mas sim a definição que o protocolo (MCP) usa para dizer ao modelo de IA: “Ei, este dado existe, este é o nome dele (name), é deste tipo (mimeType), e aqui está a descrição do que ele contém (description).”

Isso permite que a aplicação/cliente (o Host) saiba quais dados ela pode pegar da estante para entregar ao modelo de IA quando ele precisar de contexto.

{

"uri": "file:///home/user/project/README.md",

"name": "Project Documentation",

"description": "Documentação principal do projeto",

"mimeType": "text/markdown"

}

Uso Prático

Pense que você está conversando com um assistente de IA que está integrado ao seu computador e tem acesso a esse recurso.

Usuário diz(Você): “Como eu faço a instalação deste projeto?”

A aplicação (o Host) percebe que você está perguntando sobre o projeto. Ela usa a definição do recurso para entender que file:///.../README.md é a “Documentação principal do projeto” e que é um arquivo de texto.

Diferente de uma ferramenta, a IA não “chama” o arquivo. Em vez disso, o Host (a aplicação) “pega os dados” e o “anexa” à conversa para a IA ler.Com esse contexto, a IA pode responder sua pergunta de forma mais “inteligente”.

3. Prompts

Os prompts funcionam como templates configuráveis ou atalhos inteligentes que os usuários podem utilizar para iniciar fluxos específicos de conversa com o modelo. Eles encapsulam instruções complexas em comandos simples, semelhantes a “comandos de barra” (ex: /resumir-documento ou /gerar-relatório), permitindo ao usuário acionar comportamentos predefinidos de forma rápida e consistente.

Estrutura de um Prompt:

Pense neste bloco de código como a “criação de um atalho” ou um “comando de barra” personalizado (como /resumir ou /traduzir em um chat).

Este JSON não executa a tarefa sozinho. Ele é a definição que o protocolo (MCP) usa para:

1.Saber que este “atalho” (name) existe.

2.Entender o que ele faz (description).

3.Saber quais “opções” ou “filtros” (arguments) ele aceita.

Por exemplo, a definição summarize_code abaixo diz ao sistema:

"Ei, eu tenho um atalho chamado summarize_code.

O que ele faz? Resumir arquivos de código do projeto.

Quais opções ele aceita? Ele aceita um argumento opcional (required: false) chamado file_pattern, que serve para filtrar quais arquivos resumir (por exemplo, *.py ou main.js)."

{
  "name": "summarize_code",
  "description": "Resumir arquivos de código do projeto",
  "arguments": [
    {
      "name": "file_pattern",
      "description": "Padrão de arquivos a resumir (ex: *.py)",
      "required": false
    }
  ]
}

Uso Prático

Imagine que você é um desenvolvedor e quer um resumo rápido de todos os arquivos Python do seu projeto. Você usa o “atalho” que acabou de ser definido.

Usuário digita(Você): /summarize_code *.py

O Host (a aplicação onde você está digitando) reconhece o comando /summarize_code. Ele usa a definição do prompt para entender o que fazer com o texto *.py. O Host traduz seu comando para a estrutura exata que a definição do prompt exige:

{
  "name": "summarize_code",
  "arguments": {
    "file_pattern": "*.py"
  }
}

Por que isso é importante? A definição garantiu que o Host soubesse que *.py era um valor para o argumento file_pattern.

OUTPUT (A Resposta da IA) A “implementação” deste prompt (uma função no servidor, como vimos nos códigos Python) é acionada. Ela:

1.Recebe file_pattern: “*.py”.

2.Busca todos os arquivos *.py no contexto atual.

3.Monta uma instrução complexa para a IA (ex: “Resuma os seguintes arquivos: [conteúdo do main.py], [conteúdo do utils.py]...”).

4.A IA processa tudo e te entrega o resultado final:

Exemplos de Mensagens Comuns

Antes de entender os exemplos, é importante saber o que são essas mensagens.

No MCP, a comunicação entre o Cliente (como um agente de IA ou aplicativo) e o Servidor (que fornece dados, como papers ou APIs) ocorre por meio de um protocolo padronizado chamado JSON-RPC.

Esse formato define com precisão como as mensagens devem ser estruturadas, enviadas e interpretadas, permitindo que diferentes sistemas se comuniquem de forma segura e padronizada.

Analogia para Entender

Imagine um atendimento em um drive-thru:

Assim também funciona a comunicação no MCP:

Todas as mensagens seguem esse padrão de “pergunta → resposta”.


Estrutura Básica das Mensagens

Toda mensagem JSON-RPC tem estes elementos:

{
  "jsonrpc": "2.0",
  "id": "1",
  "method": "fazer_algo",
  "params": {
    "dado1": "valor1"
  }
}
  1. Inicialização da Conexão

Antes de qualquer troca de dados úteis, cliente e servidor precisam se reconhecer e alinhar capacidades. É nesse momento que ocorre a inicialização da conexão, uma etapa essencial para estabelecer uma comunicação clara e segura.

A seguir, apresentamos o script em formato JSON que representa essa etapa inicial de comunicação, onde cliente e servidor trocam suas primeiras informações para estabelecer a conexão.

{
  "jsonrpc": "2.0",
  "id": "1",
  "method": "initialize",
  "params": {
    "protocolVersion": "2024-11-05",
    "capabilities": {
      "tools": {},
      "resources": {},
      "prompts": {}
    },
    "clientInfo": {
      "name": "ExampleClient",
      "version": "1.0.0"
    }
  }
}

Tradução em português:

Cliente: "Olá servidor! Sou o ExampleClient versão 1.0.0.
         Uso o protocolo MCP versão 2024-11-05.
         Posso trabalhar com ferramentas, recursos e prompts.
         Você pode me responder?"

Servidor responde: “Oi! Eu posso fazer isso...”

{
  "jsonrpc": "2.0",
  "id": "1",
  "result": {
    "protocolVersion": "2024-11-05",
    "capabilities": {
      "tools": {
        "listChanged": true
      },
      "resources": {
        "subscribe": true,
        "listChanged": true
      },
      "prompts": {
        "listChanged": true
      }
    },
    "serverInfo": {
      "name": "ExampleServer",
      "version": "1.0.0"
    }
  }
}

Tradução em português:

Servidor: "Olá ExampleClient! Sou o ExampleServer versão 1.0.0.
           Também uso o protocolo MCP versão 2024-11-05.
           
           Minhas capacidades:
           ✅ Ferramentas: Posso notificar quando a lista mudar
           ✅ Recursos: Você pode se inscrever e serei notificado sobre mudanças
           ✅ Prompts: Posso notificar quando a lista mudar
           
           Estamos conectados!"
  1. Listagem de Ferramentas Disponíveis

Após o processo de inicialização, o próximo passo é a descoberta de capacidades.

Neste momento, o cliente envia uma solicitação ao servidor perguntando quais ferramentas estão disponíveis para uso. Essa listagem permite que o modelo saiba o que está ao seu alcance — funções, integrações e recursos que pode utilizar durante uma interação.

É como entrar em uma oficina e perguntar:  
**"Quais ferramentas vocês têm aí? Martelo? Chave de fenda? Furadeira?"**  
O servidor responde com a lista do que tem disponível, e o modelo decide como usar essas ferramentas conforme necessário.

Cliente pergunta: “Que ferramentas você oferece?”

{
  "jsonrpc": "2.0",
  "id": "2",
  "method": "tools/list"
}

Tradução em português:

Cliente: "Me mostre a lista de todas as ferramentas disponíveis."

Servidor responde: “Tenho estas ferramentas...”

{
  "jsonrpc": "2.0",
  "id": "2",
  "result": {
    "tools": [
      {
        "name": "get_weather",
        "description": "Obter informações meteorológicas",
        "inputSchema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "Cidade para consultar o clima"
            }
          },
          "required": ["location"]
        }
      }
    ]
  }
}

Tradução em português:

Servidor: "Tenho 1 ferramenta disponível:

           📍 Nome: get_weather
           📝 O que faz: Busca informações sobre o clima
           
           Como usar:
           - Você DEVE me dar: 'location' (nome da cidade)
           - location deve ser texto (string)
           - Exemplo: 'São Paulo', 'Rio de Janeiro'
           
           Pronto! É só chamar essa ferramenta quando precisar."
  1. Execução de uma Ferramenta

Após conhecer as ferramentas disponíveis, o cliente pode invocar uma delas para executar uma ação específica.
Essa etapa representa o momento em que o modelo passa da descoberta para a execução, colocando em prática uma funcionalidade oferecida pelo servidor.

Por exemplo, se entre as ferramentas listadas há uma chamada get_weather, o cliente pode enviar uma solicitação como:

“Quero usar a ferramenta get_weather para consultar a previsão do tempo em São Paulo.”

Esse processo é essencial para que o LLM realize operações externas, como consultas a APIs, cálculos personalizados ou acesso a sistemas, expandindo suas capacidades além do texto gerado localmente.

É como estar em uma oficina: depois de saber que há um **termômetro**, você diz —  
**"Ok, quero usar essa ferramenta para medir a temperatura agora!"**  
O servidor então executa a função e retorna o resultado solicitado.  

Veja os comandos utilizados para uma execução em JSON:

Cliente chama: “Use a ferramenta X com estes dados”

{
  "jsonrpc": "2.0",
  "id": "3",
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "location": "São Paulo"
    }
  }
}

Tradução em português:

Cliente: "Quero EXECUTAR a ferramenta 'get_weather'.
         
         Os dados que estou enviando são:
         📍 location: 'São Paulo'
         
         Me retorne o resultado, por favor!"

Servidor responde: “Aqui está o resultado!”

{
  "jsonrpc": "2.0",
  "id": "3",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Clima em São Paulo: 25°C, ensolarado, umidade 60%"
      }
    ]
  }
}

Tradução em português:

Servidor: "Executei a ferramenta 'get_weather' para São Paulo.
           
           Resultado:
           🌡️ Temperatura: 25°C
           ☀️ Condição: Ensolarado
           💧 Umidade: 60%
           
           Tudo certo!"

Exemplo Real do Nosso Projeto

A seguir, apresentamos um exemplo real extraído do nosso projeto, ilustrando como o cliente pode chamar uma ferramenta de busca de papers para recuperar informações acadêmicas. Este é um exemplo prático de comunicação entre cliente e servidor utilizando o MCP, a troca de mensagens segue o padrão JSON-RPC.

Cliente pede:

{
  "jsonrpc": "2.0",
  "id": "3",
  "method": "tools/call",
  "params": {
    "name": "search_papers",
    "arguments": {
      "query": "artificial intelligence",
      "max_results": 3
    }
  }
}

O cliente está solicitando ao servidor que execute uma ferramenta chamada search_papers, com os seguintes argumentos:

Essa chamada equivale a dizer:

“Servidor, por favor, busque 3 artigos sobre inteligência artificial.”

Servidor responde:

{
  "jsonrpc": "2.0",
  "id": "3",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Encontrados 3 papers sobre 'artificial intelligence':\n\n1. Deep Learning Advances (2024)\n   Autores: John Smith, Jane Doe\n   ArXiv: 2409.12345\n\n2. Neural Networks Review (2024)\n   Autores: Bob Johnson\n   ArXiv: 2409.54321\n\n3. AI Ethics Study (2024)\n   Autores: Alice Brown\n   ArXiv: 2409.98765"
      }
    ]
  }
}

O servidor compreendeu a solicitação e devolveu um resultado com 3 artigos, contendo:


Tratamento de Erros

O que acontece se algo sair do esperado?

Quando ocorre uma falha durante a comunicação, o servidor não retorna um campo result, como em uma resposta bem-sucedida.
Em vez disso, ele envia uma mensagem de erro estruturada, contendo informações sobre o que deu errado.

Isso permite que o cliente trate adequadamente a situação — por exemplo, exibindo uma mensagem ao usuário ou tentando novamente com outros parâmetros.

Exemplo: Ferramenta não encontrada

{
  "jsonrpc": "2.0",
  "id": "3",
  "error": {
    "code": -32601,
    "message": "Method not found",
    "data": {
      "detail": "A ferramenta 'get_clima' não existe. Ferramentas disponíveis: get_weather"
    }
  }
}

Tradução:

Servidor: "ERRO! A ferramenta que você pediu não existe.
           
           🔴 Código do erro: -32601 (Método não encontrado)
           📝 Mensagem: Method not found
           ℹ️ Detalhes: A ferramenta 'get_clima' não existe.
                       Ferramentas disponíveis: get_weather"

Fluxo Completo de Comunicação

Sequência típica de uso

  1. INICIALIZAÇÃO Cliente: "initialize" → Servidor: "Ok, conectado!"

  2. DESCOBERTA Cliente: "tools/list" → Servidor: "Tenho estas ferramentas..."

  3. EXECUÇÃO (pode repetir várias vezes) Cliente: "tools/call get_weather" → Servidor: "25°C, sol" Cliente: "tools/call search_papers" → Servidor: "Encontrei 5 papers" Cliente: "tools/call analyze_papers" → Servidor: "Análise completa..."

  4. FINALIZAÇÃO Cliente fecha a conexão

Diagrama Visual

┌─────────┐                           ┌─────────┐
│ CLIENTE │                           │SERVIDOR │
└────┬────┘                           └────┬────┘
     │                                     │
     │  1. initialize                      │
     │────────────────────────────────────>│
     │                                     │
     │  2. Conectado + Capacidades         │
     │<────────────────────────────────────│
     │                                     │
     │  3. tools/list                      │
     │────────────────────────────────────>│
     │                                     │
     │  4. Lista de ferramentas            │
     │<────────────────────────────────────│
     │                                     │
     │  5. tools/call "get_weather"        │
     │────────────────────────────────────>│
     │                                     │
     │  6. Resultado: "25°C, sol"          │
     │<────────────────────────────────────│
     │                                     │

Resumindo...

Analogia: Restaurante

1. INITIALIZE = Entrar no restaurante e ser recebido
   "Boa noite! Bem-vindo ao restaurante!"

2. TOOLS/LIST = Pedir o cardápio
   "Aqui está nosso menu: pizza, hambúrguer, salada..."

3. TOOLS/CALL = Fazer o pedido
   "Quero uma pizza margherita"
   → "Sua pizza está pronta!"

Dicas Práticas

Antes de finalizar, vale destacar algumas boas práticas tanto para quem desenvolve quanto para quem utiliza integrações com o MCP.


Recursos Adicionais

Abaixo estão listados alguns recursos úteis para aprofundar o entendimento e aplicar na prática o que foi apresentado até o momento. Esses materiais complementares ajudam tanto no domínio da estrutura de mensagens quanto na validação e aplicação real do MCP:

Outras Capacidades Essenciais

O MCP oferece ainda um conjunto de capacidades avançadas que ampliam sua flexibilidade e inteligência. Elas tornam possível controlar o comportamento do modelo, organizar fluxos de interação e extrair informações de forma mais precisa e estruturada. Para se aprofundar nesses conceitos, recomendamos a leitura dos materiais Canal YouTube (2024)Anthropic (2024).

1. Composability (Componibilidade)

Uma característica poderosa do MCP é que qualquer aplicação, API ou agente pode ser tanto um cliente MCP quanto um servidor MCP simultaneamente. Isso permite criar arquiteturas complexas e em camadas.

Como Cliente, usa:

Como Servidor, expõe:

Web Search MCP Server

research_topic()

Database MCP Server

summarize_findings()

File System MCP Server

generate_report()

2. Sampling (Amostragem)

Permite que um servidor MCP solicite inferências (chamadas de LLM) do cliente, sem precisar hospedar seu próprio modelo.

Por que isso é poderoso?

  1. Simplicidade no servidor
    O servidor permanece leve e direto, sem precisar incorporar capacidades próprias de IA.

  2. Controle total
    Você mantém o controle sobre os custos e a privacidade, já que toda a inteligência vem do seu próprio modelo de linguagem (LLM).

O script abaixo cria uma solicitação de amostragem (sampling) para o modelo de linguagem, pedindo que ele classifique um e-mail em uma das três categorias — urgente, normal ou baixa prioridade —, utilizando o modelo preferencial Claude 3 Sonnet.

{
  "jsonrpc": "2.0",
  "method": "sampling/createMessage",
  "params": {
    "messages": [
      {
        "role": "user",
        "content": {
          "type": "text",
          "text": "Classifique este email como urgente, normal ou baixa prioridade: [email content...]"
        }
      }
    ],
    "modelPreferences": {
      "hints": [
        {
          "name": "claude-3-sonnet"
        }
      ]
    }
  }
}

3. Elicitation (Elicitação)

Capacidade que permite ao servidor solicitar informações adicionais dos usuários durante a execução de uma ferramenta.

{
  "jsonrpc": "2.0",
  "method": "elicitation/request",
  "params": {
    "prompt": "Confirmar reserva do restaurante X para 4 pessoas às 19h?",
    "options": ["Confirmar", "Cancelar", "Alterar horário"]
    }
 }

4. Completions (Conclusões/Sugestões)

O MCP suporta autocompletar para argumentos de prompt e parâmetros de recursos.

Implementação:

Cliente solicita sugestões

{
  "jsonrpc": "2.0",
  "id": "4",
  "method": "completion/complete",
  "params": {
    "ref": {
      "type": "prompt",
      "name": "analyze_data"
    },
    "argument": {
      "name": "data_source",
      "value": "sales_"
    }
  }
}

Servidor retorna sugestões

{
  "jsonrpc": "2.0",
  "id": "4",
  "result": {
    "completion": {
      "values": [
        "sales_2024",
        "sales_monthly",
        "sales_quarterly"
      ],
      "total": 3,
      "hasMore": false
    }
  }
}

5. Authentication (Autenticação)

Os servidores MCP podem implementar OAuth 2.0/2.1 para acessar recursos protegidos.

Exemplo de configuração:

{
  "mcpServers": {
    "google-drive": {
      "command": "mcp-server-google-drive",
      "env": {
        "GOOGLE_CLIENT_ID": "your-client-id",
        "GOOGLE_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}

6. Notifications (Notificações)

Servidores podem enviar notificações para clientes sobre mudanças de estado.

O script do exemplo abaixo envia uma notificação ao servidor informando que o recurso localizado no URI file:///project/config.json foi atualizado, permitindo que o servidor reaja a essa mudança se necessário (como recarregar o arquivo ou ajustar o contexto).

{
   "jsonrpc": "2.0",
   "method": "notifications/resources/updated",
   "params": {
      "uri": "file:///project/config.json"
    }
}

7. Transports (Transportes)

O MCP suporta diferentes mecanismos de comunicação:

Transporte Local (STDIO)

Transporte Remoto (HTTP/SSE)

  • Comunicação via entrada/saída padrão

  • Ideal para servidores locais

  • Baixa latência, alta segurança

  • Comunicação via HTTP com Server-Sent Events

  • Permite servidores remotos

  • Suporte a múltiplos clientes

Configuração de Transporte:

{
  "mcpServers": {
    "local-server": {
      "command": "python",
      "args": [
        "server.py"
      ],
      "transport": "stdio"
    },
    "remote-server": {
      "url": "https://api.example.com/mcp",
      "transport": "http"
    }
  }
}

Limitações e Considerações de Segurança

As implementações do MCP trazem avanços significativos em interoperabilidade e integração entre modelos de IA, mas é essencial compreender suas limitações técnicas e riscos de segurança. Antes de aplicar o MCP em ambientes produtivos, recomenda-se avaliar aspectos como exposição de dados sensíveis, controle de acesso, auditoria de logs e tratamento de falhas, garantindo que a adoção do protocolo seja feita de forma segura e escalável. Para saber mais sobre limitações e considerações de segurança consulte, Data Science Academy (2024)Neo4j (2024).

1. Limitações do MCP

Limitações de Performance

Limitações Funcionais

Latência de Rede: Servidores remotos podem ter latência alta

Stateless: Servidores MCP são geralmente stateless entre requisições

Throughput: Limitado pela capacidade do transporte (HTTP vs STDIO)

Transações: Não há suporte nativo para transações distribuídas

Concorrência: Nem todos os servidores suportam requisições paralelas

Streaming de Dados: Limitado para grandes volumes de dados

Timeout: Operações longas podem exceder limites de timeout

Compatibilidade: Nem todas as ferramentas/APIs têm servidor MCP

2. Considerações de Segurança

Antes de implementar qualquer integração baseada em MCP, é fundamental compreender as considerações de segurança que garantem o uso confiável do protocolo. A proteção de dados sensíveis e o controle de acesso são pilares para manter a integridade e a confidencialidade do sistema.

Autenticação e Autorização

{
  "mcpServers": {
    "database-server": {
      "command": "mcp-database-server",
      "env": {
        "DB_CONNECTION": "postgresql://user:pass@localhost/db",
        "ALLOWED_OPERATIONS": "SELECT, INSERT",
        "MAX_ROWS": "1000"
      }
    }
  }
}

Controle de Acesso

Exemplo de verificação de permissões

def verify_permissions(operation, resource):
    if operation == "DELETE" and not user.has_permission("admin"):
        raise PermissionError("Operação DELETE requer permissão de admin")
    if resource.startswith("/system/") and not user.has_permission("system"):
        raise PermissionError("Acesso a recursos do sistema negado")

Isolamento e Sandboxing

Auditoria e Logging

Sistema de registro que monitora e documenta todas as operações realizadas através do MCP. É como ter um “diário detalhado” de tudo que acontece entre cliente e servidor.

Informações Registradas

Durante as interações no contexto do MCP, é essencial registrar detalhes operacionais para garantir segurança, rastreabilidade e auditoria adequada. Abaixo estão os principais elementos recomendados para registro:

Exemplo Prático:

import logging
from datetime import datetime

def log_mcp_operation(tool_name, params, user_id, result_status):
    logging.info({
        "timestamp": datetime.utcnow().isoformat(),
        "tool": tool_name,
        "user": user_id,
        "params": params,
        "status": result_status,
        "type": "mcp_operation"
    })

Benefícios do MCP

O MCP oferece vantagens significativas para todo o ecossistema de IA:

1. Para Desenvolvedores de Aplicações

2. Para Provedores de Ferramentas/APIs

3. Para Usuários Finais

4. Para Empresas

5. Para o Ecossistema de IA

Aplicação Prática: Sistema MCP para Busca e Análise de Papers Acadêmicos

Agora que compreendemos os conceitos e estruturas fundamentais do MCP, é hora de visualizar esses conhecimentos em ação. A seguir, apresentaremos uma aplicação prática, que demonstra passo a passo como implementar as funcionalidades do MCP em um cenário real.

Trata-se de um Sistema MCP para Busca e Análise de Papers Acadêmicos — uma solução completa que permite buscar, analisar e interagir com artigos científicos utilizando o protocolo MCP aliado à inteligência artificial. Esse exemplo mostra como integrar agentes com ferramentas externas, manipulando dados em tempo real e simulando conversas orientadas por LLMs.

Você pode acessar todo o código comentado desta aplicação clicando aqui.

O que é este projeto? Este é um sistema que permite:

Como funciona? O sistema possui duas partes:

  1. Servidor MCP (mcp_papers_server.py): O “cérebro” que busca artigos e usa IA

  2. Cliente MCP (mcp_papers_client.py): A interface que você usa para interagir

Você → Cliente → Servidor → ArXiv/Gemini IA
                    ↓
              Resultados
                    ↓
              Você recebe

Requisitos

Antes de iniciar a aplicação, certifique-se de que os seguintes requisitos estão atendidos no seu ambiente:

Instalação Completa (Passo a Passo)

Passo 1: Preparar o Ambiente

1.1 Criar a estrutura de pastas

Crie uma pasta para o projeto:

# Windows (no prompt de comando)
mkdir CHATBOT-PAPERS
cd CHATBOT-PAPERS
mkdir Servidores
mkdir Servidores\logs

# Linux/Mac (no terminal)
mkdir -p CHATBOT-PAPERS/Servidores/logs
cd CHATBOT-PAPERS

Estrutura final:

CHATBOT-PAPERS/
├── .venv/                      # Ambiente virtual (será criado)
├── Servidores/
│   ├── logs/                   # Logs do sistema
│   ├── .env                    # Configurações (criar)
│   ├── mcp_papers_server.py    # Servidor (criar)
│   ├── mcp_papers_client.py    # Cliente (criar)
│   └── requirements.txt        # Dependências (criar)

1.2 Criar ambiente virtual

Por que fazer isso? Para isolar as dependências do projeto e não bagunçar seu Python.

# Windows
python -m venv .venv
.venv\Scripts\activate

# Linux/Mac
python3 -m venv .venv
source .venv/bin/activate

Passo 2: Instalar Dependências

2.1 Criar arquivo requirements.txt

Na pasta Servidores, crie o arquivo requirements.txt:

# Dependências principais
fastmcp>=0.1.0
arxiv>=2.0.0
google-generativeai>=0.3.0
python-dotenv>=1.0.0

# Dependências do cliente
mcp>=0.1.0
colorama>=0.4.6

# Ferramentas de desenvolvimento (opcional)
mcp-inspector>=0.1.0

2.2 Instalar tudo de uma vez

cd Servidores
pip install -r requirements.txt

Passo 3: Configurar API Key

3.1 Obter sua chave API do Google Gemini

  1. Acesse: https://makersuite.google.com/app/apikey

  2. Faça login com sua conta Google

  3. Clique em “Create API Key”

  4. Copie a chave gerada

3.2 Criar arquivo .env

Na pasta Servidores, crie o arquivo .env:

# Chave da API do Google Gemini (OBRIGATÓRIO)
GOOGLE_API_KEY=sua_chave_api_aqui

# Configurações opcionais
MCP_SERVER_NAME=papers-academic-server
MCP_LOG_LEVEL=INFO

Passo 4: Adicionar os Códigos

4.1 Criar o servidor (mcp_papers_server.py)

Cole o código do servidor fornecido anteriormente.

4.2 Criar o cliente (mcp_papers_client.py)

Cole o código do cliente fornecido anteriormente.


Como Usar

Método 1: Modo Simples (Recomendado para Iniciantes)

Basta executar o cliente, que iniciará tudo automaticamente:

# Na pasta Servidores, com ambiente ativado
python mcp_papers_client.py

Método 2: Modo Avançado (Debug)

Execute servidor e cliente separadamente para ver logs detalhados:

Terminal 1 - Servidor:

cd CHATBOT-PAPERS/Servidores
.venv\Scripts\activate     # Windows
source .venv/bin/activate  # Linux/Mac
python mcp_papers_server.py

Terminal 2 - Cliente:

cd CHATBOT-PAPERS/Servidores
.venv\Scripts\activate     # Windows
source .venv/bin/activate  # Linux/Mac
python mcp_papers_client.py

Guia de Uso Interativo

Quando você executar o cliente, verá:

📚 Cliente MCP de Papers Acadêmicos
=================================

🔌 Conectando ao servidor MCP...
✅ Conectado com sucesso!
📦 6 ferramentas disponíveis

📋 Menu de Opções
========================================
  1 - Buscar papers
  2 - Ver detalhes de um paper
  3 - Analisar papers (resumo)
  4 - Analisar papers (tendências)
  5 - Analisar papers (comparação)
  6 - Chat sobre papers
  7 - Informações do cache
  8 - Limpar cache
  9 - Ajuda
  0 - Sair
========================================

Escolha uma opção:

Exemplo de Uso Completo

Buscar Papers sobre Inteligência Artificial

Escolha uma opção: 1
Digite os termos de busca: artificial intelligence ethics
Número de resultados (1-10, padrão 5): 5

🔍 Buscando papers...
✅ Encontrados 5 papers!

📄 Paper 1:
   Título: Ethics in AI: A Comprehensive Review
   Autores: John Smith, Jane Doe
   Data: 2024-09-15
   ArXiv ID: 2409.12345

Ver Detalhes de um Paper

Escolha uma opção: 2
Digite o número do paper (1-5): 1

📄 Detalhes do Paper
========================================
Título: Ethics in AI: A Comprehensive Review
Autores: John Smith, Jane Doe
Data de Publicação: 2024-09-15
ArXiv ID: 2409.12345
Link: https://arxiv.org/abs/2409.12345

📝 Resumo:
This paper reviews ethical considerations in artificial
intelligence systems, focusing on bias, transparency,
and accountability...

Gerar Análise Inteligente

Escolha uma opção: 3
🤖 Gerando análise com IA...

📊 RESUMO EXECUTIVO
========================================
Com base nos 5 papers analisados sobre ética em IA:

🔑 Principais Descobertas:
- Viés algorítmico é o tema mais recorrente
- Necessidade de frameworks regulatórios
- Importância da transparência em sistemas críticos

📈 Tendências:
- Crescente preocupação com privacidade
- Desenvolvimento de IA explicável (XAI)
- Foco em IA centrada no ser humano

Chat Interativo

Escolha uma opção: 6
Digite sua pergunta (ou 'voltar' para menu):
> Quais metodologias são mais usadas para detectar viés?

🤖 Resposta:
Baseado nos papers analisados, as principais metodologias
incluem:

1. Análise estatística de disparidade de impacto
2. Testes de fairness (equidade) em diferentes grupos
3. Auditoria algorítmica com datasets de teste
4. Métodos de interpretabilidade como SHAP e LIME

Os papers recomendam usar uma combinação de técnicas...

Digite sua pergunta (ou 'voltar' para menu):
> voltar

Funcionalidades Detalhadas

1. Busca de Papers (search_papers)

O que faz: Busca artigos no ArXiv

Parâmetros:

2. Detalhes do Paper (get_paper_details)

O que faz: Mostra informações completas de um artigo

Informações exibidas:

3. Análise com IA (analyze_papers)

O que faz: Usa Gemini para analisar os papers encontrados

Tipos de análise:

4. Chat Inteligente (chat_about_papers)

O que faz: Conversa sobre os papers em linguagem natural

5. Gerenciamento de Cache

O que é cache? Memória temporária que acelera respostas repetidas.

Comandos:


Monitoramento e Logs

Visualizar Logs em Tempo Real

Windows:

# Em um novo terminal
cd CHATBOT-PAPERS\Servidores
type logs\mcp_server.log

Linux/Mac:

# Visualização contínua
tail -f Servidores/logs/mcp_server.log

Entender os Logs

Formato dos logs:

2025-09-30 14:32:15 - INFO - Searching for: machine learning
2025-09-30 14:32:17 - INFO - Found 5 papers
2025-09-30 14:32:20 - ERROR - API key invalid

Casos de Uso Práticos

1. Revisão Bibliográfica Rápida

2. Identificar Tendências de Pesquisa

3. Comparar Abordagens


Segurança e Boas Práticas

Arquivo .gitignore recomendado

Para manter seu repositório limpo e evitar o versionamento de arquivos desnecessários, recomendamos utilizar um arquivo .gitignore adequado ao projeto.

# Ambiente virtual
.venv/
venv_mcp/

# Configurações sensíveis
.env
*.env

# Logs
logs/
*.log

# Python
__pycache__/
*.pyc
*.pyo
*.pyd

# IDE
.vscode/
.idea/
*.swp

Licença

Este projeto está sob a licença MIT. Veja o arquivo LICENSE para mais detalhes.

Observação: O que é uma licença MIT? A licença MIT é uma licença de software permissiva, curta e simples, que permite usar, copiar, modificar e distribuir o código-fonte livremente, até mesmo para fins comerciais, desde que o aviso de direitos autorais original e o texto da licença sejam incluídos em todas as cópias do software ou partes substanciais dele.


Recursos Úteis

Durante a implementação e aprofundamento no uso do MCP, é importante ter à mão algumas ferramentas e documentações de apoio. Abaixo estão links úteis das tecnologias usadas para acelerar o desenvolvimento e facilitar a integração com APIs e modelos de IA, desta aplicação:


References
  1. Canal YouTube. (2024). Workshop sobre Model Context Protocol. https://www.youtube.com/watch?v=kQmXtrmQ5Zg
  2. Sakal, N. (2024). MCP vs API: Model Context Protocol Explained. https://norahsakal.com/blog/mcp-vs-api-model-context-protocol-explained/
  3. Anthropic. (2024). Model Context Protocol - Documentação Oficial. Anthropic. https://modelcontextprotocol.io/introduction
  4. DeepLearning.AI. (2024). Build Rich Context AI Apps with Anthropic. DeepLearning.AI. https://www.deeplearning.ai/short-courses/mcp-build-rich-context-ai-apps-with-anthropic/
  5. Microsoft. (2024). MCP for Beginners - Tutorial Completo. Microsoft Corporation. https://github.com/microsoft/mcp-for-beginners/blob/main/translations/br/00-Introduction/README.md
  6. Data Science Academy. (2024). Model Context Protocol (MCP) para Sistemas de IA Generativa: Conceito, Aplicações e Desafios. Data Science Academy. https://blog.dsacademy.com.br/model-context-protocol-mcp-para-sistemas-de-ia-generativa-conceito-aplicacoes-e-desafios/
  7. Neo4j. (2024). Model Context Protocol: A Developer’s Guide. Neo4j Inc. https://neo4j.com/blog/developer/model-context-protocol/