Arquitetura Stateless do MCP
Ir para notas que citam estaA arquitetura stateless do MCP dispensa a sessão fixa entre cliente e servidor: cada chamada é autocontida e pode ser atendida por qualquer instância do servidor.
O desenho anterior obrigava o cliente a abrir uma sessão antes de qualquer trabalho útil. O servidor devolvia um identificador de sessão e toda chamada seguinte precisava carregá-lo, o que prendia aquele cliente àquela instância. Em produção, isso brigava com a infraestrutura que as empresas já tinham: era preciso configurar sessão pegajosa no balanceador e manter um armazenamento de sessão compartilhado entre instâncias. Conforme o volume de requisições crescia, a infraestrutura crescia junto e ficava mais cara. O problema nunca esteve na ideia do Model Context Protocol, e sim na forma como as informações eram transportadas.
Sem a etapa obrigatória de inicialização, o corpo da requisição passa a levar tudo o que o servidor precisa, incluindo a versão do protocolo e as informações do cliente. Um Servidor MCP remoto vira, na prática, um serviço HTTP comum: o balanceador distribui em round robin, mandando cada requisição para a instância que estiver livre. Colocar um servidor em produção deixa de exigir infraestrutura especial e passa a reaproveitar o que já se sabe sobre serviços web.
Stateless no protocolo não é stateless na aplicação
É a confusão mais comum sobre esse desenho. O que deixou de existir foi o estado mantido pelo protocolo, numa sessão paralela à conversa. A aplicação por trás do servidor continua podendo ter estado — ele apenas passa a viajar dentro do que a requisição e a resposta carregam.
O padrão que emerge é o de uma API HTTP que cria um recurso: uma chamada abre um carrinho, um pedido ou um processo, o servidor devolve o identificador daquele recurso e o modelo o usa como argumento nas chamadas seguintes. Isso tem dois efeitos bons. O modelo enxerga o identificador e consegue raciocinar sobre o recurso que acabou de criar, combinando ferramentas diferentes em cima dele. E o fluxo fica mais fácil de depurar, porque cada passo é visível na chamada.
Nada disso quebra o que já estava rodando: a versão nova opera em paralelo com a anterior, o que permite migrar aos poucos. Também não obriga a mexer nos sistemas legados atrás do servidor — a conexão entre o servidor MCP e a fonte de dados pode continuar usando sessão como sempre usou.
Tarefas longas e interfaces devolvidas pelo servidor
Duas capacidades se apoiam nesse desenho. A primeira é a extensão de tarefas: para operações demoradas, o cliente dispara o processo, o servidor devolve um identificador de tarefa e o cliente acompanha, atualiza ou cancela a tarefa por meio dele, em vez de segurar uma conexão aberta esperando o resultado. É a mesma lógica do identificador de recurso, aplicada ao tempo. Essa extensão existia antes como experimento e foi redesenhada; é a única parte do protocolo que exige refazer a implementação para adotar a versão oficial, ainda que a experimental continue funcionando.
A segunda é a entrega de interface: em vez de apenas dados brutos, o servidor pode devolver uma interface HTML interativa, que o cliente renderiza em ambiente isolado. Toda ação disparada ali chama uma ferramenta do servidor, como antes, de modo que nada muda no processamento. O ganho é que a interface vem do servidor e vale para qualquer cliente compatível.
Governança: autorização, descontinuação e rastreio
O amadurecimento veio acompanhado de regras para evoluir sem quebrar quem depende do protocolo. A autorização foi alinhada a padrões já usados em produção, OAuth 2.0 e OpenID Connect, em vez de um esquema próprio. A listagem de ferramentas ganhou cache, com tempo de validade e escopo declarados, num modelo comparável ao controle de cache do HTTP.
O rastreio distribuído passou a ser documentado na própria especificação, o que permite acompanhar chamadas MCP com ferramentas comuns de monitoramento e aproxima o protocolo da prática de Observabilidade de Agentes; o tratamento de logs aponta para OpenTelemetry. Por fim, uma política formal de descontinuação exige que uma funcionalidade fique cerca de doze meses obsoleta antes de ser removida, sempre com o substituto indicado — o que troca a chance de uma quebra inesperada por previsibilidade.