Model Context Protocol (MCP) na Prática: Construindo Servidores e Ferramentas para Agentes Autônomos

O Labirinto da Fragmentação: Por que Nossos Agentes Precisam de um Protocolo Padrão

Construir agentes autônomos e sistemas baseados em Large Language Models (LLMs), que são os modelos de inteligência artificial capazes de entender e gerar texto humano, tornou-se comum na engenharia moderna. No entanto, conectar esses modelos a bases de dados e APIs corporativas sempre gerou muita dor de cabeça. Historicamente, cada provedor de IA criava seu próprio formato de 'function calling', que é a capacidade da IA de acionar funções externas, exigindo código customizado para cada ferramenta. Na prática, isso significa que qualquer mudança de API quebrava os fluxos dos agentes da noite para o dia.

É exatamente esse problema que o Model Context Protocol (MCP), criado pela Anthropic, resolve. Pense nele como um cabo USB-C para a inteligência artificial: um padrão aberto que separa os aplicativos de IA dos provedores de dados. Em vez de criar integrações pontuais para cada sistema, os desenvolvedores criam um único servidor padronizado que funciona em qualquer cliente compatível, transformando agentes isolados em sistemas colaborativos seguros.

Anatomia da Arquitetura MCP: Host, Client, Server e Transports

Para projetar sistemas robustos, precisamos entender as quatro peças principais que conversam entre si usando protocolos de transporte padronizados:

• MCP Host: É a aplicação principal que inicia a sessão de IA, como o aplicativo Claude Desktop ou o editor de código Cursor. O Host gerencia a segurança e as aprovações de uso.
• MCP Client: O componente dentro do Host que mantém a conexão direta com o servidor MCP, negociando capacidades e gerenciando o estado da sessão.
• MCP Server: Um programa leve que expõe dados e comandos através do protocolo MCP, funcionando como uma ponte para bancos de dados ou arquivos.
• Transports: Os canais de comunicação, que podem ser stdio, que usa a entrada e saída padrão do terminal para processos locais, ou Server-Sent Events / SSE, que envia eventos via HTTP para servidores remotos.

A tabela abaixo resume as características arquiteturais dos meios de transporte suportados pelo protocolo:

Construindo um Servidor MCP Robusto do Zero em Python

Vamos colocar a mão na massa construindo um servidor MCP em Python usando o kit de desenvolvimento oficial. Este servidor vai fornecer ferramentas para consultar um banco de dados e expor configurações estáticas para a inteligência artificial.

import asyncio
from mcp.server import Server
from mcp.server.stdio import stdio_server
import mcp.types as types

# Inicializa a instância principal do Servidor MCP
app = Server("enterprise-data-server")

@app.list_resources()
async def list_resources() -> list[types.Resource]:
    return [
        types.Resource(
            uri="config://system/env",
            name="Variáveis de Ambiente do Sistema",
            description="Configurações atuais do ambiente de produção",
            mimeType="application/json"
        )
    ]

@app.read_resource()
async def read_resource(uri: str) -> str:
    if uri == "config://system/env":
        return '{"environment": "production", "region": "us-east-1", "debug": false}'
    raise ValueError(f"Recurso não encontrado: {uri}")

@app.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="execute_sql_query",
            description="Executa uma query SQL segura de leitura no banco de dados de métricas.",
            inputSchema={
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "A query SQL SELECT a ser executada."
                    }
                },
                "required": ["query"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    if name == "execute_sql_query":
        query = arguments.get("query", "")
        if not query.lower().strip().startswith("select"):
            raise ValueError("Apenas operações SELECT são permitidas por motivos de segurança.")
        
        # Simulação de execução em banco de dados
        mock_result = f"[RESULTADO MOCKADO PARA]: {query}\n- Linha 1: id=101, status=active\n- Linha 2: id=102, status=active"
        return [types.TextContent(type="text", text=mock_result)]
    
    raise ValueError(f"Ferramenta desconhecida: {name}")

async def main():
    async with stdio_server() as (read_stream, write_stream):
        await app.run(
            read_stream,
            write_stream,
            app.create_initialization_options()
        )

if __name__ == "__main__":
    asyncio.run(main())

O código acima mostra como o protocolo é limpo. Usando marcadores chamados decoradores, expusemos um arquivo de configuração e uma ferramenta de banco de dados validada. O agente conectado não precisa conhecer a infraestrutura do banco; ele apenas segue o modelo de dados estruturado em JSON que declaramos.

Segurança em Primeiro Lugar: Sandboxing e Prevenção de Execução Arbitrária

Ligar modelos de linguagem a bancos de dados traz riscos graves, como a injeção indireta de comandos maliciosos em textos de entrada. Como desenvolvedores, não podemos confiar cegamente na inteligência artificial. O MCP foi desenhado para garantir que a segurança aconteça no servidor, nunca confiando apenas no modelo.

Ao criar servidores corporativos, siga estas regras práticas de segurança:

1. Validação rigorosa de inputs (Input Schemas): Use validação estrita baseada em JSON Schema, que é um formato para descrever a estrutura de dados, rejeitando parâmetros inesperados antes de rodar qualquer código.
2. Princípio do Menor Privilégio: Garanta que as credenciais do banco de dados usadas pelo servidor tenham permissões limitadas, idealmente apenas de leitura.
3. Isolamento de Processos (Sandboxing): Ao usar o transporte local, rode o servidor dentro de contêineres Docker, que são ambientes virtuais isolados, para proteger o sistema operacional principal.
4. Human-in-the-Loop (HITL): Para ações perigosas, como apagar dados ou enviar e-mails, o sistema deve exigir que um humano aprove a execução antes do envio final.

Integrações no Mundo Real: Do Claude Desktop a Pipelines de Produção

A grande vantagem do MCP é que ele funciona de imediato. Depois que o servidor está pronto, integrá-lo exige apenas um arquivo de configuração em formato JSON no aplicativo de sua escolha. Por exemplo, para registrar nosso script Python no Claude Desktop, colocamos o seguinte trecho no arquivo claude_desktop_config.json:

{
  "mcpServers": {
    "enterprise-metrics": {
      "command": "python",
      "args": [
        "/caminho/para/seu/servidor_mcp.py"
      ]
    }
  }
}

Além de chats comuns, o MCP brilha em editores como o Cursor e em fluxos complexos de agentes na nuvem usando bibliotecas como LangGraph. Em empresas maiores, esses servidores rodam como microsserviços acessados via SSE e protegidos por autenticação avançada, permitindo que várias inteligências artificiais colaborem em tarefas de engenharia sem atrito.

O Horizonte da Web Agêntica Aberta e Interoperável

O surgimento do Model Context Protocol muda a forma como construímos softwares com inteligência artificial. Estamos saindo de sistemas fechados e entrando em um ecossistema onde agentes autônomos podem navegar e modificar dados de forma segura e padronizada. Dominar a criação de servidores MCP deixou de ser um detalhe e virou uma habilidade essencial para programadores que criam a próxima geração de ferramentas inteligentes.