Fable MCP

mcp-server-fable

Um servidor MCP (Model Context Protocol) para Anthropic Claude Fable 5 — o modelo mais capaz e mais caro da Anthropic ($10 / $50 por 1M de tokens de entrada / saída, ~2× Opus). Construído em Rust, ele expõe o Fable como ferramentas MCP especializadas (plan, critique, ask) para que qualquer cliente MCP possa usá-las.

O Fable não é um modelo de chat para o dia a dia aqui. Este servidor foi construído para a única coisa que justifica o preço: usar o Fable para planejar e criticar, e então entregar o resultado a um modelo mais barato (Sonnet / Haiku / Opus) para executar. Funciona no Claude Code, Claude Desktop, Cursor, agentes personalizados e qualquer outro ambiente que suporte servidores MCP via stdio.

Comunica-se via stdio usando JSON-RPC 2.0. Estruturalmente, espelha o mcp-server-claude-chat, mas é deliberadamente adaptado à superfície da API do Fable e construído especificamente para o padrão planejar-depois-executar.

Por que mcp-server-fable (vs. o advisor integrado do Claude Code)?

O Claude Code tem um recurso nativo poderoso de advisor (/advisor fable ou a ferramenta advisor). Ele permite que um modelo executor rápido (tipicamente Sonnet ou Haiku) consulte dinamicamente o Fable para orientação em decisões difíceis dentro de uma única sessão.

Este servidor MCP adota uma abordagem complementar que é útil em mais situações:

• Ferramentas explícitas com prompts otimizados para handoff — plan e critique usam prompts de sistema fixos e cuidadosamente escritos, projetados para que a saída possa ser passada verbatim a um modelo mais barato. Os planos são numerados, inequívocos, incluem caminhos/assinaturas exatos, casos de borda, critérios de aceitação e notas de escopo fora. As críticas são deliberadamente priorizando cobertura (relate tudo; filtre downstream).
• Funciona em qualquer lugar onde MCP funciona — Não limitado ao Claude Code. Use no Claude Desktop, Cursor, Windsurf, frameworks de agentes personalizados, extensões MCP do VS Code, scripts ou qualquer ferramenta futura que suporte o Model Context Protocol.
• Você controla a orquestração — Chame o Fable para planejamento ou revisão exatamente quando você (ou seu sistema multiagente) decidir, em vez de depender do modelo para escalar.
• Composabilidade limpa — Trate o Fable como um serviço especialista reutilizável junto com seus outros servidores MCP. Perfeito para fluxos de trabalho modernos de "modelo caro para julgamento, modelo barato para execução".
• Comportamento correto específico do Fable — Níveis adequados de effort, tratamento de recusas (sem fallback silencioso), timeouts longos e relatórios precisos de custo por chamada nas tarifas do Fable.

Muitas equipes estão convergindo para o mesmo padrão que a comunidade descobriu: use o Fable de forma restrita para arquitetura, planejamento e revisão, depois execute com modelos mais baratos. Este servidor oferece ferramentas de primeira classe e portáveis para as "partes Fable" desse padrão.

Consulte a seção "Detalhes técnicos" abaixo para as diferenças específicas da API do Fable que também exigiram uma implementação dedicada.

Assinatura vs. créditos de API

Este servidor usa a API da Anthropic com chave de API (créditos de API) — a única forma suportada e em conformidade com os termos para acionar o Claude a partir de uma ferramenta de terceiros. Uma assinatura Claude Pro/Max não é utilizável aqui. Aponte base_url para um gateway compatível com a Anthropic se você tiver um.

Detalhes técnicos: diferenças da API do Fable

A API Messages do Fable difere do formato da era Opus (é por isso que um servidor dedicado foi necessário em vez de reutilizar um wrapper genérico de chat do Claude):

• Sem parâmetros de amostragem — temperature / top_p / top_k são rejeitados com um 400. Não há argumento de ferramenta temperature.
• Apenas pensamento adaptativo — o raciocínio está sempre ativo; a profundidade é controlada por effort (low / medium / high / xhigh / max), não por um orçamento de tokens. A cadeia de pensamento bruta nunca é retornada; ask pode solicitar um resumo legível via show_reasoning.
• Recusas param, de forma limpa — este é um servidor dedicado ao Fable. Os classificadores de segurança do Fable (ciber / bio / destilação de modelo) podem recusar uma solicitação; isso retorna como uma resposta bem-sucedida com stop_reason: "refusal", exibida com sua categoria e explicação em vez de uma resposta. Nunca é repetido silenciosamente em um modelo diferente.
• Retenção de dados de 30 dias exigida — o Fable não está disponível para organizações com retenção de dados zero; essas organizações recebem um 400 em todas as solicitações.

Cada resposta também imprime um custo estimado em USD (nas tarifas anunciadas do Fable), já que a consciência de custo é o ponto central.

Ferramentas

Ferramenta	Descrição
plan	Principal. Transforma um objetivo (+ contexto opcional) em um plano de implementação pronto para executor: etapas numeradas, caminhos/assinaturas exatos, casos de borda, critérios de aceitação, notas de escopo fora — escrito para ser entregue a um modelo mais barato e executado verbatim.
critique	Revisão priorizando cobertura de código, um diff ou um design. Relata cada achado com severidade + confiança para filtragem downstream. focus opcional.
ask	Consulta bruta de uma única chamada ao Fable. Histórico multi-turno, prompt de sistema, esforço, resumo de raciocínio opcional.

plan

Nome	Tipo	Obrigatório	Descrição
goal	string	sim	O que construir ou corrigir
context	string	não	Código relevante, árvore de arquivos, restrições, saída de erro, tentativas anteriores
effort	string	não	low/medium/high/xhigh/max (padrão high)
max_tokens	integer	não	Máximo de tokens a gerar (padrão do servidor caso contrário)

