Brainstorm

Debates de IA em múltiplas rodadas entre GPT, DeepSeek, Groq e Claude — todos os modelos argumentam, criticam e sintetizam dentro do seu assistente de codificação.

GitHub

Documentação

brainstorm-mcp

Servidor MCP de brainstorming com múltiplas IAs. Orquestra debates entre GPT, Gemini, DeepSeek e Claude com síntese estruturada. Inclui modo rápido instantâneo, revisão de código multi-modelo com vereditos e estilos red-team/Socrático. O modo hospedado não exige chaves de API.

Não confie em uma única IA. Faça-as debaterem.

brainstorm-mcp — Claude Opus vs GPT-5.4 vs DeepSeek debating

Demonstração

Clique para assistir: 3 modelos debatem, fazem cross-exame e produzem um veredito estruturado — tudo dentro do Claude Code.

Recursos

Modo hospedado — Sem necessidade de chaves de API. Usa modelos do seu ambiente (Claude Opus/Sonnet/Haiku) via subagentes
Modo API — Chamadas diretas de API com execução paralela entre OpenAI, Gemini, DeepSeek, Groq e Ollama
Modo CLI — Debata por CLIs de agentes que você já tem (claude, codex e outros), para que os debates usem sua assinatura em vez de créditos de API
brainstorm_quick — Perspectivas instantâneas de múltiplos modelos em menos de 10 segundos
brainstorm_review — Revisão de código multi-modelo com descobertas estruturadas, classificações de severidade e vereditos
Estilos de debate — Livre, red-team (adversário) e socrático (perguntas investigativas)
Injeção de contexto — Fundamente debates em código real, diffs ou documentos de arquitetura
Vereditos de síntese em 3 tópicos — Recomendação, Principais trade-offs, Maior discordância
Claude como participante — Claude debate junto com modelos externos com contexto completo de conversa
Debates em várias rodadas — Modelos veem e criticam as respostas uns dos outros ao longo das rodadas
Execução paralela — Todos os modelos respondem simultaneamente em cada rodada
Resiliente — A falha de um modelo não aborta o debate
Multiplataforma — Funciona em macOS, Windows e Linux

Instalação

Claude Code

Adicione ao .mcp.json do seu projeto:

{
  "mcpServers": {
    "brainstorm": {
      "command": "npx",
      "args": ["-y", "brainstorm-mcp"],
      "env": {
        "OPENAI_API_KEY": "sk-...",
        "GEMINI_API_KEY": "AIza...",
        "DEEPSEEK_API_KEY": "sk-..."
      }
    }
  }
}

Claude Desktop

Adicione ao claude_desktop_config.json:

{
  "mcpServers": {
    "brainstorm": {
      "command": "npx",
      "args": ["-y", "brainstorm-mcp"],
      "env": {
        "OPENAI_API_KEY": "sk-...",
        "DEEPSEEK_API_KEY": "sk-..."
      }
    }
  }
}

Instalação Manual

npm install -g brainstorm-mcp
brainstorm-mcp

Modo hospedado não exige chaves de API — basta instalar e usar. O host (Claude Code) executa os prompts usando seu próprio acesso a modelos.

Configuração

Opção 1: Variáveis de Ambiente (mais simples)

OPENAI_API_KEY=sk-...
GEMINI_API_KEY=AIza...
DEEPSEEK_API_KEY=sk-...

Opção 2: Arquivo de Configuração (controle total)

Defina BRAINSTORM_CONFIG para apontar para um arquivo JSON:

{
  "providers": {
    "openai": { "model": "gpt-5.4", "apiKeyEnv": "OPENAI_API_KEY" },
    "gemini": { "model": "gemini-2.5-flash", "apiKeyEnv": "GEMINI_API_KEY" },
    "deepseek": { "model": "deepseek-chat", "apiKeyEnv": "DEEPSEEK_API_KEY" },
    "ollama": { "model": "llama3.1", "baseURL": "http://localhost:11434/v1" }
  }
}

Provedores conhecidos (openai, gemini, deepseek, groq, mistral, together, moonshot, minimax, glm, qwen) não precisam de um baseURL.

Opção 3: Provedores CLI (use uma assinatura, não créditos de API)

Se você já paga pelo Claude Code, Codex, Gemini CLI e outros, o brainstorm pode usar esses CLIs em vez de comprar créditos de API. Qualquer CLI de agente encontrada no seu PATH é registrada automaticamente na inicialização — sem configuração necessária:

[brainstorm] Detected CLI provider(s) on PATH: claude, codex (subscription-based, no API cost)

