MCP em Escala: Controle de Acesso, Governança de Custos e Redução de 92% nos Custos de Tokens

O Imposto Oculto em Cada Solicitação MCP

Aqui está algo sobre o qual ninguém fala quando demonstra as integrações MCP: custos de tokens em escala.

Eu tenho executado configurações MCP com um número crescente de servidores conectados. O padrão é sempre o mesmo. Você conecta alguns servidores, tudo funciona brilhantemente. Você conecta uma dúzia, os custos começam a subir. Você conecta dezesseis servidores com mais de 500 ferramentas, e de repente seu orçamento de tokens se esgota antes que o modelo comece a pensar sobre sua consulta real.

Por quê? Cada definição de ferramenta de cada servidor conectado é injetada no contexto do modelo em cada solicitação. Mais de 150 definições de ferramentas podem consumir a maior parte do seu orçamento de tokens. E não há controle de acesso. Qualquer consumidor pode chamar qualquer ferramenta. Sem rastreamento de custos no nível da ferramenta.

Isso é insustentável para implantações em produção.

Eu Testei a Abordagem do Modo de Código do Bifrost

Bifrost adota uma abordagem fundamentalmente diferente para esse problema. Em vez de despejar todas as definições de ferramentas na janela de contexto, ele expõe um sistema de arquivos virtual de arquivos stub em Python. O modelo descobre ferramentas sob demanda através de quatro meta-ferramentas:

• listToolFiles - descobrir servidores e ferramentas disponíveis
• readToolFile - carregar assinaturas de função específicas
• getToolDocs - buscar documentação detalhada apenas quando necessário
• executeToolCode - executar scripts em um interpretador Starlark isolado

A chave da percepção: o modelo só carrega o que realmente precisa para a consulta atual. Se você pedir para ler um arquivo, ele não precisa saber sobre suas ferramentas do Slack, GitHub, Jira e banco de dados todas de uma vez.

Aqui está como um fluxo típico de descoberta de ferramentas se parece:

# O modelo chama listToolFiles para ver servidores disponíveis
available = listToolFiles()
# Retorna: ["filesystem/", "github/", "slack/", "jira/", ...]

# O modelo identifica que precisa de ferramentas de sistema de arquivos para esta consulta
tools = readToolFile("filesystem/read.py")
# Retorna apenas a assinatura da função para filesystem_read

# O modelo busca docs apenas se necessário
docs = getToolDocs("filesystem", "read")

# Executa com total isolamento
result = executeToolCode("filesystem/read.py", {"path": "/src/main.go"})

Isso é carregamento preguiçoso para contextos de ferramentas LLM. Ideia simples. Impacto massivo.

Resultados de Benchmark: 3 Rodadas Controladas

Eu executei três rodadas controladas, escalando de 6 servidores para 16 servidores. Cada rodada manteve uma taxa de aprovação de tarefas de 100%. O modelo completou todas as tarefas corretamente enquanto usava dramaticamente menos tokens.

Com cerca de 500 ferramentas, o Modo de Código reduz o uso de tokens por consulta em cerca de 14x. De 1,15M tokens para 83K. Isso não é uma melhoria incremental. Essa é uma estrutura de custo completamente diferente.

As economias se acumulam de forma não linear. À medida que você adiciona mais ferramentas, a porcentagem economizada aumenta porque a sobrecarga do Modo de Código permanece aproximadamente constante, enquanto o modo tradicional escala linearmente com a contagem de ferramentas.

Para a metodologia completa de benchmark, consulte a documentação de benchmarking.

Controle de Acesso que Realmente Funciona

As economias de tokens são ótimas, mas implantações MCP em produção precisam de governança. O Bifrost lida com isso através de dois mecanismos.

Chaves Virtuais permitem que você crie credenciais com escopo por usuário, equipe ou cliente. Você pode definir o escopo no nível da ferramenta:

virtual_key:
  name: "data-team-key"
  allowed_tools:
    - database_read
    - database_query
  blocked_tools:
    - database_delete
    - filesystem_write

Permitir filesystem_read, bloquear filesystem_write. Permitir database_query, bloquear database_delete. Granular, declarativo, sem necessidade de mudanças de código.

Grupos de Ferramentas MCP são coleções nomeadas de ferramentas de múltiplos servidores. Você cria um grupo, anexa a chaves, equipes ou usuários. Sem consultas ao banco de dados no momento da resolução. Isso é importante quando você está operando a 5000 RPS e não pode se dar ao luxo de latência de busca.

Observabilidade por Ferramenta

Cada execução de ferramenta é registrada com:

• Nome da ferramenta e origem do servidor
• Argumentos passados e resultados retornados
• Latência de execução
• Chave virtual que iniciou a chamada
• Contexto da solicitação LLM pai

Você pode rastrear custos no nível da ferramenta juntamente com os custos de tokens LLM. Isso é importante quando sua equipe financeira pergunta por que a conta de IA dobrou no mês passado. Você pode apontar exatamente quais ferramentas, quais equipes e quais consultas geraram os gastos.

Orçamento e limites permitem que você defina tetos de gastos por chave virtual, para que nenhuma equipe única possa ultrapassar a alocação mensal.

Flexibilidade de Conexão

O Bifrost suporta quatro tipos de conexão MCP: STDIO, HTTP, SSE e em processo via o SDK Go. OAuth 2.0 com PKCE e atualização automática de tokens estão integrados. Monitoramento de saúde com reconexões automáticas mantém tudo funcionando sem intervenção manual.

Você pode executá-lo em modo de aprovação manual, onde um humano revisa chamadas de ferramentas, ou em modo de loop de agente autônomo, onde o modelo encadeia chamadas de ferramentas de forma independente.

Para usuários do Claude Code e Cursor, o endpoint /mcp é int