Sequential Thinking Multi-Agent System (MAS)

Un agente MCP que utiliza un Sistema Multiagente (MAS) para el pensamiento secuencial y la resolución de problemas.

Documentación

Sequential Thinking Multi-Agent System (MAS)

Un servidor MCP que procesa pensamientos secuenciales a través de un equipo de agentes de IA especializados, cada uno analizando el problema desde una perspectiva cognitiva diferente.

Qué es esto

Este es un servidor MCP, no una aplicación independiente. Se ejecuta como un servicio en segundo plano que extiende un cliente LLM compatible con MCP (como Claude Desktop) con capacidades estructuradas de pensamiento secuencial. Expone una herramienta, sequentialthinking, que ejecuta cada pensamiento a través de un flujo de trabajo multiagente fijo: una síntesis inicial, varios agentes especialistas pensando en paralelo, y una síntesis final que responde a la pregunta original.

Cómo funciona

El sistema utiliza una estrategia fija de full_exploration para cada solicitud. El analizador de complejidad de IA aún se ejecuta para registrar metadatos de diagnóstico (puntuación de complejidad, tipo de problema, modos de pensamiento requeridos), pero ya no cambia la ruta de ejecución — todos los pensamientos siguen la misma ruta:

flowchart TD
    A[Input Thought] --> B[AI Complexity Analyzer]
    B --> C[Complexity Metadata Stored]
    C --> D[Fixed Strategy: full_exploration]
    D --> E[Step 1: Initial Synthesis]
    E --> F[Step 2: Parallel Specialist Agents]
    F --> G[Step 3: Final Synthesis]
    G --> H[Unified Response]

Los agentes especialistas

Cada solicitud ejecuta seis agentes especialistas en paralelo, más un agente de síntesis que se ejecuta dos veces (una al inicio, una al final). Cada especialista, excepto el de síntesis, puede usar opcionalmente investigación web a través de ExaTools.

Agente	Dirección de pensamiento	Enfoque	Presupuesto de tiempo
Factual	`factual`	Hechos objetivos y datos verificados	120s
Emocional	`emotional`	Intuición y reacciones viscerales	30s
Crítico	`critical`	Riesgos, debilidades, fallos lógicos	120s
Optimista	`optimistic`	Beneficios, oportunidades, valor	120s
Creativo	`creative`	Nuevas ideas y alternativas	240s
Metacognitivo	`metacognitive`	Detección de sesgos y evaluación del proceso de razonamiento	90s
Síntesis	`synthesis`	Integración y respuesta final	60s

Propiedades clave:

Determinista: cada solicitud ejecuta la misma ruta de múltiples pasos.
Paralelo: los agentes especialistas se ejecutan simultáneamente con asyncio.gather.
Impulsado por síntesis: tanto la orquestación como la respuesta final provienen del agente de síntesis, que utiliza el modelo mejorado.

Estrategia de modelos

Se configuran dos modelos por proveedor:

Modelo mejorado: utilizado por el agente de síntesis (tareas de integración).
Modelo estándar: utilizado por los agentes especialistas.

Capacidades de investigación

ExaTools está adjunto a cada agente excepto al de síntesis. La investigación es opcional — se activa solo cuando EXA_API_KEY está configurado. Sin él, el sistema funciona con razonamiento puro.

La herramienta `sequentialthinking`

El servidor expone una herramienta MCP.

Entrada

{
  thought: string,               // One focused reasoning step
  thoughtNumber: number,         // 1-based step index; increment each call
  totalThoughts: number,         // Planned number of steps
  nextThoughtNeeded: boolean,    // true for intermediate steps, false on final step
  isRevision: boolean,           // true only when revising earlier conclusions
  branchFromThought?: number,    // Set with branchId to branch from a prior step
  branchId?: string,             // Branch identifier (required when branching)
  needsMoreThoughts: boolean     // true only when extending beyond totalThoughts
}

Salida

{
  should_continue: boolean,      // Canonical continuation signal
  next_thought_number: number?,  // Recommended next thoughtNumber
  stop_reason: string,           // Why to continue/stop/retry
  current_thought_number: number,
  total_thoughts: number,
  next_call_arguments?: {        // Suggested next-call arguments when applicable
    thoughtNumber: number,
    totalThoughts: number,
    nextThoughtNeeded: boolean,
    needsMoreThoughts: boolean
  },
  parameter_usage: Record<string, string>
}

Contrato de llamada

Trata esta herramienta como un bucle de múltiples pasos, no como una llamada única.
Después de cada respuesta, lee structuredContent.should_continue.
Sigue llamando hasta que should_continue sea false.
Usa activamente la reflexión: cuando un paso es débil o incorrecto, envía un paso de revisión con isRevision=true.
Prefiere structuredContent.next_thought_number y next_call_arguments al construir la siguiente solicitud.

Proveedores compatibles

