Agente de IA Protocolo de Contexto do Modelo

Execução de código com MCP: uma nova abordagem para a eficiência de agentes de IA

com

atualizado em Jan 22, 2026

A proposta Anthropic introduziu um método no qual agentes de IA interagem com servidores do Protocolo de Contexto de Modelo (MCP) escrevendo código executável em vez de fazer chamadas diretas às ferramentas. O agente trata as ferramentas como arquivos em um computador, encontra o que precisa e as utiliza diretamente com o código, de modo que os dados intermediários não precisam passar pela memória do modelo. Testamos essa abordagem para verificar se ela reduz o custo em tokens, mantendo a mesma taxa de sucesso.

Execução de código com MCP versus MCP regular

Métrica	MCP regular	MCP com Execução de Código	Diferença
Taxa de sucesso	100%	100%	Mesmo
Latência média	9,66s	10,37s	+7%
Tokens de entrada médios	15.417	3.310	-78,5%
Tokens de saída média	87	192	+120%
Total de Tokens de Entrada	770.852	165.496	-78,5%
Total de Tokens de Saída	4.345	9.585	+120%
Total de todos os tokens	775.197	175.081	-77,4%

Comparamos duas abordagens para construir agentes de IA que interagem com ferramentas externas por meio do MCP:

MCP regular : Abordagem tradicional onde todas as definições de ferramentas são carregadas na janela de contexto do modelo.
Execução de código MCP : Nova abordagem em que o modelo escreve o código que chama as ferramentas, mantendo os dados intermediários fora de contexto.

Principais conclusões

Economia de tokens de entrada: a execução do código utiliza 78,5% menos tokens de entrada (165 mil contra 771 mil):

Cargas regulares geram aproximadamente 15.400 tokens de definições de ferramentas por chamada.
A execução do código requer apenas cerca de 3.300 tokens por chamada.

Maior número de tokens de saída: A abordagem de execução de código utiliza 2,2 vezes mais tokens de saída porque o modelo escreve código e explicações.

Economia líquida de tokens: redução total de 77,4% em tokens (de 175 mil para 775 mil).

Implicações de custo:

Os tokens de entrada são normalmente mais baratos que os tokens de saída.
Mas a economia de 78% nos insumos supera em muito o aumento de 2 vezes na produção.
Redução estimada de custos de aproximadamente 70% com a execução de código.

Ambos alcançaram uma taxa de sucesso de 100% nessas consultas com GPT-4.1.

A abordagem de execução de código foi inspirada na postagem de Anthropic sobre o uso de execução de código com MCP para reduzir o uso da janela de contexto, mantendo a capacidade do agente. ¹

Metodologia de execução de código com comparação MCP

Tarefas

Executamos cada tarefa 50 vezes para cada abordagem:

Acesse https://aimultiple.com/open-source-embedding-models e me diga quais são os 5 melhores desempenhos (ou seja, os modelos com 100% de precisão entre os 5 primeiros).
Acesse https://aimultiple.com/open-source-embedding-models e me diga qual modelo apresenta a maior latência.

Configuração de comparação

Utilizamos o servidor MCP de Bright Data com o modo profissional ativado, pois ele apresentou a maior precisão em nosso teste de benchmark MCP para navegadores.

Bright Data Servidor MCP: ferramentas de integração web para IA.

Visite o site

Usamos GPT-4.1 como LLM devido à sua grande janela de contexto.

Configuração do ambiente: Limpamos todos os dados em cache e garantimos uma nova conexão com o servidor MCP a cada execução. Cada consulta é executada como um subprocesso separado.

Comparação de arquitetura

Arquitetura MCP regular

Na abordagem MCP padrão, o agente segue um fluxo direto: a consulta do usuário entra em um Agente LangGraph ReAct, que tem acesso a todas as 63 definições de ferramentas em sua janela de contexto. O agente seleciona e chama ferramentas por meio da Sessão do Cliente MCP, e os resultados das ferramentas retornam pela janela de contexto para informar a próxima ação do agente.

Execução de código Arquitetura MCP

A abordagem de execução de código adiciona uma camada intermediária: a consulta do usuário é enviada a um Agente de Execução de Código com um contexto compacto (apenas nomes de ferramentas, não esquemas completos). O agente escreve código Python que chama ferramentas. Esse código é executado em um ambiente de Execução de Código isolado (sandbox), que se comunica com a Sessão do Cliente MCP. Somente os resultados finais ou resumos retornam ao contexto do agente, não os dados intermediários brutos.

A implementação da execução de código utiliza divulgação progressiva. Apenas os nomes das ferramentas e descrições truncadas (60 caracteres) são incluídos no prompt do sistema. Quando o modelo precisa usar uma ferramenta, ele escreve um código Python que chama uma função assíncrona `call_tool()` fornecida no ambiente de execução.

Limitações da nossa abordagem

Diversidade de consultas: Apenas 2 tipos de consultas foram testados; os resultados podem variar para outros tipos de tarefas.
Modelo único: Testado apenas com GPT-4.1; outros modelos podem apresentar padrões diferentes.
Qualidade do código: O sucesso na execução do código depende da capacidade do modelo de gerar código, o que pode causar diminuição nas taxas de sucesso em tarefas mais complexas.

Por que o MCP tradicional desperdiça recursos

Problema 1: As definições de ferramentas consomem contexto excessivo.

Cada ferramenta precisa de instruções na memória do modelo. Um exemplo básico:

 gdrive.getDocumento
 Obtém um arquivo da unidade Google
 Necessário: ID do documento
 Retorna: o conteúdo do arquivo

Exemplo: Um agente conectado a 50 servidores com 20 ferramentas cada significa 1.000 definições de ferramentas. Com aproximadamente 150 tokens por definição, isso representa 150.000 tokens consumidos antes mesmo do agente ler sua primeira solicitação.

Problema 2: Os dados são processados várias vezes.

Tarefa: “Obter minhas anotações de reunião da unidade Google e adicioná-las à unidade Salesforce.”

O que acontece:

O agente recebe o documento (50.000 tokens)
O modelo lê isso
O agente envia para Salesforce (mais 50.000 tokens)

O modelo processa mais de 100.000 tokens para mover dados de um lugar para outro – como se alguém lesse um livro inteiro em voz alta apenas para entregá-lo a outra pessoa.

Quando usar a execução de código com MCP?

A execução de código com MCP resolve duas ineficiências fundamentais nas implementações tradicionais de MCP:

As definições de ferramentas já não ocupam muito espaço na janela de contexto.
Os dados intermediários param de fluir pelo modelo desnecessariamente.

Essa abordagem funciona melhor quando:

Você tem várias ferramentas MCP conectadas.
Seus fluxos de trabalho envolvem processamento de dados em várias etapas.
Documentos ou conjuntos de dados grandes são transferidos entre ferramentas.
Os limites da janela de contexto afetam seus agentes.

Os requisitos de infraestrutura significam que esta não é automaticamente a melhor opção para todos os casos de uso. Implantações de pequena escala com poucas ferramentas podem não justificar a complexidade operacional.

Para organizações que já utilizam agentes com extensos catálogos de ferramentas MCP, o potencial de redução de tokens em mais de 98% e a consequente economia de custos tornam essa abordagem digna de investigação.