Use-os como qualquer outro provedor:

{ "topic": "GraphQL vs REST", "models": ["claude:sonnet", "codex:default", "openai:gpt-5.4"] }

Adaptadores integrados:

Provedor	Comando	Modelo padrão	Status
`claude`	`claude -p`	`sonnet`	verificado
`codex`	`codex exec`	`default`	verificado
`gemini`	`gemini -p`	`gemini-2.5-pro`	melhor esforço, verificar localmente
`cursor-agent`	`cursor-agent -p`	`default`	melhor esforço
`opencode`	`opencode run`	`default`	melhor esforço
`qwen`	`qwen -p`	`qwen3-coder-plus`	melhor esforço
`kimi`	`kimi --print`	`default`	melhor esforço
`droid`	`droid exec`	`default`	melhor esforço

<provider>:default significa "deixe o CLI usar o modelo com o qual está configurado". Chamadas de CLI são executadas com ferramentas desativadas e em sandbox somente leitura, quando o CLI suporta — elas geram texto, não tocam no seu repositório. Variáveis de ambiente específicas de chave de API (ANTHROPIC_API_KEY, OPENAI_API_KEY) são removidas do processo filho para que o CLI recorra ao seu login de assinatura.

Opções de ambiente:

Variável	Efeito
`BRAINSTORM_CLI_PROVIDERS`	`auto` (padrão), `off`, ou uma lista separada por vírgulas de adaptadores a detectar
`BRAINSTORM_PREFER_CLI`	`1` — debates sem `models` explícito usam somente provedores CLI, ignorando APIs com medição
`BRAINSTORM_CLI_TIMEOUT_MS`	Timeout por chamada para provedores CLI (padrão 300000)

Para fixar um modelo ou adicionar um CLI que não é integrado, use o arquivo de configuração:

{
  "providers": {
    "claude": { "type": "cli", "model": "opus" },
    "my-cli": {
      "type": "cli",
      "adapter": "custom",
      "command": "some-agent-cli",
      "args": ["run", "--model", "{{model}}", "--quiet", "{{prompt}}"],
      "promptVia": "arg",
      "model": "some-model"
    }
  }
}

Placeholders de modelo: {{model}}, {{system}}, {{prompt}}, {{outfile}}. Um placeholder sozinho que resolve para nada é removido da linha de comando junto com a flag que o introduz, então ["--model", "{{model}}"] funciona mesmo para provider:default. Defina "promptVia": "stdin" para canalizar o prompt em vez de passá-lo como argumento.

Backends de planos de programação através do CLI do Claude

Moonshot (Kimi), MiniMax e Z.ai (GLM) vendem assinaturas de planos de programação que falam a API da Anthropic. Aponte o binário claude para um deles e esse fornecedor entra no debate no plano que você já paga:

{
  "providers": {
    "moonshot": { "type": "cli", "backend": "moonshot", "model": "kimi-k2-thinking" },
    "minimax":  { "type": "cli", "backend": "minimax",  "model": "MiniMax-M2" },
    "glm":      { "type": "cli", "backend": "glm",      "model": "glm-4.6" }
  }
}

Backend	Endpoint	Variável de env do token
`moonshot`	`https://api.moonshot.ai/anthropic`	`MOONSHOT_API_KEY`
`minimax`	`https://api.minimax.io/anthropic`	`MINIMAX_API_KEY`
`glm`	`https://api.z.ai/api/anthropic`	`ZAI_API_KEY`

O token é lido do seu ambiente no momento da chamada — o arquivo de configuração guarda o nome da variável, nunca o segredo. ANTHROPIC_API_KEY é removido do processo filho para que sua conta da Anthropic nunca seja cobrada por isso. Qualquer provedor CLI também aceita um bloco "env" para sobrescrever o backend manualmente; um valor de "$NAME" indireciona para o ambiente do servidor.

Esses fornecedores também são alcançáveis como APIs com medição comuns — moonshot, minimax, glm e qwen têm URLs base conhecidas, então somente MOONSHOT_API_KEY é suficiente para registrar moonshot como provedor de API.

Ferramentas

Ferramenta	Descrição	Anotação
`brainstorm`	Debate de múltiplas rodadas entre modelos de IA (modo API ou hospedado)	readOnly
`brainstorm_quick`	Perspectivas instantâneas multi-modelo — paralelas, sem rodadas	readOnly
`brainstorm_review`	Revisão de código multi-modelo com descobertas, severidade e veredito	readOnly
`brainstorm_respond`	Submete a resposta do Claude em uma sessão interativa	readOnly
`brainstorm_collect`	Submete respostas de modelos em uma sessão hospedada	readOnly
`list_providers`	Mostra provedores configurados, status de chaves de API e CLIs detectados	readOnly
`add_provider`	Adiciona um provedor de API ou CLI em tempo de execução	não destrutivo