Proveedor	Variable de entorno	Modelo mejorado predeterminado	Modelo estándar predeterminado
DeepSeek (predeterminado)	`DEEPSEEK_API_KEY`	`deepseek-chat`	`deepseek-chat`
Groq	`GROQ_API_KEY`	`openai/gpt-oss-120b`	`openai/gpt-oss-20b`
OpenRouter	`OPENROUTER_API_KEY`	`deepseek/deepseek-chat-v3-0324`	`deepseek/deepseek-r1`
GitHub Models	`GITHUB_TOKEN`	`openai/gpt-5`	`openai/gpt-5-min`
Anthropic	`ANTHROPIC_API_KEY`	`claude-3-5-sonnet-20241022`	`claude-3-5-haiku-20241022`
Ollama	ninguno	`devstral:24b`	`devstral:24b`

Instalación

Requisitos previos

Python 3.10+
Una clave de API LLM de uno de los proveedores anteriores
Opcional: EXA_API_KEY para investigación web
uv gestor de paquetes (recomendado) o pip

Instalar

git clone https://github.com/FradSer/mcp-server-mas-sequential-thinking.git
cd mcp-server-mas-sequential-thinking

uv pip install .        # or: pip install .

Configurar un cliente MCP

Añade a la configuración de tu cliente MCP:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "mcp-server-mas-sequential-thinking",
      "env": {
        "LLM_PROVIDER": "deepseek",
        "DEEPSEEK_API_KEY": "your_api_key",
        "EXA_API_KEY": "your_exa_key_optional"
      }
    }
  }
}

Variables de entorno

# LLM provider (required)
LLM_PROVIDER="deepseek"  # deepseek, groq, openrouter, github, anthropic, ollama
DEEPSEEK_API_KEY="sk-..."

# Optional: override the models per provider (prefixed by provider name)
# DEEPSEEK_ENHANCED_MODEL_ID="deepseek-chat"
# DEEPSEEK_STANDARD_MODEL_ID="deepseek-chat"

# Optional: web research (enables ExaTools)
# EXA_API_KEY="your_exa_api_key"

# Optional: custom endpoint
# LLM_BASE_URL="https://custom-endpoint.com"

# Optional: team orchestration mode (standard/broadcast, route, coordinate)
# TEAM_MODE="standard"

Ejecutar el servidor directamente

mcp-server-mas-sequential-thinking        # installed script
uv run mcp-server-mas-sequential-thinking  # or via uv

Desarrollo

# Install with dev dependencies
uv pip install -e ".[dev]"

# Code quality
uv run ruff check . --fix
uv run ruff format .
uv run mypy .

# Run tests
uv run pytest tests/

# Or use the Makefile
make test        # all tests with coverage + quality checks
make test-fast   # fast run without coverage
make check-all   # all quality checks

Probar con MCP Inspector

npx @modelcontextprotocol/inspector uv run mcp-server-mas-sequential-thinking

Abre http://127.0.0.1:6274/ y prueba la herramienta sequentialthinking.

Advertencia sobre el consumo de tokens

La arquitectura multiagente consume significativamente más tokens que una herramienta de agente único — aproximadamente 5-10 veces más por llamada a sequentialthinking, porque cada llamada invoca múltiples agentes especialistas. La compensación es un análisis más profundo y desde múltiples perspectivas.

Estructura del proyecto

mcp-server-mas-sequential-thinking/
├── src/mcp_server_mas_sequential_thinking/
│   ├── main.py                          # MCP server entry point (MCPServer)
│   ├── processors/
│   │   ├── multi_thinking_core.py       # Specialist agent definitions
│   │   └── multi_thinking_processor.py  # Parallel sequence execution
│   ├── routing/
│   │   ├── ai_complexity_analyzer.py    # AI complexity analysis
│   │   ├── complexity_types.py          # Complexity metric models
│   │   └── multi_thinking_router.py     # Fixed full_exploration routing
│   ├── services/
│   │   ├── server_core.py               # ThoughtProcessor implementation
│   │   ├── processing_orchestrator.py   # Agno Team orchestration
│   │   ├── workflow_executor.py
│   │   └── context_builder.py
│   ├── infrastructure/
│   │   ├── persistent_memory.py         # SQLite session storage
│   │   └── learning_resources.py        # Agent learning machine
│   ├── security/rate_limiter.py         # Rate limiting and request validation
│   └── config/
│       ├── modernized_config.py         # Provider strategies
│       └── constants.py                 # System constants
├── scripts/mcp_python_client_smoke.py   # Protocol smoke test
├── tests/                               # Unit and integration tests
├── pyproject.toml
└── Makefile

Registro de cambios

Consulta CHANGELOG.md para el historial de versiones.

Contribuciones

Las contribuciones son bienvenidas. Por favor, asegúrate de:

Que el código siga el estilo del proyecto (ruff, mypy)
Que los mensajes de commit usen el formato de commits convencionales
Que todas las pruebas pasen antes de enviar un PR
Que la documentación se actualice según sea necesario

Licencia

Este proyecto aún no declara una licencia. Consulta la discusión sobre la licencia si necesitas reutilizarlo.

Agradecimientos

Construido con Agno v2.x
Model Context Protocol por Anthropic
Capacidades de investigación impulsadas por Exa (opcional)
Pensamiento multidimensional inspirado en el trabajo de Edward de Bono

Soporte

Problemas de GitHub: Reporta errores o solicita funciones
Documentación: consulta CLAUDE.md para notas de implementación
Protocolo MCP: Documentación oficial de MCP

Sequential Thinking Multi-Agent System (MAS)

Documentación