Ferramenta gratuita

De OpenAPI a servidor MCP em Rust

Você já tem uma especificação OpenAPI. Veja como ela vira um servidor MCP funcional em Rust, e quais partes um conversor não faz por você.

SDK oficial modelcontextprotocol/rust-sdk (rmcp)
Instalação
cargo add rmcp
Uma ferramenta MCP funcional em Rust
#[derive(Debug, Deserialize, JsonSchema)]
struct GetOrderArgs {
    /// The order id to look up
    order_id: String,
}

#[tool_router]
impl MyServer {
    #[tool(description = "Look up one order by its id and return its current status.")]
    async fn get_order(&self, Parameters(args): Parameters<GetOrderArgs>)
        -> Result<CallToolResult, McpError> {
        Ok(CallToolResult::success(vec![Content::text(fetch_order(&args.order_id).await)]))
    }
}

Gerado, rodando e ainda invisível.

Converter uma especificação te dá um servidor. Não te dá ninguém que queira usá-lo. O MCP Showcase transforma o mesmo endpoint em um playground ao vivo com documentação legível para cada ferramenta.

Como funciona

link
Converta a especificação

O conversor de OpenAPI transforma cada operação em uma definição de ferramenta MCP, no seu navegador e sem enviar a sua especificação.

play_circle
Ligue tudo em Rust

Pegue as definições de ferramentas geradas e implemente-as contra a sua API com o SDK de Rust, no formato mostrado acima.

checklist
Reduza a lista

Uma especificação convertida te dá uma ferramenta por operação, o que quase sempre é demais. Fique com as de que um agente precisa.

Da especificação para Rust

A metade mecânica é mesmo mecânica: cada operação OpenAPI vira uma ferramenta MCP, a summary vira a descrição, e os parâmetros de caminho, query e corpo achatam em um único esquema de entrada. O conversor de OpenAPI faz essa parte no seu navegador, sem enviar a sua especificação.

O que sobra tem a forma de Rust: implementar essas ferramentas contra a sua API com modelcontextprotocol/rust-sdk (rmcp) (cargo add rmcp), no formato mostrado acima.

Runtime assíncrono e derivação de esquema são ambos explícitos

O rmcp é construído sobre o Tokio e deriva esquemas via schemars, então tanto o runtime quanto a derivação de esquema são escolhas suas e não padrões herdados. Espere mais preparação do que em Python para o mesmo servidor, e espere que o compilador pegue os erros de esquema que os outros SDKs descobrem em execução.

O que nenhum conversor faz por você

  • A autenticação. O código gerado chama a sua API sem credenciais. Ligar o cabeçalho, o token ou o fluxo OAuth é com você.
  • Reescrever as descrições. Uma summary de OpenAPI é escrita para quem lê documentação. Uma descrição de ferramenta MCP é lida por um modelo que decide o que chamar. São trabalhos diferentes, e as summaries normalmente precisam de reescrita depois de convertidas.
  • Escolher o que expor. Um conversor te entrega uma ferramenta por operação. Para a maioria das APIs isso é uma ordem de grandeza demais.
  • Expandir corpos com $ref. Resolvê-los exige a sua seção components, então eles chegam como objeto genérico.

Por que o número de ferramentas importa tanto

As definições de ferramentas são enviadas ao modelo a cada requisição, não uma vez por sessão. Oitenta operações são oitenta descrições e oitenta esquemas na janela de contexto de cada turno — pagos continuamente, e mensuravelmente piores na escolha do que uma lista curta. A calculadora de tokens mostra quanto uma dada lista custa; o linter de esquemas mostra se as descrições sobreviveram à conversão em estado utilizável.

Ferramentas e guias relacionados

Gerado não é a mesma coisa que utilizável

Um servidor convertido prova que o mapeamento funcionou. Para um cliente em potencial ele não diz nada: essa pessoa não lê Rust e não vai configurar um cliente para descobrir. O MCP Showcase transforma o mesmo endpoint em um playground ao vivo com documentação por ferramenta que qualquer um pode experimentar no navegador.

Perguntas frequentes

O mapeamento é mecânico: cada operação vira uma ferramenta, a summary vira a descrição e os parâmetros viram um único esquema de entrada plano. O que não é mecânico: autenticação, tratamento de erros e decidir quais operações merecem estar na lista de ferramentas.

A autenticação, que você adiciona. Os corpos de requisição atrás de um $ref, cuja resolução exige a sua seção components. E o julgamento: um conversor te dá alegremente oitenta ferramentas, o que é pior do que oito.

Porque as definições de ferramentas são enviadas ao modelo a cada requisição. Oitenta operações são oitenta descrições e oitenta esquemas no contexto de cada turno, pagos continuamente, e ao mesmo tempo deixam o modelo mensuravelmente pior para escolher entre elas.

Sim, e vale saber disso antes de converter. Uma summary de OpenAPI é escrita para quem lê documentação; uma descrição de ferramenta MCP é lida por um modelo que decide o que chamar. São trabalhos diferentes, e as summaries costumam precisar de reescrita depois.

Publique e passe a URL pelo MCP Inspector para confirmar o handshake e a lista de ferramentas, e depois pelo linter de esquemas para ver se as descrições sobreviveram bem o bastante para um modelo escolher direito.

Mais ferramentas MCP gratuitas