Exemplos de Uso

Exemplo 1: Perspectivas Rápidas Multi-Modelo

Prompt: "Use brainstorm_quick para comparar Redis vs PostgreSQL para armazenamento de sessão"

Ferramenta chamada: brainstorm_quick

{ "topic": "Redis vs PostgreSQL for session storage in a Node.js app" }

Saída: Cada modelo configurado responde independentemente em paralelo. Você obtém uma comparação lado a lado em menos de 10 segundos com nomes dos modelos, respostas, tempo e custo.

Tratamento de erros: Se um modelo falhar (limite de taxa, timeout), a ferramenta continua com os modelos restantes e mostra quais falharam.

Exemplo 2: Revisão de Código Multi-Modelo

Prompt: "Revise este diff para problemas de segurança" (com um git diff colado)

Ferramenta chamada: brainstorm_review

{
  "diff": "diff --git a/src/auth.ts ...",
  "title": "Add JWT authentication middleware",
  "focus": ["security", "correctness"]
}

Saída: Um veredito estruturado (aprovar / aprovar com avisos / precisa de mudanças) com uma tabela de descobertas mostrando severidade, categoria, arquivo, números de linha e sugestões. Inclui análise de concordância entre modelos — problemas sinalizados por vários modelos têm maior confiança.

Tratamento de erros: Se a síntese falhar, as revisões brutas dos modelos ainda são retornadas.

Exemplo 3: Brainstorm em Modo Hospedado (Sem Chaves de API)

Prompt: "Brainstorm usando opus, sonnet e haiku sobre se devemos usar GraphQL ou REST"

Ferramenta chamada: brainstorm

{
  "topic": "GraphQL vs REST for our public API",
  "models": ["opus", "sonnet", "haiku"],
  "mode": "hosted",
  "rounds": 2,
  "style": "redteam"
}

Saída: A ferramenta retorna prompts para cada modelo. O host (Claude Code) cria subagentes com modelos diferentes, coleta respostas e as alimenta de volta via brainstorm_collect. Após todas as rodadas, um modelo de síntese produz um veredito em 3 tópicos: Recomendação, Principais trade-offs, Maior discordância.

Tratamento de erros: Sessões expiram após 10 minutos. Se uma sessão não for encontrada, uma mensagem de erro clara é retornada com instruções para iniciar uma nova.

Como Funciona

Modo API / CLI

Você pede ao Claude para fazer brainstorming sobre um tópico
A ferramenta envia o tópico a todos os provedores configurados em paralelo — HTTP para provedores de API, um subprocesso para provedores CLI
Claude lê as respostas e contribui com sua própria perspectiva
Modelos veem as respostas uns dos outros e refinam ao longo das rodadas
Um sintetizador produz o veredito final

Modo Hospedado

Você pede ao Claude para fazer brainstorming com modelos específicos (ex.: opus, sonnet, haiku)
A ferramenta retorna prompts — nenhuma chamada de API é feita
Claude cria subagentes com modelos diferentes para executar os prompts
As respostas são coletadas e realimentadas para a próxima rodada
Repita até a síntese

Política de Privacidade

O brainstorm-mcp é executado inteiramente na sua máquina e não coleta, armazena ou transmite nenhum dado pessoal, telemetria ou análises.

No modo API, os prompts são enviados diretamente da sua máquina para os provedores de modelo configurados (OpenAI, Gemini, DeepSeek, etc.) usando suas próprias chaves de API. No modo CLI, os prompts são passados para CLIs de agentes instalados na sua máquina, que falam com seus próprios fornecedores sob sua assinatura existente. No modo hospedado, nenhuma chamada de API externa é feita.

As sessões de debate são armazenadas somente em memória com um TTL de 10 minutos. Nenhum dado é gravado em disco, a menos que você salve os resultados explicitamente.

Política de privacidade completa: PRIVACY.md

Suporte

Issues: https://github.com/spranab/brainstorm-mcp/issues
E-mail: developer@pranab.co.in
Repositório: https://github.com/spranab/brainstorm-mcp

Desenvolvimento

git clone https://github.com/spranab/brainstorm-mcp.git
cd brainstorm-mcp
npm install
npm run build
npm start

Licença

MIT