critique

Nome	Tipo	Obrigatório	Descrição
content	string	sim	Código, diff ou design a revisar
focus	string	não	Área a ponderar, ex.: security, concurrency
effort	string	não	low/medium/high/xhigh/max (padrão high)
max_tokens	integer	não	Máximo de tokens a gerar

ask

Nome	Tipo	Obrigatório	Descrição
prompt	string	sim	A mensagem do usuário
system_prompt	string	não	Prompt de sistema
messages	string	não	Histórico como um array JSON de {role, content} (apenas papéis user/assistant)
effort	string	não	low/medium/high/xhigh/max (padrão medium)
max_tokens	integer	não	Máximo de tokens a gerar
show_reasoning	boolean	não	Retorna um resumo do raciocínio do Fable em um bloco [thinking]

Pré-requisitos

• Rust (edição 2024)
• Uma chave de API da Anthropic de console.anthropic.com, em uma organização com retenção de dados ≥30 dias

O servidor espera um arquivo de configuração em ~/.config/mcp-server-fable/config.toml contendo no mínimo seu api_key. Consulte config.toml.example.

api_key = "sk-ant-..."

# Optional overrides:
# base_url = "https://api.anthropic.com/v1"
# default_model = "claude-fable-5"
# default_max_tokens = 8192
# default_effort = "high"   # low | medium | high | xhigh | max

O servidor falha rapidamente na inicialização se a configuração estiver ausente, api_key estiver vazio ou default_effort (se definido) for inválido.

Build

cargo build --release   # produces target/release/fable
cargo build             # debug build
cargo run               # run in dev mode
RUST_LOG=debug cargo run
cargo test              # unit tests (response formatting, cost, refusal, effort, message building)

Instalação e Configuração do MCP

1. Compile o servidor

cargo build --release
# The binary will be at: target/release/fable

Use o caminho absoluto completo para target/release/fable em toda a configuração abaixo.

2. Instalação assistida por IA (método moderno recomendado)

Copie o bloco abaixo e cole-o diretamente no seu assistente de codificação por IA (Claude Code, Cursor, Grok, etc.). A IA cuidará da clonagem (se necessário), compilação, resolução de caminho e registro para você.

Add the mcp-server-fable MCP server for me.

Repository: https://github.com/<your-username>/mcp-server-fable   (update this URL if you have a fork)

Steps to perform:
1. If the repo isn't cloned locally yet, clone it and cd into it.
2. Build the release binary:
     cargo build --release
3. Determine the absolute path to the built binary (target/release/fable).
4. Set up the config directory and file:
     mkdir -p ~/.config/mcp-server-fable
     cp config.toml.example ~/.config/mcp-server-fable/config.toml
   Then edit the config and add your Anthropic API key (api_key = "sk-ant-...").

5. Register it as an MCP server named "fable".

   For Claude Code, run:
     claude mcp add fable -- <ABSOLUTE_PATH_TO>/target/release/fable

   For Claude Desktop or other MCP clients, add this under the "mcpServers" key (use the real absolute path):
{
  "fable": {
    "command": "<ABSOLUTE_PATH_TO>/target/release/fable"
  }
}

After setup, test that the `plan` tool is available and working.

3. Configuração manual

Claude Desktop ou qualquer cliente MCP (~/.config/Claude/claude_desktop_config.json ou equivalente):

{
  "mcpServers": {
    "fable": {
      "command": "/absolute/path/to/mcp-server-fable/target/release/fable"
    }
  }
}

Claude Code (uma linha):

claude mcp add fable -- /absolute/path/to/mcp-server-fable/target/release/fable

Substitua o caminho pelo seu caminho absoluto real para o binário de release.

Uso

Depois de registrado, um cliente MCP chama as ferramentas pelo nome — a principal é plan.

De um cliente MCP (ex.: Claude Code)

Peça ao modelo para usá-lo, entregando o objetivo mais todo o contexto que o executor precisará:

Use a ferramenta fable plan. objetivo: "Adicionar um sinalizador --json ao CLI que imprime resultados como JSON". contexto: "Aplicativo Rust clap; a saída atualmente passa por println! em src/main.rs". esforço: alto

O Claude Code emite um tools/call para plan; o Fable retorna um plano numerado e pronto para executor — caminhos exatos, assinaturas, casos de borda, critérios de aceitação — que você então entrega a um modelo mais barato (Sonnet / Haiku) para implementar verbatim.

JSON-RPC bruto via stdio

A mesma chamada sem um cliente — uma solicitação tools/call que o servidor lê no stdin:

{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{
  "name":"plan",
  "arguments":{
    "goal":"Add a --json flag to the CLI that prints results as JSON",
    "context":"Rust clap app; output currently via println! in src/main.rs",
    "effort":"high"
  }}}

plan e critique retornam seu conteúdo seguido por um rodapé de token + custo estimado. Aqui está uma resposta real (de um pequeno probe ask) mostrando esse rodapé:

BINARY-OK
[stop_reason: end_turn]
[tokens: 21 input + 9 output = 30 total]
[cost: ≈ $0.0007 (fable rates)]

Como o servidor só chama o Fable, essa linha de custo está sempre nas tarifas de $10 / $50 por 1M do Fable — precisa por construção, não por convenção.

Estrutura do Projeto

src/
  main.rs    - entry point, config loading, stdio transport setup
  server.rs  - MCP tool definitions (plan, critique, ask) + fixed prompts
  api.rs     - Anthropic HTTP client, Effort enum, Messages types, refusal/cost formatter
  params.rs  - tool parameter types with serde + JSON Schema derives
  config.rs  - TOML config loading + effort validation

Licença

MIT