Brainstorm

Debates de IA de múltiples rondas entre GPT, DeepSeek, Groq y Claude: todos los modelos argumentan, critican y sintetizan dentro de tu asistente de codificación.

GitHub

Prueba este MCPPatrocinado

Documentación

brainstorm-mcp

Haz una pregunta de diseño a un modelo 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 múltiples rondas entre GPT, Gemini, DeepSeek, Claude y modelos locales de Ollama desde tu editor: se ven y critican las respuestas de los demás a lo largo de las rondas, y luego obtienes una síntesis de 3 viñetas: recomendación, compensaciones clave 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 requiere claves API.

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

Inicio rápido (60 segundos)

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

Luego pregúntale a Claude: "Brainstorm usando opus, sonnet y haiku sobre si deberíamos usar GraphQL o REST."

Eso se ejecuta en modo alojado: sin claves API, sin cuentas de proveedor. El debate utiliza los modelos ya disponibles en tu entorno y obtienes la síntesis de 3 viñetas al final.

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

Demo

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

Características

Modo alojado — No se necesitan claves API. Utiliza modelos en tu entorno (Claude Opus/Sonnet/Haiku) mediante subagentes
Modo API — Llamadas directas a la API del modelo con ejecución paralela en OpenAI, Gemini, DeepSeek, Groq, Ollama
Modo CLI — Debate a través de las CLI de agentes que ya tienes (claude, codex y más) para que los debates se ejecuten con tu suscripción en lugar de créditos de API
brainstorm_quick — Perspectivas instantáneas de múltiples modelos en menos de 10 segundos
brainstorm_review — Revisión de código multi-modelo con hallazgos estructurados, calificaciones de severidad y veredictos
Estilos de debate — Libre, red-team (adversarial) y socrático (preguntas de sondeo)
Inyección de contexto — Fundamenta los debates en código real, diffs o documentos de arquitectura
Síntesis de veredictos en 3 viñetas — Recomendación, compensaciones clave, desacuerdo más fuerte
Claude como participante — Claude debate junto a modelos externos con contexto completo de conversación
Debates de múltiples rondas — Los modelos ven y critican las respuestas de los demás a lo largo de las rondas
Ejecución paralela — Todos los modelos responden simultáneamente dentro de cada ronda
Resiliente — Que un modelo falle no aborta el debate
Multiplataforma — Funciona en macOS, Windows y Linux

Instalación

El comando de una línea bajo Inicio rápido es suficiente para el modo alojado. Agrega claves de proveedor para incorporar GPT, Gemini, DeepSeek, Groq u Ollama al debate; la configuración por cliente se detalla a continuación.

Claude Code

Agrega 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

Agrega 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 host (Claude Code) ejecuta los prompts usando su propio acceso a modelos.

Configuración

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

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.

Cualquier ID de modelo que sirva el proveedor funciona, incluido el GPT-6 de OpenAI (openai:gpt-6-astra) y los modelos de razonamiento gpt-5.x: brainstorm elige la forma de solicitud que cada modelo espera y reintenta con la otra forma si la API la rechaza.

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

Si ya pagas por Claude Code, Codex, Gemini CLI y similares, brainstorm puede invocar esas CLI en lugar de comprar créditos de 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:

Proveedor	Comando	Modelo predeterminado	Estado
`claude`	`claude -p`	`sonnet`	verificado
`codex`	`codex exec`	`default`	verificado
`gemini`	`gemini -p`	`gemini-2.5-pro`	mejor esfuerzo, verificar localmente
`cursor-agent`	`cursor-agent -p`	`default`	mejor esfuerzo
`opencode`	`opencode run`	`default`	mejor esfuerzo
`qwen`	`qwen -p`	`qwen3-coder-plus`	mejor esfuerzo
`kimi`	`kimi --print`	`default`	mejor esfuerzo
`droid`	`droid exec`	`default`	mejor esfuerzo

<provider>:default significa "deja que la CLI use el modelo con el que esté configurada". Las llamadas CLI se ejecutan con herramientas deshabilitadas y un sandbox de solo lectura donde la CLI lo admita: 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 la CLI recurra a tu inicio de sesión de suscripción.

Perillas de entorno:

Variable	Efecto
`BRAINSTORM_CLI_PROVIDERS`	`auto` (predeterminado), `off` o una lista separada por comas de adaptadores a detectar
`BRAINSTORM_PREFER_CLI`	`1` — los debates sin un `models` explícito usan solo proveedores CLI, omitiendo las API medidas
`BRAINSTORM_CLI_TIMEOUT_MS`	Tiempo de espera por llamada para proveedores CLI (predeterminado 300000)

Para fijar un modelo o agregar una CLI que no esté integrada, 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, por lo 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 de la CLI de Claude

Moonshot (Kimi), MiniMax y Z.ai (GLM) venden suscripciones de planes de codificación que hablan el 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" }
  }
}

Backend	Endpoint	Variable de entorno del 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`

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 indirecta a través del entorno del servidor.

Estos proveedores también son accesibles como API medidas simples: moonshot, minimax, glm y qwen tienen URL base conocidas, por lo que MOONSHOT_API_KEY solo es suficiente para registrar moonshot como un proveedor de API.

Herramientas

Herramienta	Descripción	Anotación
`brainstorm`	Debate de múltiples rondas entre modelos de IA (modo API o alojado)	readOnly
`brainstorm_quick`	Perspectivas instantáneas de múltiples modelos — paralelas, sin rondas	readOnly
`brainstorm_review`	Revisión de código multi-modelo con hallazgos, severidad, veredicto	readOnly
`brainstorm_respond`	Envía la respuesta de Claude en una sesión interactiva	readOnly
`brainstorm_collect`	Envía respuestas de modelos en una sesión alojada	readOnly
`list_providers`	Muestra proveedores configurados, estado de claves API y CLI detectadas	readOnly
`add_provider`	Agrega un nuevo proveedor API o CLI en tiempo de ejecución	no destructiva

Ejemplos de uso

Ejemplo 1: Perspectivas rápidas de múltiples modelos

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, tiempos y costo.

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 git diff 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 severidad, 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 crudas de los modelos aún se devuelven.

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 host (Claude Code) genera subagentes con diferentes modelos, recopila respuestas y las retroalimenta a través de brainstorm_collect. Después de todas las rondas, un modelo de síntesis produce un veredicto de 3 viñetas: Recomendación, Compensaciones clave, 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

Le pides a Claude que haga un brainstorm sobre un tema
La herramienta envía el tema a todos los proveedores configurados en paralelo — HTTP para proveedores API, un subproceso generado para proveedores CLI
Claude lee sus respuestas y contribuye con su propia perspectiva
Los modelos ven las respuestas de los demás y refinan a lo largo de las rondas
Un sintetizador produce el veredicto final

Modo alojado

Le pides a Claude que haga un brainstorm con modelos específicos (p. ej., opus, sonnet, haiku)
La herramienta devuelve prompts — no se realizan llamadas API
Claude genera subagentes con diferentes modelos para ejecutar los prompts
Las respuestas se recopilan y retroalimentan para la siguiente ronda
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 las CLI de agentes instaladas 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 escribe ningún dato 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 — rastreador de proyectos respaldado por SQLite: una vez que el debate se resuelve, la decisión va a un lugar duradero.
yantrikdb-mcp — memoria cognitiva persistente para que el agente recuerde qué 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 API fuera de tus clientes.

Licencia

MIT