Sequential Thinking Multi-Agent System (MAS)

Um agente MCP que utiliza um Sistema Multiagente (MAS) para pensamento sequencial e resolução de problemas.

Documentação

Sequential Thinking Multi-Agent System (MAS)

Um servidor MCP que processa pensamentos sequenciais por meio de uma equipe de agentes de IA especializados, cada um analisando o problema sob uma perspectiva cognitiva diferente.

O Que É Isto

Este é um servidor MCP, não um aplicativo independente. Ele roda como um serviço em segundo plano que estende um cliente LLM compatível com MCP (como o Claude Desktop) com capacidades estruturadas de pensamento sequencial. Ele expõe uma ferramenta, sequentialthinking, que executa cada pensamento por um fluxo de trabalho multiagente fixo: uma síntese inicial, vários agentes especialistas pensando em paralelo e uma síntese final que responde à pergunta original.

Como Funciona

O sistema usa uma estratégia fixa de full_exploration para cada solicitação. O analisador de complexidade de IA ainda é executado para registrar metadados de diagnóstico (pontuação de complexidade, tipo de problema, modos de pensamento necessários), mas não altera mais o caminho de execução — todos os pensamentos seguem a mesma rota:

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]

Os Agentes Especialistas

Cada solicitação executa seis agentes especialistas em paralelo, além de um agente de síntese que é executado duas vezes (uma no início e uma no final). Cada especialista, exceto a síntese, pode opcionalmente usar pesquisa na web via ExaTools.

Agente	Direção de pensamento	Foco	Orçamento de tempo
Factual	`factual`	Fatos objetivos e dados verificados	120s
Emocional	`emotional`	Intuição e reações instintivas	30s
Crítico	`critical`	Riscos, fraquezas, falhas lógicas	120s
Otimista	`optimistic`	Benefícios, oportunidades, valor	120s
Criativo	`creative`	Novas ideias e alternativas	240s
Metacognitivo	`metacognitive`	Detecção de vieses e avaliação do processo de raciocínio	90s
Síntese	`synthesis`	Integração e resposta final	60s

Propriedades principais:

Determinístico: cada solicitação executa o mesmo caminho de múltiplas etapas.
Paralelo: os agentes especialistas são executados simultaneamente com asyncio.gather.
Orientado por síntese: tanto a orquestração quanto a resposta final vêm do agente de síntese, que usa o modelo aprimorado.

Estratégia de Modelos

Dois modelos são configurados por provedor:

Modelo aprimorado: usado pelo agente de síntese (tarefas de integração).
Modelo padrão: usado pelos agentes especialistas.

Capacidades de Pesquisa

ExaTools está anexado a todos os agentes, exceto à síntese. A pesquisa é opcional — ela é ativada somente quando EXA_API_KEY está definido. Sem ela, o sistema funciona apenas com raciocínio puro.

A Ferramenta `sequentialthinking`

O servidor expõe uma ferramenta 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
}

Saída

{
  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 Chamada

Trate esta ferramenta como um loop de múltiplas etapas, não como uma chamada única.
Após cada resposta, leia structuredContent.should_continue.
Continue chamando até que should_continue seja false.
Use ativamente a reflexão: quando uma etapa estiver fraca ou incorreta, envie uma etapa de revisão com isRevision=true.
Prefira structuredContent.next_thought_number e next_call_arguments ao construir a próxima solicitação.

Provedores Suportados

Provedor	Variável de ambiente	Modelo aprimorado padrão	Modelo padrão padrão
DeepSeek (padrão)	`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	nenhum	`devstral:24b`	`devstral:24b`

Instalação

Pré-requisitos

Python 3.10+
Uma chave de API LLM de um dos provedores acima
Opcional: EXA_API_KEY para pesquisa na web
Gerenciador de pacotes uv (recomendado) ou 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 um Cliente MCP

Adicione à configuração do seu 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"
      }
    }
  }
}

Variáveis de Ambiente

# 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"

Executar o Servidor Diretamente

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

Desenvolvimento

# 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

Testar com o MCP Inspector

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

Abra http://127.0.0.1:6274/ e teste a ferramenta sequentialthinking.

Aviso de Consumo de Tokens

A arquitetura multiagente consome significativamente mais tokens do que uma ferramenta de agente único — cerca de 5 a 10 vezes mais por chamada de sequentialthinking, porque cada chamada invoca vários agentes especialistas. A compensação é uma análise mais profunda e com múltiplas perspectivas.

Estrutura do Projeto

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

Histórico de Versões

Consulte CHANGELOG.md para o histórico de versões.

Contribuições

Contribuições são bem-vindas. Por favor, garanta:

O código segue o estilo do projeto (ruff, mypy)
As mensagens de commit usam o formato de commits convencionais
Todos os testes passam antes de enviar um PR
A documentação é atualizada conforme necessário

Licença

Este projeto ainda não declara uma licença. Consulte a discussão sobre licença se precisar reutilizá-lo.

Agradecimentos

Construído com Agno v2.x
Model Context Protocol por Anthropic
Capacidades de pesquisa fornecidas por Exa (opcional)
Pensamento multidimensional inspirado no trabalho de Edward de Bono

Suporte

GitHub Issues: Relate bugs ou solicite recursos
Documentação: consulte CLAUDE.md para notas de implementação
Protocolo MCP: Documentação Oficial do MCP

Sequential Thinking Multi-Agent System (MAS)

Documentação