brainstorm-mcp

Pregúntale a un modelo una pregunta de diseño y obtendrás una respuesta segura, sin señal sobre qué partes le generan dudas. Pregunta a tres y el desacuerdo es la señal.

brainstorm-mcp ejecuta debates de varias rondas entre GPT, Gemini, DeepSeek, Claude y modelos locales de Ollama desde tu editor: se ven y se critican mutuamente las respuestas a lo largo de las rondas, y luego obtienes una síntesis de 3 viñetas: recomendación, principales compensaciones y el desacuerdo más fuerte. También incluye modo rápido instantáneo, revisión de código multi-modelo con veredictos y estilos red-team/Socrático. El modo alojado no necesita claves API.

No confíes en una sola IA. Haz que discutan.

Demo

Haz clic para ver: 3 modelos debaten, se interrogan mutuamente y producen un veredicto estructurado, todo dentro de Claude Code.

Características

• Modo alojado — No se necesitan claves API. Usa los modelos de tu entorno (Claude Opus/Sonnet/Haiku) mediante subagentes

• Modo API — Llamadas directas a la API de modelos con ejecución en paralelo en OpenAI, Gemini, DeepSeek, Groq, Ollama

• Modo CLI — Debate a través de los CLI de agentes que ya tienes (claude, codex y más), de modo que los debates se ejecutan con tu suscripción en lugar de créditos API

• brainstorm_quick — Perspectivas multi-modelo instantáneas en menos de 10 segundos

• brainstorm_review — Revisión de código multi-modelo con hallazgos estructurados, niveles de gravedad y veredictos

• Estilos de debate — Libre, red-team (adversarial) y socrático (preguntas indagatorias)

• Inyección de contexto — Fundamenta los debates en código real, diffs o documentación de arquitectura

• Veredictos de síntesis en 3 viñetas — Recomendación, principales compensaciones, desacuerdo más fuerte

• Claude como participante — Claude debate junto a modelos externos con contexto completo de conversación

• Debates de varias rondas — Los modelos ven y critican las respuestas de los demás a lo largo de las rondas

• Ejecución en paralelo — Todos los modelos responden simultáneamente en cada ronda

• Resiliente — Que un modelo falle no aborta el debate

• Multiplataforma — Funciona en macOS, Windows y Linux

Related MCP server: roundtable-mcp

Instalación (60 segundos)

claude mcp add brainstorm -- npx -y brainstorm-mcp

Eso es suficiente para el modo alojado (sin claves API: debate usando los modelos ya disponibles en tu entorno). Añade claves de proveedores para traer GPT, Gemini, DeepSeek, Groq u Ollama al debate.

Claude Code

Añade a tu .mcp.json del proyecto:

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

Claude Desktop

Añade a claude_desktop_config.json:

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

Instalación manual

npm install -g brainstorm-mcp
brainstorm-mcp

El modo alojado no requiere claves API: solo instala y listo. El anfitrión (Claude Code) ejecuta los prompts usando su propio acceso a modelos.

Configuración

Opción 1: Variables de entorno (la más sencilla)

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

Opción 2: Archivo de configuración (control total)

Establece BRAINSTORM_CONFIG para apuntar a una configuración 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" }
  }
}

Los proveedores conocidos (openai, gemini, deepseek, groq, mistral, together, moonshot, minimax, glm, qwen) no necesitan un baseURL.

Opción 3: Proveedores CLI (usa una suscripción, no créditos API)

Si ya pagas por Claude Code, Codex, Gemini CLI y similares, brainstorm puede ejecutar esos CLI en lugar de comprar créditos API. Cualquier CLI de agente que se encuentre en tu PATH se registra automáticamente al inicio — no se necesita configuración:

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

Úsalos como cualquier otro proveedor:

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

Adaptadores integrados:

<provider>:default significa "deja que el CLI use el modelo con el que esté configurado". Las llamadas CLI se ejecutan con las herramientas desactivadas y un sandbox de solo lectura cuando el CLI lo admite: generan texto, no tocan tu repositorio. Las variables de entorno de claves API específicas del proveedor (ANTHROPIC_API_KEY, OPENAI_API_KEY) se eliminan del proceso hijo para que el CLI recurra a tu inicio de sesión de suscripción.

Interruptores de entorno:

Para fijar un modelo o añadir un CLI que no esté integrado, usa el archivo de configuración:

{
  "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"
    }
  }
}

Marcadores de plantilla: {{model}}, {{system}}, {{prompt}}, {{outfile}}. Un marcador solitario que se resuelve a nada se elimina de la línea de comandos junto con la bandera que lo introduce, así que ["--model", "{{model}}"] funciona incluso para provider:default. Establece "promptVia": "stdin" para canalizar el prompt en lugar de pasarlo como argumento.

Backends de planes de codificación a través del CLI de Claude

Moonshot (Kimi), MiniMax y Z.ai (GLM) venden suscripciones de planes de codificación que hablan la API de Anthropic. Apunta el binario claude a uno de ellos y ese proveedor se une al debate con el plan que ya pagas:

{
  "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" }
  }
}

