Como o RustAPI Transforma Cada Endpoint em uma Ferramenta de Agente de IA

Imagine isto: você construiu uma API REST sólida. FastAPI, Express, Go, não importa. Funciona. Então alguém diz "precisamos de agentes de IA para usar nossa API."

Agora você está escrevendo um servidor MCP separado. Mantendo definições de ferramentas que espelham suas rotas. Mantendo esquemas em sincronia. Depurando timeouts de rede entre agente→proxy→API.

E se seu framework simplesmente... lidasse com isso?

MCP em 30 segundos

O Protocolo de Contexto de Modelo (MCP) é como agentes de IA chamam ferramentas externas. Claude Desktop usa isso. Cursor usa isso. Agentes do VS Code usam isso.

Uma ferramenta MCP tem:

• Um nome e uma descrição
• Um esquema de entrada (Esquema JSON)
• Uma função manipuladora

Isso é literalmente um endpoint de API com uma especificação OpenAPI.

A abordagem RustAPI: registro automático de ferramentas

use rustapi_rs::prelude::*;
use rustapi_rs::protocol::mcp::{McpConfig, InvocationMode};

#[tokio::main]
async fn main() {
    let app = RustApi::new()
        .route(get_weather)
        .route(post_order);

    // Esta única chamada:
    // 1. Lê a especificação OpenAPI que o RustAPI gera automaticamente
    // 2. Cria definições de ferramentas MCP para cada rota
    // 3. Conecta manipuladores que despacham através da sua pilha de middleware
    let mcp = McpServer::from_rustapi(
        &app,
        McpConfig::new()
            .name("minha-api".into())
            .invocation_mode(InvocationMode::InProcess)
    );

    mcp.serve_stdio().await.unwrap();
}

Sem registro manual de ferramentas. Sem duplicação de esquemas. Seus endpoints são as ferramentas.

Arquitetura: o que acontece em uma chamada de ferramenta

Agente de IA
  → Servidor MCP (stdio/HTTP)
    → Invocador de Requisições (despacho interno)
      → Router::dispatch()
        → LayerStack (autenticação, limite de taxa, registro, middleware)
          → Sua função manipuladora
      ← Resposta
    ← Resultado da ferramenta MCP
  ← Agente vê o resultado

A chave: O modo InProcess ignora completamente a rede. O RequestInvoker cria uma requisição interna e a despacha através do mesmo Router que lida com HTTP. Seu middleware é executado. Seus interceptores disparam. Mas sem socket TCP. Sem serialização.

Verificação de realidade de benchmark

// Teste: 1000 chamadas sequenciais de ferramentas MCP
// RustAPI 0.1.507, Intel i7-12700H, Windows 11

Modo InProcess:   27.9 µs/chamada  (35,842 chamadas/segundo)
Modo Proxy:     1350.0 µs/chamada  (741 chamadas/segundo)
                     ~48x mais rápido

Por que isso importa? Um agente fazendo 20 chamadas de ferramentas por consulta de usuário com modo proxy = 27ms de sobrecarga. Com InProcess = 0.5ms. Essa é a diferença entre "rápido" e "carregando..."

O CLI: sua API existente acaba de ganhar poderes MCP

Não está usando RustAPI? O CLI preenche essa lacuna:

# Instalar
cargo install cargo-rustapi --features mcp

# A partir de qualquer especificação OpenAPI (FastAPI, Express, Go, qualquer coisa com OpenAPI)
rustapi mcp generate --spec ./openapi.json

# Resultados:
# ✓ Ferramentas MCP geradas: getWeather, postOrder, listProducts
# ✓ Servidor rodando em http://localhost:9090
# ✓ Conecte Claude Desktop a http://localhost:9090/sse

Por baixo dos panos, ele:

1. Analisa a especificação OpenAPI (tolerante a especificações parciais/incompletas)
2. Mapeia métodos HTTP + caminhos → nomes de ferramentas MCP
3. Mapeia esquemas de parâmetros → esquemas de entrada MCP
4. Gera manipuladores proxy que chamam sua API real
5. Inicia um servidor MCP totalmente tipado

Isso funciona com qualquer API que tenha uma especificação OpenAPI. FastAPI, Express, Go, Python não importa.

Por que o transporte stdio importa

rustapi mcp generate --spec openapi.json --stdio

Stdio é o transporte nativo para clientes de IA de desktop. Claude Desktop lê as configurações do servidor MCP e cria processos. Sua API se torna uma ferramenta de primeira classe no arsenal do agente de desktop, sem servidor HTTP, sem conflitos de porta, sem CORS.

Juntando tudo: um exemplo completo

use rustapi_rs::prelude::