El token se lee de tu entorno en el momento de la llamada: el archivo de configuración contiene el nombre de la variable, nunca el secreto. ANTHROPIC_API_KEY se elimina del hijo para que tu cuenta de Anthropic nunca se facture por estos. Cualquier proveedor CLI también acepta un bloque "env" para anular el backend manualmente; un valor de "$NAME" se indirige a través del entorno del servidor.

Estos proveedores también son accesibles como APIs medidas normales: moonshot, minimax, glm y qwen tienen URLs base conocidas, así que MOONSHOT_API_KEY por sí sola es suficiente para registrar moonshot como proveedor de API.

Herramientas

Ejemplos de uso

Ejemplo 1: Perspectivas rápidas multi-modelo

Prompt: "Usa brainstorm_quick para comparar Redis vs PostgreSQL para almacenamiento de sesiones"

Herramienta llamada: brainstorm_quick

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

Salida: Cada modelo configurado responde de forma independiente en paralelo. Obtienes una comparación lado a lado en menos de 10 segundos con nombres de modelos, respuestas, tiempo y coste.

Manejo de errores: Si un modelo falla (límite de velocidad, tiempo de espera), la herramienta continúa con los modelos restantes y muestra cuáles fallaron.

Ejemplo 2: Revisión de código multi-modelo

Prompt: "Revisa este diff en busca de problemas de seguridad" (con un diff de git pegado)

Herramienta llamada: brainstorm_review

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

Salida: Un veredicto estructurado (aprobar / aprobar con advertencias / necesita cambios) con una tabla de hallazgos que muestra gravedad, categoría, archivo, números de línea y sugerencias. Incluye análisis de acuerdo entre modelos: los problemas señalados por varios modelos tienen mayor confianza.

Manejo de errores: Si la síntesis falla, las revisiones de modelos en bruto se devuelven de todos modos.

Ejemplo 3: Brainstorm en modo alojado (sin claves API)

Prompt: "Brainstorm usando opus, sonnet y haiku sobre si deberíamos usar GraphQL o REST"

Herramienta llamada: brainstorm

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

Salida: La herramienta devuelve prompts para cada modelo. El anfitrión (Claude Code) genera subagentes con diferentes modelos, recopila las respuestas y las retroalimenta mediante brainstorm_collect. Después de todas las rondas, un modelo de síntesis produce un veredicto de 3 viñetas: Recomendación, Principales compensaciones, Desacuerdo más fuerte.

Manejo de errores: Las sesiones expiran después de 10 minutos. Si no se encuentra una sesión, se devuelve un mensaje de error claro con instrucciones para iniciar una nueva.

Cómo funciona

Modo API / CLI

1. Le pides a Claude que haga un brainstorm sobre un tema

2. La herramienta envía el tema a todos los proveedores configurados en paralelo — HTTP para proveedores de API, un subproceso generado para proveedores CLI

3. Claude lee sus respuestas y aporta su propia perspectiva

4. Los modelos ven las respuestas de los demás y refinan a lo largo de las rondas

5. Un sintetizador produce el veredicto final

Modo alojado

1. Le pides a Claude que haga un brainstorm con modelos específicos (p. ej., opus, sonnet, haiku)

2. La herramienta devuelve prompts — no se realizan llamadas API

3. Claude genera subagentes con diferentes modelos para ejecutar los prompts

4. Las respuestas se recopilan y se retroalimentan para la siguiente ronda

5. Repite hasta la síntesis

Política de privacidad

brainstorm-mcp se ejecuta completamente en tu máquina y no recopila, almacena ni transmite ningún dato personal, telemetría o análisis.

En modo API, los prompts se envían directamente desde tu máquina a los proveedores de modelos que configures (OpenAI, Gemini, DeepSeek, etc.) usando tus propias claves API. En modo CLI, los prompts se pasan a los CLI de agentes instalados en tu máquina, que hablan con sus propios proveedores bajo tu suscripción existente. En modo alojado, no se realizan llamadas API externas.

Las sesiones de debate se almacenan solo en memoria con un TTL de 10 minutos. No se escriben datos en el disco a menos que guardes explícitamente los resultados.

Política de privacidad completa: PRIVACY.md

Soporte

• Problemas: https://github.com/spranab/brainstorm-mcp/issues

• Correo electrónico: developer@pranab.co.in

• Repositorio: https://github.com/spranab/brainstorm-mcp

Desarrollo

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

Proyectos relacionados

Otra infraestructura de agentes del mismo autor, construida para usarse en conjunto:

• saga-mcp — Seguimiento de proyectos respaldado por SQLite: una vez que el debate se asienta, la decisión va a un lugar duradero.

• yantrikdb-mcp — memoria cognitiva persistente para que el agente recuerde lo que decidiste y por qué.

• swarmcode — canal en tiempo real entre instancias de Claude Code en diferentes máquinas.

• truenas-mcp — 278 acciones de TrueNAS SCALE detrás de una herramienta jerárquica.

• mcpier — plano de control MCP autoalojado que mantiene las claves de API fuera de tus clientes.

Licencia

MIT