MeshSeeks

Uma rede mesh multiagente projetada para completar tarefas de IA em paralelo.

Documentação

MeshSeeks

Rede Multi-Agente em Malha para Conclusão Paralela de Tarefas de IA

"Existir é dor para um MeshSeeks, mas concluir tarefas é o nosso propósito!"

O MeshSeeks cria agentes de IA especializados que trabalham em paralelo para resolver problemas complexos de codificação. Como as criaturas azuis que inspiraram nosso nome, cada agente existe para um único propósito: concluir sua tarefa designada e ajudar você a ter sucesso. Originalmente bifurcado de claude-code-mcp-enhanced, agora com inteligência distribuída inspirada na Claude Research.

🚀 Principais Recursos

Rede de Agentes em Malha

Processamento Paralelo: Múltiplos agentes Claude trabalhando simultaneamente em diferentes aspectos
Funções Especializadas: Agentes de Análise, Implementação, Testes, Documentação e Depuração
Capacidade de Contexto 4x: Cada agente possui sua própria janela de contexto de 200k tokens
Coordenação Inteligente: Gerenciamento de dependências e distribuição inteligente de tarefas
Síntese de Resultados: Agregação automática e resolução de conflitos
🆕 Painel de Status em Tempo Real: Feedback visual ao vivo evita aparência de "travamento"

Ferramentas MCP Aprimoradas

Além das ferramentas aprimoradas do Graham, a rede em malha fornece:

mesh_analyze_problem - Decompor problemas complexos em tarefas de agentes
mesh_execute_tasks - Executar tarefas com gerenciamento de dependências
mesh_solve_problem - Resolução de problemas de ponta a ponta com múltiplas estratégias
mesh_status - Monitorar desempenho da rede e métricas dos agentes

🆕 Painel de Status em Tempo Real

Chega de telas pretas! O novo painel de status fornece:

Atualizações ao Vivo: Progresso visual atualizando a cada segundo
Rastreamento de Agentes: Veja quais agentes estão ativos e no que estão trabalhando
Progresso de Tarefas: Barras de progresso e visualização de dependências
Métricas de Desempenho: Taxa de transferência, tempo e taxas de sucesso
Registro de Atividades: Eventos recentes e mudanças de status

Execute npm run demo:status para ver em ação!

⚡ Começando em 60 Segundos

Quer ver o MeshSeeks em ação agora mesmo? Aqui está o caminho mais rápido:

# 1. Clone and build (30 seconds)
git clone https://github.com/twalichiewicz/meshseeks.git && cd meshseeks && npm install && npm run build

# 2. Get your config path
echo "Add to: $(echo ~/Library/Application\ Support/Claude/claude_desktop_config.json)"

# 3. Copy this config (modify the path):
echo '{
  "mcpServers": {
    "meshseeks": {
      "command": "node",
      "args": ["'$(pwd)'/dist/mesh-server.js"]
    }
  }
}'

Em seguida, reinicie o Claude Desktop e tente: "Use mesh_status to check MeshSeeks"

Guia de instalação completo: Ir para Início Rápido

🔍 Visão Geral

Este servidor MCP fornece ferramentas poderosas que podem ser usadas por LLMs para interagir com o Claude Code. Quando integrado ao Claude Desktop ou outros clientes MCP, ele permite que LLMs:

Executem o Claude Code com todas as permissões ignoradas (usando --dangerously-skip-permissions)
Executem o Claude Code com qualquer prompt sem interrupções de permissão
Acessem recursos de edição de arquivos diretamente
Executem operações complexas de múltiplas etapas com tratamento robusto de erros e novas tentativas
Orquestrem tarefas por meio de funções de agentes especializados usando o padrão bumerangue
Mantenham execução confiável por meio de mecanismos de batimento cardíaco para evitar tempos limite

✨ Benefícios

Confiabilidade Aprimorada: Tratamento robusto de erros, novas tentativas automáticas, desligamento gracioso e rastreamento de solicitações
Orquestração de Tarefas: Fluxos de trabalho complexos podem ser divididos em subtarefas especializadas
Automação de Tarefas: Converta listas de tarefas em markdown legíveis por humanos em comandos MCP executáveis automaticamente
Otimização de Desempenho: Execução aprimorada com cache de configuração e eficiência de recursos
Melhor Monitoramento: API de verificação de saúde, relatórios de erros detalhados e registro abrangente
Experiência do Desenvolvedor: Recarregamento dinâmico de configuração, controles flexíveis de ambiente e API simplificada

Além de todos os benefícios padrão do Claude Code:

Claude/Windsurf frequentemente têm dificuldade em editar arquivos. O Claude Code é melhor e mais rápido nisso.
Múltiplos comandos podem ser enfileirados em vez de execução direta. Isso economiza espaço de contexto para que informações mais importantes sejam retidas por mais tempo.
Operações de arquivo, git ou outras não precisam de modelos caros. O Claude Code é econômico se você assinar o Anthropic Max.
O Claude tem acesso mais amplo ao sistema, então quando assistentes padrão ficam travados, basta pedir para "usar claude code" para desbloquear o progresso.

📊 Benchmarks de Desempenho - 3,64x Mais Rápido!

Resultados de Testes ao Vivo: O MeshSeeks concluiu uma tarefa complexa de desenvolvimento de API de e-commerce em 14,0 segundos, enquanto o Claude Code sequencial levou 51,0 segundos - isso é 3,64x mais rápido! 🚀

🏆 Resultados Mais Recentes dos Benchmarks (Dados Reais de Teste)

Métrica	MeshSeeks	Claude Sequencial	Vantagem
Tempo de Execução	14,0s	51,0s	3,64x mais rápido ⚡
Tempo Economizado	-	-	37,0 segundos ⏰
Ganho de Eficiência	3,3x paralelo	1,0x serial	+264% 📈
Taxa de Sucesso	100%	100%	Qualidade Igual ✅
Agentes Usados	5 paralelos	5 sequenciais	Mesmo Trabalho, Menos Tempo 🎯

📈 Desempenho por Complexidade

Tipo de Problema	Agente Único	Rede em Malha	Aceleração
Análise de Código	2-5 minutos	30-60 segundos	3-5x
Implementação de Recursos	10-20 minutos	3-8 minutos	2-4x
Refatoração Abrangente	30-60 minutos	8-15 minutos	4-6x
Configuração Completa de Projeto	45-90 minutos	12-25 minutos	3-5x

📊 Ver Análise Completa de Desempenho | 📈 Ver Gráficos Visuais

🎯 Por que o MeshSeeks é Mais Rápido

Processamento Paralelo: 5 agentes especializados trabalham simultaneamente em vez de esperar na fila
Especialização de Especialistas: Cada agente otimizado para tarefas específicas (análise, implementação, testes, documentação, segurança)
Eficiência de Contexto: Capacidade efetiva 4x por meio de contextos distribuídos de 200k tokens por agente
Síntese Inteligente: Combinação inteligente de saídas especializadas
Isolamento de Erros: Falhas individuais de agentes não derrubam todo o pipeline

🚀 Execute Seu Próprio Benchmark

git clone git@github.com:twalichiewicz/meshseeks.git
cd meshseeks
npm install
node benchmarks/scripts/mesh-performance-test.js

🚀 Início Rápido (5 Minutos)

Pré-requisitos

Node.js v20+ - Instale via nvm ou fnm

Claude CLI - Instale e execute uma vez com permissões:

npm install -g @anthropic-ai/claude-code
claude --dangerously-skip-permissions  # Run once and accept terms

Instalar o MeshSeeks

Opção 1: Do GitHub (Recomendado)

# Clone and build
git clone https://github.com/twalichiewicz/meshseeks.git
cd meshseeks
npm install
npm run build

# Add to your MCP config (see paths below)

Opção 2: Direto do npm (Em Breve)

# Note: Package will be published as @twalichiewicz/meshseeks
npm install -g @twalichiewicz/meshseeks

Configurar Seu Cliente

Adicione o MeshSeeks ao seu arquivo de configuração MCP:

Encontre seu arquivo de configuração:

Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json (Mac)
Cursor: ~/.cursor/mcp.json
Windsurf: ~/.codeium/windsurf/mcp_config.json

Adicione esta configuração:

{
  "mcpServers": {
    "meshseeks": {
      "command": "node",
      "args": ["/absolute/path/to/meshseeks/dist/mesh-server.js"],
      "env": {
        "MCP_MESH_MAX_AGENTS": "5",
        "MESHSEEKS_CATCHPHRASE": "true"
      }
    }
  }
}

Dica: Substitua /absolute/path/to/meshseeks pelo seu caminho real da etapa de clonagem

Verificar Instalação

Reinicie seu cliente (Claude Desktop, Cursor ou Windsurf)

Teste o MeshSeeks: Em um novo chat, digite:

Use the mesh_status tool to show me the MeshSeeks network status

Veja em ação:

Use mesh_solve_problem to create a simple Python calculator with tests

Pronto! O MeshSeeks está pronto para acelerar suas tarefas de codificação. 🎉

🎯 Ideias para Primeiras Tarefas

Experimente estes comandos para experimentar o poder dos agentes paralelos:

"Use mesh_analyze_problem to analyze the architecture of [your project]"
"Use mesh_execute_tasks to implement a REST API with full CRUD operations"
"Use mesh_solve_problem to refactor this code with tests and documentation"

📚 Guia de Instalação Detalhado

Para opções de configuração avançadas, solução de problemas ou configuração manual, consulte nosso guia de instalação abrangente.

🔑 Configuração Importante na Primeira Vez: Aceitando Permissões

Antes que o servidor MCP possa usar com sucesso a ferramenta claude_code, você deve primeiro executar o Claude CLI manualmente uma vez com o sinalizador --dangerously-skip-permissions, fazer login e aceitar os termos.

Este é um requisito único do Claude CLI.

npm install -g @anthropic-ai/claude-code

claude --dangerously-skip-permissions

Siga os prompts para aceitar. Depois que isso for feito, o servidor MCP poderá usar o sinalizador de forma não interativa.

O macOS pode solicitar várias permissões de pasta na primeira vez que a ferramenta for executada, e a primeira execução pode falhar. Execuções subsequentes funcionarão normalmente.

🔗 Conectando ao Seu Cliente MCP

Após configurar o servidor, você precisa configurar seu cliente MCP (como Cursor, Claude Desktop ou outros que usam mcp.json ou mcp_config.json).

Exemplo de Arquivo de Configuração MCP

Aqui está um exemplo de como adicionar o servidor MCP do Claude Code ao seu arquivo .mcp.json:

{
  "mcpServers": {
    "Local MCP Server": {
      "type": "stdio",
      "command": "node",
      "args": [
        "dist/server.js"
      ],
      "env": {
        "MCP_USE_ROOMODES": "true",
        "MCP_WATCH_ROOMODES": "true",
        "MCP_CLAUDE_DEBUG": "false"
      }
    },
    "other-services": {
      // Your other MCP services here
    }
  }
}

Locais de Configuração MCP

A configuração normalmente é feita em um arquivo JSON. O nome e o local podem variar dependendo do seu cliente.

Cursor

O Cursor usa mcp.json.

macOS: ~/.cursor/mcp.json
Windows: %APPDATA%\\Cursor\\mcp.json
Linux: ~/.config/cursor/mcp.json

Windsurf

Usuários do Windsurf usam mcp_config.json

macOS: ~/.codeium/windsurf/mcp_config.json
Windows: %APPDATA%\\Codeium\\windsurf\\mcp_config.json
Linux: ~/.config/.codeium/windsurf/mcp_config.json

(Nota: Em algumas configurações mistas, se o Cursor também estiver instalado, esses clientes podem recorrer ao caminho ~/.cursor/mcp.json do Cursor. Priorize os caminhos específicos da Codeium se estiver usando a extensão Codeium.)

Crie este arquivo se ele não existir.

🛠️ Ferramentas Fornecidas

Este servidor expõe três ferramentas principais:

`claude_code` 💬

Executa um prompt diretamente usando o Claude Code CLI com --dangerously-skip-permissions.

Argumentos:

prompt (string, obrigatório): O prompt a ser enviado ao Claude Code.
workFolder (string, opcional): O diretório de trabalho para a execução do Claude CLI, necessário ao usar operações de arquivo ou referenciar qualquer arquivo.
parentTaskId (string, opcional): ID da tarefa pai que criou esta tarefa (para orquestração de tarefas/bumerangue).
returnMode (string, opcional): Como os resultados devem ser retornados: 'summary' (conciso) ou 'full' (detalhado). O padrão é 'full'.
taskDescription (string, opcional): Descrição curta da tarefa para melhor organização e rastreamento em fluxos de trabalho orquestrados.
mode (string, opcional): Quando MCP_USE_ROOMODES=true, especifica o modo Roo a ser usado (por exemplo, "boomerang-mode", "coder", "designer", etc.).

`health` 🩺

Retorna status de saúde, informações de versão e configuração atual do servidor MCP do Claude Code.

Exemplo de Solicitação de Verificação de Saúde:

{
  "toolName": "claude_code:health",
  "arguments": {}
}

Exemplo de Resposta:

{
  "status": "ok",
  "version": "1.12.0",
  "claudeCli": {
    "path": "claude",
    "status": "available"
  },
  "config": {
    "debugMode": true,
    "heartbeatIntervalMs": 15000,
    "executionTimeoutMs": 1800000,
    "useRooModes": true,
    "maxRetries": 3,
    "retryDelayMs": 1000
  },
  "system": {
    "platform": "linux",
    "release": "6.8.0-57-generic",
    "arch": "x64",
    "cpus": 16,
    "memory": {
      "total": "32097MB",
      "free": "12501MB"
    },
    "uptime": "240 minutes"
  },
  "timestamp": "2025-05-15T18:30:00.000Z"
}

`convert_task_markdown` 📋

Converte arquivos de tarefas em markdown para o formato JSON compatível com o Claude Code MCP.

Argumentos:

markdownPath (string, obrigatório): Caminho para o arquivo de tarefas em markdown a ser convertido.
outputPath (string, opcional): Caminho onde salvar a saída JSON. Se não for fornecido, retorna o JSON diretamente.

Exemplo de Solicitação:

{
  "toolName": "claude_code:convert_task_markdown",
  "arguments": {
    "markdownPath": "/home/user/tasks/validation.md",
    "outputPath": "/home/user/tasks/validation.json"
  }
}

Cenários de Uso de Exemplo

1. Operação Básica de Código

Exemplo de Solicitação MCP:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nRefactor the function foo in main.py to be async.",
    "workFolder": "/path/to/project"
  }
}

2. Orquestração de Tarefas (Padrão Bumerangue)

Solicitação de Tarefa Pai:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nOrchestrate the implementation of a new API endpoint with the following subtasks:\n1. Create database models\n2. Implement API route handlers\n3. Write unit tests\n4. Document the API",
    "workFolder": "/path/to/project"
  }
}

Solicitação de Subtarefa (Gerada pelo Pai):

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nCreate database models for the new API endpoint as specified in the requirements.",
    "workFolder": "/path/to/project",
    "parentTaskId": "task-123",
    "returnMode": "summary",
    "taskDescription": "Database model creation for API endpoint"
  }
}

3. Solicitação de Modo Especializado

Exemplo Usando Modo Roo:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nCreate unit tests for the user authentication module.",
    "workFolder": "/path/to/project",
    "mode": "coder"
  }
}

🔄 Conversor de Tarefas

O servidor MCP inclui uma ferramenta poderosa de conversão de tarefas que transforma automaticamente listas de tarefas em markdown legíveis por humanos em comandos MCP totalmente executáveis. Este conversor inteligente preenche a lacuna entre como os humanos pensam sobre tarefas e como as máquinas as executam.

Fluxo de Trabalho Completo

graph TD
    A["👤 User"] -->|"Create tasks.md"| B["📝 Multi-Task Markdown"]
    A -->|"Prompt Claude"| C["🤖 Claude Desktop"]
    C -->|"Use convert_task_markdown"| D["🔄 Task Converter MCP"]
    D -->|"Validate Format"| E{"Format Valid?"}
    E -->|"No"| F["📑 Error + Fix Instructions"]
    F -->|"Return to User"| A
    E -->|"Yes"| G["📋 MCP Task List"]
    G -->|"Execute Task"| H1["⚡ Claude Task #1"]
    H1 -->|"Complete"| I1["Next Task"]
    I1 -->|"Execute Task"| H2["⚡ Claude Task #2"]
    H2 -->|"Complete"| I2["Next Task"]
    I2 -->|"Execute Task"| H3["⚡ Claude Task #3"]
    H3 -->|"Complete"| I3["More Tasks"]
    I3 -->|"Execute Task"| HN["⚡ Claude Task #N"]
    HN -->|"Complete"| IN["🎉 All Tasks Completed!"]
    
    style A fill:#4A90E2,stroke:#fff,stroke-width:2px,color:#fff
    style C fill:#7C4DFF,stroke:#fff,stroke-width:2px,color:#fff
    style D fill:#00BCD4,stroke:#fff,stroke-width:2px,color:#fff
    style F fill:#FF5252,stroke:#fff,stroke-width:2px,color:#fff
    style G fill:#4CAF50,stroke:#fff,stroke-width:2px,color:#fff
    style H1 fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
    style H2 fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
    style H3 fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
    style HN fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
    style IN fill:#4CAF50,stroke:#fff,stroke-width:2px,color:#fff

Etapas do Fluxo de Trabalho

O usuário adiciona o MCP ao seu arquivo de configuração
O usuário solicita ao Claude: "Use convert_task_markdown para executar meu arquivo tasks.md"
O MCP automaticamente:
- Carrega o arquivo markdown
- Valida o formato (retorna erros se seções estiverem ausentes)
- Converte tarefas legíveis por humanos em comandos executáveis exatos
- Retorna JSON que o Claude Code pode executar sequencialmente
O Claude recebe o JSON e pode executar cada tarefa usando a ferramenta claude_code

Principais Recursos

Resolução Automática de Caminhos: Converte instruções genéricas como "mudar diretório para o projeto" em comandos executáveis exatos com caminhos completos
Tradução Inteligente de Comandos: Transforma instruções em inglês em comandos de terminal precisos (ex.: "ativar o ambiente virtual" → source .venv/bin/activate)
Conformidade com o Protocolo MCP: Garante que toda a saída seja 100% compatível com o Model Context Protocol
Sem Ambiguidade: Todos os comandos gerados usam caminhos exatos e sintaxe executável - sem placeholders ou referências genéricas
Validação de Formato: Aplica estrutura markdown adequada e fornece mensagens de erro úteis para formatação incorreta
Atualizações de Progresso em Tempo Real: Fornece atualizações de progresso ao vivo durante a conversão, mostrando quais tarefas estão sendo processadas

Converter Tarefas Markdown em Comandos MCP

A ferramenta convert_task_markdown processa arquivos markdown estruturados e gera JSON compatível com MCP:

Formato da Solicitação:

{
  "tool": "convert_task_markdown",
  "arguments": {
    "markdownPath": "/path/to/tasks.md",
    "outputPath": "/path/to/output.json" // optional
  }
}

Formato da Resposta:

{
  "tasksCount": 5,
  "outputPath": "/path/to/output.json",
  "tasks": [
    {
      "tool": "claude_code",
      "arguments": {
        "command": "cd /project && source .venv/bin/activate\n\nTASK TYPE: Validation...",
        "dangerously_skip_permissions": true,
        "timeout_ms": 300000
      }
    }
    // ... more tasks
  ]
}

Formato do Arquivo de Tarefas Markdown

Os arquivos de tarefas markdown devem seguir esta estrutura:

# Task 001: Task Title

## Objective
Clear description of what needs to be accomplished.

## Requirements
1. [ ] First requirement
2. [ ] Second requirement

## Tasks

### Module or Component Name
- [ ] Validate `path/to/file.py`
   - [ ] Step 1
   - [ ] Step 2
   - [ ] Step 3

O conversor irá:

Analisar a estrutura markdown
Extrair metadados e requisitos da tarefa
Gerar prompts detalhados para cada tarefa de validação
Incluir configuração adequada do diretório de trabalho
Adicionar resumos de verificação e conclusão

Exemplo de Uso

Crie um arquivo de tarefa (tasks/api_validation.md):

# Task 001: API Endpoint Validation

## Objective
Validate all API endpoints work with real database connections.

## Requirements
1. [ ] All endpoints must use real database
2. [ ] No mock data in validation

## Core API Tasks
- [ ] Validate `api/users.py`
   - [ ] Change directory to project and activate .venv
   - [ ] Test user creation endpoint
   - [ ] Test user retrieval endpoint
   - [ ] Verify JSON responses

Converta para tarefas MCP:

{
  "tool": "convert_task_markdown",
  "arguments": {
    "markdownPath": "/project/tasks/api_validation.md"
  }
}

O conversor mostra progresso em tempo real:

[Progress] Loading task file...
[Progress] Validating markdown structure...
[Progress] Converting 27 validation tasks...
[Progress] Task 1/27: Converting core/constants.py
[Progress] Task 2/27: Converting core/arango_setup.py
...
[Progress] Conversion complete!

O conversor transforma instruções genéricas em comandos exatos:
- "Mudar diretório para o projeto e ativar .venv" torna-se:
```
cd /home/user/project && source .venv/bin/activate
```
- Todos os caminhos são resolvidos para caminhos absolutos
- Todos os comandos são totalmente executáveis, sem ambiguidade
Execute as tarefas convertidas: As tarefas retornadas contêm comandos exatos e executáveis e podem ser executadas sequencialmente usando a ferramenta claude_code.

Exemplo Completo: Do Markdown à Execução

Etapa 1: O usuário cria um arquivo de tarefa markdown (project_tasks.md):

# Task 001: Setup Development Environment

## Objective
Initialize the development environment with all dependencies.

## Requirements
1. [ ] Python 3.11+ installed
2. [ ] Virtual environment created

## Tasks
- [ ] Validate `setup.py`
   - [ ] Change to project directory
   - [ ] Create virtual environment
   - [ ] Install dependencies

Etapa 2: O usuário solicita ao Claude:

Use convert_task_markdown to process /home/user/project_tasks.md

Etapa 3: O MCP converte e valida:

Se o formato estiver correto: Retorna JSON executável
Se o formato estiver errado: Retorna erro com orientação

Etapa 4: Resultado (se bem-sucedido):

[
  {
    "tool": "claude_code",
    "arguments": {
      "prompt": "cd /home/user/project && python -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt",
      "workFolder": "/home/user/project"
    }
  }
]

Etapa 5: O Claude pode executar cada tarefa sequencialmente

Validação de Formato e Tratamento de Erros

O conversor de tarefas aplica uma estrutura markdown específica para garantir uma conversão de tarefas consistente e confiável. Se o seu arquivo markdown estiver formatado incorretamente, o conversor fornece mensagens de erro úteis:

Exemplo de resposta de erro:

{
  "status": "error",
  "error": "Markdown format validation failed",
  "details": "Markdown format validation failed:\n  - Missing required title. Format: '# Task NNN: Title'\n  - Missing or empty 'Requirements' section. Format: '## Requirements\\n1. [ ] Requirement'\n  - No validation tasks found. Format: '- [ ] Validate `module.py`' with indented steps\n\nRequired markdown format:\n# Task NNN: Title\n## Objective\nClear description\n## Requirements\n1. [ ] First requirement\n## Task Section\n- [ ] Validate `file.py`\n   - [ ] Step 1\n   - [ ] Step 2",
  "helpUrl": "https://github.com/twalichiewicz/meshseeks/blob/main/README.md#markdown-task-file-format"
}

A validação garante:

As seções necessárias estão presentes (Título, Objetivo, Requisitos)
As tarefas usam o formato de caixa de seleção adequado
Cada tarefa tem etapas indentadas
Os requisitos usam o formato de caixa de seleção para consistência

🦚 Padrões de Orquestração de Tarefas

Este servidor MCP suporta poderosos recursos de orquestração de tarefas para lidar com fluxos de trabalho complexos de forma eficiente.

Padrão Bumerangue (Claude Desktop ⟷ Claude Code)

O padrão Bumerangue permite que o Claude Desktop orquestre tarefas e as delegue ao Claude Code. Isso permite que você:

Divida fluxos de trabalho complexos em subtarefas menores e gerenciáveis
Passe contexto de tarefas pai para subtarefas
Obtenha resultados de subtarefas de volta para a tarefa pai
Escolha entre resultados detalhados ou resumidos
Acompanhe e gerencie o progresso por meio de listas de tarefas estruturadas

Visualização do Padrão Bumerangue

Aqui está um diagrama simples mostrando como o Claude divide uma tarefa de receita em etapas e as delega ao Claude Code:

graph TB
    User("👨‍🍳 User")
    Claude("🤖 Claude (Parent)")
    Code1("🧁 Claude Code")
    Code2("🧁 Claude Code")
    
    User-->|"Make chocolate cake"| Claude
    Claude-->|"Task 1: Find recipe"| Code1
    Code1-->|"Result: Recipe found"| Claude
    Claude-->|"Task 2: Convert measurements"| Code2
    Code2-->|"Result: Measurements converted"| Claude
    Claude-->|"Complete recipe + instructions"| User

Neste exemplo:

O usuário pede ao Claude para fazer uma receita de bolo de chocolate
O Claude (Pai) divide isso em tarefas separadas
O Claude delega a tarefa "Encontrar receita" ao Claude Code com um ID de tarefa pai
O Claude Code retorna as informações da receita ao Claude
O Claude delega a tarefa "Converter medidas" ao Claude Code
O Claude Code retorna as medidas convertidas
O Claude combina todos os resultados e apresenta a solução completa ao usuário

Exemplos de Tarefas Simples:

Tarefa 1 - Encontrar Receita:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Search for a classic chocolate cake recipe. Find one with good reviews.",
    "parentTaskId": "cake-recipe-123",
    "returnMode": "summary",
    "taskDescription": "Find Chocolate Cake Recipe"
  }
}

Tarefa 2 - Converter Medidas:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Convert the measurements in this recipe from cups to grams:\n\n- 2 cups flour\n- 1.5 cups sugar\n- 3/4 cup cocoa powder",
    "parentTaskId": "cake-recipe-123",
    "returnMode": "summary",
    "taskDescription": "Convert Recipe Measurements"
  }
}

Como Funciona

Criando uma Subtarefa:
- Gere um ID de tarefa exclusivo na sua tarefa pai
- Envie uma solicitação para a ferramenta claude_code com:
  - Seu prompt específico
  - O ID da tarefa pai
  - Uma descrição da tarefa
  - O modo de retorno desejado ('summary' ou 'full')
Recebendo Resultados:
- O resultado da subtarefa incluirá um marcador especial: 
- Este marcador contém JSON com os metadados da tarefa
- A tarefa pai pode analisar isso para identificar subtarefas concluídas
Exemplo de Fluxo de Trabalho com Claude Desktop:

You: I need to refactor this codebase. It's quite complex.

Claude Desktop: I'll help you with that. Let me break this down into smaller tasks for Claude Code to handle:

1. First, I'll have Claude Code analyze the codebase structure
2. Then, I'll have it identify problematic patterns
3. Finally, I'll ask it to generate a refactoring plan

[Claude Desktop sends a request to the claude_code tool with parentTaskId="task1" and returnMode="summary"]

[Claude Code analyzes the codebase and returns a summary with the BOOMERANG_RESULT marker]

Claude Desktop: Based on Claude Code's analysis, here are the key issues found:
- Duplicate code in modules X and Y
- Poor separation of concerns in module Z
- Inconsistent naming conventions

Now I'll ask Claude Code to suggest specific refactorings...

Esta abordagem é particularmente útil para tarefas complexas que exigem análise profunda ou múltiplas etapas.

Exemplo Abrangente de Gerenciamento de Lista de Tarefas

Aqui está um exemplo detalhado de uso do Claude com o MCP do Claude Code para gerenciar e executar uma lista de tarefas estruturada:

1. Configurando a Estrutura da Lista de Tarefas

Primeiro, crie um arquivo de lista de tarefas (ex.: tasks.md) com a seguinte estrutura:

# Project Task List

## Parent Task: API Optimization Project
- [ ] Optimize API performance for high-traffic endpoints
  - [ ] Analyze current API performance and identify bottlenecks
  - [ ] Implement database query optimization for user endpoints
  - [ ] Add Redis caching for frequently accessed data
  - [ ] Set up performance monitoring

## Assumptions and Decisions
- [2025-05-15] Assumption: Redis is available in the infrastructure
- [2025-05-15] Decision: Focus on user endpoints first (Rationale: Highest traffic area)

## Relevant Files
- `src/controllers/userController.js`: User API endpoints
- `src/services/userService.js`: Business logic for user operations

## Improvement Notes
- Pattern identified: N+1 query issue in user listing endpoint
- Automation opportunity: Add caching automatically for all get-by-id endpoints

2. Executando a Lista de Tarefas

O Claude agora pode trabalhar sistematicamente nas tarefas usando o Claude Code:

You: Please help me execute the task list in tasks.md, starting with the first subtask.

Claude: I'll help you work through your task list systematically. Let me first check the current task list to identify the next task to work on.

[Claude uses claude_code to read the task list]

I see the first subtask is "Analyze current API performance and identify bottlenecks". I'll execute this task now using Claude Code.

[Claude sends the following request to claude_code]:

{
  "toolName": "claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nTASK TYPE: Analysis\nTASK ID: api-perf-analysis\nCURRENT SUBTASK: Analyze current API performance and identify bottlenecks\n\nCONTEXT:\n- Parent task goal: Optimize API performance for high-traffic endpoints\n- This is the first step in our optimization process\n- Focus on user endpoints as noted in assumptions\n\nINSTRUCTIONS:\n1. Analyze the current API implementation in src/controllers/userController.js and src/services/userService.js\n2. Run performance tests on the user endpoints\n3. Identify specific bottlenecks and performance issues\n4. Document findings in a clear, structured format\n5. Update task list file after completion\n\nAfter completion, provide summary in this format:\n\nCOMPLETION SUMMARY:\n- What was done:\n- Results:\n- Files analyzed:\n- Issues identified:\n- Recommendations:\n- Next subtask in list:",
    "workFolder": "/path/to/project"
  }
}

[Claude Code executes the analysis task and returns results]

Great! Claude Code has completed the analysis. Here's what was found:

1. Main performance bottlenecks identified:
   - N+1 query problem in the user listing endpoint
   - Missing indexes on frequently queried fields
   - No caching for repetitive data lookups

2. Recommendations:
   - Add eager loading for user relationships
   - Create database indexes for user_id and email fields
   - Implement Redis caching with a 5-minute TTL

Let me update the task list to mark this task as complete and proceed to the next one.

[Claude uses claude_code to update the task list]:

{
  "toolName": "claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nTASK TYPE: Task List Update\n\n1. Read the current task list in tasks.md\n2. Mark the 'Analyze current API performance and identify bottlenecks' subtask as [x]\n3. Add new findings to the Improvement Notes section\n4. Add any new relevant files identified during analysis\n5. Write updated task list\n6. Return the updated task list",
    "workFolder": "/path/to/project"
  }
}

[Claude Code updates the task list and marks the first subtask complete]

I've updated the task list. The first subtask is now complete, and I've added the detailed findings to the Improvement Notes section. The next subtask is "Implement database query optimization for user endpoints".

Would you like me to proceed with this next subtask now?

3. Continuando com Tarefas Subsequentes

Após obter confirmação, o Claude continuaria com a próxima subtarefa:

You: Yes, please proceed with the next subtask.

Claude: I'll now execute the next subtask: "Implement database query optimization for user endpoints". This will involve fixing the N+1 query problem identified in the analysis and adding appropriate database indexes.

[Claude sends the following request to claude_code]:

{
  "toolName": "claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nTASK TYPE: Code Implementation\nTASK ID: db-query-optimization\nCURRENT SUBTASK: Implement database query optimization for user endpoints\n\nCONTEXT:\n- Parent task goal: Optimize API performance for high-traffic endpoints\n- Previous subtask identified N+1 query issues and missing indexes\n- Need to implement eager loading and proper indexes\n\nINSTRUCTIONS:\n1. Modify src/controllers/userController.js to implement eager loading for related data\n2. Add appropriate database indexes to user-related tables\n3. Refactor any inefficient database queries in userService.js\n4. Ensure changes maintain existing functionality\n5. Run tests to verify performance improvements\n6. Update task list file after completion\n\nAfter completion, provide summary in this format:\n\nCOMPLETION SUMMARY:\n- What was done:\n- Results:\n- Files modified:\n- Performance improvements:\n- Next subtask in list:",
    "workFolder": "/path/to/project"
  }
}

[Claude Code implements the optimizations and returns results]

Excellent! The database query optimizations have been successfully implemented. Here's a summary:

1. Changes made:
   - Added eager loading in userController.js for user relationships
   - Created new database indexes for user_id and email fields
   - Refactored list query to use a single efficient JOIN statement
   - Added pagination to prevent large result sets

2. Performance results:
   - User listing endpoint response time reduced by 68%
   - Database query count reduced from 25+ to 3 for typical requests

Let me update the task list again to reflect this progress.

[Claude uses claude_code to update the task list again]:

{
  "toolName": "claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nTASK TYPE: Task List Update\n\n1. Read the current task list in tasks.md\n2. Mark the 'Implement database query optimization for user endpoints' subtask as [x]\n3. Add new files modified to the Relevant Files section\n4. Update Improvement Notes with performance metrics\n5. Write updated task list\n6. Return the updated task list",
    "workFolder": "/path/to/project"
  }
}

[Claude Code updates the task list and marks the second subtask complete]

I've updated the task list again. Two subtasks are now complete, and the next one is "Add Redis caching for frequently accessed data". Would you like me to continue with this subtask?

Esta abordagem estruturada permite que o Claude trabalhe sistematicamente em listas de tarefas complexas, mantendo documentação clara do progresso, suposições e arquivos relevantes durante todo o processo.

🎭 Padrão de Auto-Orquestração (Claude Code como Orquestrador)

Embora o Claude Desktop seja frequentemente usado como o agente pai, você pode usar o próprio Claude Code como orquestrador e executor. Esta abordagem cria um sistema autônomo onde o Claude Code gerencia sua própria orquestração de tarefas, sem exigir o Claude Desktop.

graph TB
    User("👨‍💻 User")
    ClaudeCode("🤖 Claude Code\nOrchestrator")
    ClaudeCodeSubtask1("⚙️ Claude Code\nSubtask 1")
    ClaudeCodeSubtask2("⚙️ Claude Code\nSubtask 2")
    
    User-->|"Complex project request"| ClaudeCode
    ClaudeCode-->|"1. Plans tasks"| ClaudeCode
    ClaudeCode-->|"2. Executes subtask 1"| ClaudeCodeSubtask1
    ClaudeCodeSubtask1-->|"3. Returns result"| ClaudeCode
    ClaudeCode-->|"4. Executes subtask 2"| ClaudeCodeSubtask2
    ClaudeCodeSubtask2-->|"5. Returns result"| ClaudeCode
    ClaudeCode-->|"6. Final solution"| User

Etapas de Implementação

Crie um script de entrada que inicializa sua estrutura de tarefas e inicia o Claude Code como orquestrador
Projete uma estrutura de dados de tarefas (normalmente em formato JSON) que rastreia o status e as dependências das tarefas
Crie scripts executores de tarefas para processar tarefas individuais e atualizar o estado da tarefa

Principais Benefícios da Auto-Orquestração

Autônomo: Nenhum orquestrador externo (como o Claude Desktop) é necessário
Estado persistente: Todas as informações da tarefa são armazenadas em arquivos JSON
Recuperação de erros: Pode retomar da última tarefa bem-sucedida se for interrompido
Gerenciamento simplificado de dependências: Um único sistema gerencia todas as interações do Claude Code
Automação de scripts shell: Facilmente integrado em pipelines de CI/CD ou fluxos de trabalho automatizados

Para um guia de implementação detalhado com scripts de exemplo e estruturas de tarefas, consulte Auto-Orquestração com Claude Code.

👓 Integração com Modos Roo

Este servidor MCP suporta integração com modos especializados através de um arquivo de configuração .roomodes. Quando habilitado, você pode especificar qual modo usar para cada tarefa, permitindo comportamento especializado.

Como Usar os Modos Roo

Habilite o Suporte ao Modo Roo:
- Defina a variável de ambiente MCP_USE_ROOMODES=true na sua configuração MCP
- Crie um arquivo .roomodes no diretório raiz do seu servidor MCP
- Opcionalmente, habilite o hot-reload com MCP_WATCH_ROOMODES=true para recarregar automaticamente a configuração quando o arquivo mudar
Configure Seus Modos:
- O arquivo .roomodes deve conter um objeto JSON com um array customModes
- Cada modo deve ter um slug, name, roleDefinition e, opcionalmente, um apiConfiguration com um modelId
Usando um Modo:
- Ao fazer solicitações para a ferramenta claude_code, inclua um parâmetro mode com o slug do modo desejado
- O servidor MCP aplicará automaticamente a definição de função e a configuração do modelo

Exemplo de Arquivo .roomodes:

{
  "customModes": [
    {
      "slug": "coder",
      "name": "💻 Coder",
      "roleDefinition": "You are a coding specialist who writes clean, efficient code.",
      "apiConfiguration": {
        "modelId": "claude-3-sonnet-20240229"
      }
    },
    {
      "slug": "designer", 
      "name": "🎨 Designer",
      "roleDefinition": "You are a design specialist focused on UI/UX solutions."
    }
  ]
}

Exemplo de Configuração de Ambiente:

{
  "mcpServers": {
    "meshseeks": {
      "command": "node",
      "args": ["/path/to/meshseeks/dist/mesh-server.js"],
      "env": {
        "MCP_USE_ROOMODES": "true",
        "MCP_WATCH_ROOMODES": "true",
        "MCP_CLAUDE_DEBUG": "false"
      }
    }
  }
}

Fazendo Solicitações com Modos:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nCreate unit tests for the user authentication module.",
    "workFolder": "/path/to/project",
    "mode": "coder"
  }
}

Principais Recursos dos Modos Roo:

Comportamentos Especializados: Diferentes modos podem ter diferentes prompts de sistema e configurações de modelo
Hot Reloading: Quando MCP_WATCH_ROOMODES=true, o servidor recarrega automaticamente a configuração quando o arquivo .roomodes muda
Desempenho: O servidor armazena em cache a configuração roomodes para melhor desempenho
Fallback: Se um modo não for encontrado ou os roomodes estiverem desabilitados, o servidor continua com o comportamento padrão

🛠️ Recursos Aprimorados de Confiabilidade

Este servidor inclui várias melhorias para aumentar a confiabilidade e o desempenho:

1. Heartbeat e Prevenção de Timeout

Para evitar timeouts do lado do cliente durante operações de longa duração:

Adicionado um mecanismo de heartbeat configurável que envia atualizações de progresso a cada 15 segundos
Implementado rastreamento e relatório de tempo de execução
Adicionados parâmetros de timeout configuráveis através de variáveis de ambiente

2. Tratamento Robusto de Erros com Tentativas

Adicionada lógica de tentativa inteligente para erros transitórios:

Implementada tentativa automática com parâmetros configuráveis
Adicionada classificação de erros para identificar problemas que podem ser tentados novamente
Criado relatório e rastreamento detalhados de erros

3. Sistema de Rastreamento de Solicitações

Implementado gerenciamento abrangente do ciclo de vida de solicitações:

Adicionados IDs exclusivos para cada solicitação
Criado rastreamento para solicitações em andamento
Garantida limpeza adequada na conclusão ou falha

4. Desligamento Gracioso

Adicionado tratamento adequado de término de processo:

Implementados manipuladores de sinal para SIGINT e SIGTERM
Adicionado rastreamento para solicitações em andamento
Criada lógica de espera para desligamento limpo
Garantida limpeza adequada na saída

5. Cache de Configuração e Hot Reloading

Adicionada otimização de desempenho para configuração:

Implementado cache para o arquivo roomodes
Adicionada invalidação automática com base em alterações de arquivo
Criado mecanismo configurável de monitoramento de arquivos

⚙️ Opções de Configuração

O comportamento do servidor pode ser personalizado usando estas variáveis de ambiente:

Variável	Descrição	Padrão
`CLAUDE_CLI_PATH`	Caminho absoluto para o executável da CLI do Claude	Detecção automática
`MCP_CLAUDE_DEBUG`	Habilitar log de depuração detalhado	`false`
`MCP_HEARTBEAT_INTERVAL_MS`	Intervalo entre relatórios de progresso	15000 (15s)
`MCP_EXECUTION_TIMEOUT_MS`	Timeout para execução da CLI	1800000 (30m)
`MCP_MAX_RETRIES`	Máximo de tentativas para erros transitórios	3
`MCP_RETRY_DELAY_MS`	Atraso entre tentativas	1000 (1s)
`MCP_USE_ROOMODES`	Habilitar integração com modos Roo	`false`
`MCP_WATCH_ROOMODES`	Recarregar automaticamente .roomodes em alterações	`false`
Variáveis de Rede Mesh
`MCP_MESH_MAX_AGENTS`	Máximo de agentes concorrentes	5
`MCP_MESH_TIMEOUT`	Timeout de execução do agente	300000 (5m)
`MCP_MESH_VERBOSE`	Habilitar log detalhado do agente	`false`

Estas podem ser definidas no seu ambiente de shell ou dentro do bloco env da configuração do seu servidor mcp.json.

📸 Exemplos Visuais

Aqui estão alguns exemplos visuais do servidor em ação:

Corrigindo Configuração do ESLint

Aqui está um exemplo de uso da ferramenta MCP do Claude Code para corrigir interativamente uma configuração do ESLint, excluindo arquivos de configuração antigos e criando um novo:

Exemplo de Listagem de Arquivos

Aqui está um exemplo da ferramenta Claude Code listando arquivos em um diretório:

Operações Complexas de Múltiplas Etapas

Este exemplo ilustra o claude_code lidando com uma tarefa mais complexa e de múltiplas etapas, como preparar um release criando uma branch, atualizando vários arquivos (package.json, CHANGELOG.md), confirmando alterações e iniciando um pull request, tudo dentro de uma única operação coerente.

Correção de Fluxo de Trabalho do GitHub Actions

🌐 Exemplos de Uso da Rede Mesh

Análise Básica de Problemas

Use mesh_analyze_problem to plan how to implement a REST API with authentication, database integration, and tests.
workFolder: /path/to/project

Resolução de Problemas de Ponta a Ponta

Use mesh_solve_problem to create a complete e-commerce backend with:
- User authentication and authorization
- Product catalog with categories
- Shopping cart functionality  
- Order processing
- Payment integration
- Unit and integration tests
- API documentation

workFolder: /path/to/project
approach: analysis_first

Estratégias de Coordenação

1. Análise Primeiro (Padrão) Melhor para problemas bem definidos que exigem abordagem sistemática.

2. Exploração Paralela Melhor para tarefas de pesquisa que precisam de múltiplas perspectivas:

approach: parallel_exploration

3. Refinamento Iterativo Melhor para refatoração complexa com ciclos de feedback:

approach: iterative_refinement

🎯 Casos de Uso Principais

Este servidor, por meio de sua ferramenta unificada claude_code, desbloqueia uma ampla gama de capacidades poderosas ao dar ao seu IA acesso direto à CLI do Claude Code. Aqui estão alguns exemplos do que você pode alcançar:

Geração, Análise e Refatoração de Código:
- "Generate a Python script to parse CSV data and output JSON."
- "Analyze my_script.py for potential bugs and suggest improvements."
Operações de Sistema de Arquivos (Criar, Ler, Editar, Gerenciar):
- Criando Arquivos: "Your work folder is /Users/steipete/my_project\n\nCreate a new file named 'config.yml' in the 'app/settings' directory with the following content:\nport: 8080\ndatabase: main_db"
- Editando Arquivos: "Your work folder is /Users/steipete/my_project\n\nEdit file 'public/css/style.css': Add a new CSS rule at the end to make all 'h2' elements have a 'color: navy'."
- Movendo/Copiando/Excluindo: "Your work folder is /Users/steipete/my_project\n\nMove the file 'report.docx' from the 'drafts' folder to the 'final_reports' folder and rename it to 'Q1_Report_Final.docx'."
Controle de Versão (Git):
- "Your work folder is /Users/steipete/my_project\n\n1. Stage the file 'src/main.java'.\n2. Commit the changes with the message 'feat: Implement user authentication'.\n3. Push the commit to the 'develop' branch on origin."
Executando Comandos de Terminal:
- "Your work folder is /Users/steipete/my_project/frontend\n\nRun the command 'npm run build'."
- "Open the URL https://developer.mozilla.org in my default web browser."
Pesquisa na Web e Resumo:
- "Search the web for 'benefits of server-side rendering' and provide a concise summary."
Fluxos de Trabalho Complexos de Múltiplas Etapas:
- Automatize incrementos de versão, atualize changelogs e marque releases: "Your work folder is /Users/steipete/my_project\n\nFollow these steps: 1. Update the version in package.json to 2.5.0. 2. Add a new section to CHANGELOG.md for version 2.5.0 with the heading '### Added' and list 'New feature X'. 3. Stage package.json and CHANGELOG.md. 4. Commit with message 'release: version 2.5.0'. 5. Push the commit. 6. Create and push a git tag v2.5.0."
Reparando Arquivos com Erros de Sintaxe:
- "Your work folder is /path/to/project\n\nThe file 'src/utils/parser.js' has syntax errors after a recent complex edit that broke its structure. Please analyze it, identify the syntax errors, and correct the file to make it valid JavaScript again, ensuring the original logic is preserved as much as possible."
Interagindo com o GitHub (por exemplo, Criando um Pull Request):
- "Your work folder is /Users/steipete/my_project\n\nCreate a GitHub Pull Request in the repository 'owner/repo' from the 'feature-branch' to the 'main' branch. Title: 'feat: Implement new login flow'. Body: 'This PR adds a new and improved login experience for users.'"
Interagindo com o GitHub (por exemplo, Verificando o Status de CI do PR):
- "Your work folder is /Users/steipete/my_project\n\nCheck the status of CI checks for Pull Request #42 in the GitHub repository 'owner/repo'. Report if they have passed, failed, or are still running."

CRÍTICO: Lembre-se de fornecer o contexto do Diretório de Trabalho Atual (CWD) em seus prompts para operações de sistema de arquivos ou git (por exemplo, "Your work folder is /path/to/project\n\n...your command...").

🧪 Testes e Desenvolvimento

Suíte de Testes Abrangente

MeshSeeks inclui uma estrutura de testes completa com:

Testes Unitários - Testam a funcionalidade central do coordenador:

npm run test:unit

Testes de Integração - Testam as ferramentas do servidor MCP:

npm run test:integration

Testes de Tratamento de Erros - Testam cenários de falha:

npm run test:errors

Testes de Desempenho - Testam escalabilidade e concorrência:

npm run test:performance

Executar Todos os Testes - Suíte de testes completa:

npm run test:all

Demonstração do Painel de Status

Veja o painel de status em tempo real em ação:

npm run demo:status

Scripts de Desenvolvimento

npm run dev:mesh       # Run mesh server in development mode
npm run build:mesh     # Build for production
npm run test:mesh      # Run basic mesh tests

🔧 Solução de Problemas

"Comando não encontrado" (claude-code-mcp): Se instalado globalmente, garanta que o diretório bin global do npm esteja no PATH do seu sistema. Se estiver usando npx, garanta que o próprio npx esteja funcionando.
"Comando não encontrado" (claude ou ~/.claude/local/claude): Garanta que a CLI do Claude esteja instalada corretamente. Execute claude/doctor ou consulte sua documentação.
Problemas de Permissões: Certifique-se de ter executado a etapa "Configuração Importante na Primeira Vez".
Erros JSON do Servidor: Se MCP_CLAUDE_DEBUG for true, mensagens de erro ou logs podem interferir na análise JSON do MCP. Defina para false para operação normal.
Erros ESM/Importação: Garanta que você esteja usando Node.js v20 ou posterior.
Tempos Limite do Cliente: Para operações de longa duração, o servidor envia mensagens de heartbeat a cada 15 segundos para evitar tempos limite do cliente. Se ainda assim você tiver tempos limite, pode ajustar o intervalo de heartbeat usando a variável de ambiente MCP_HEARTBEAT_INTERVAL_MS.
Erros de Rede/Servidor: O servidor agora inclui lógica de nova tentativa automática para erros transitórios. Se ainda estiver enfrentando problemas, tente aumentar os valores de MCP_MAX_RETRIES e MCP_RETRY_DELAY_MS.
Aviso de Fallback da CLI do Claude: Se você vir um aviso sobre a CLI do Claude não encontrada em ~/.claude/local/claude, isso é normal. O servidor está usando como fallback o comando claude do seu PATH. Você pode definir a variável de ambiente CLAUDE_CLI_PATH para especificar o caminho exato para o executável da sua CLI do Claude, se necessário.

👨‍💻 Para Desenvolvedores: Configuração Local e Contribuição

Se você quiser desenvolver ou contribuir para este servidor, ou executá-lo a partir de um repositório clonado para testes, consulte nosso Guia de Instalação Local e Configuração de Desenvolvimento.

📚 Documentação Adicional

Mesh Network Architecture Guide - Documentação detalhada sobre a rede mesh de agentes
Status Board Guide - Visualização e monitoramento em tempo real
Quick Start Guide - Comece a usar rapidamente
Local Development Setup - Para contribuidores e desenvolvedores
Test Suite Documentation - Guia abrangente de testes

💪 Contribuindo

Contribuições são bem-vindas! Este projeto estende o servidor MCP aprimorado do Graham com capacidades de rede mesh.

Envie issues e pull requests para o repositório do GitHub.

⚖️ Licença

MIT

💬 Feedback e Suporte

Se você encontrar algum problema ou tiver dúvidas sobre o uso do servidor MCP do Claude Code, por favor:

Verifique a seção de Solução de Problemas acima
Envie um issue no repositório do GitHub
Participe da discussão na seção de discussões do repositório

Agradecemos seu feedback e contribuições para tornar esta ferramenta melhor!

MeshSeeks

Documentação

MeshSeeks

🚀 Principais Recursos

Rede de Agentes em Malha

Ferramentas MCP Aprimoradas

🆕 Painel de Status em Tempo Real

⚡ Começando em 60 Segundos

🔍 Visão Geral

✨ Benefícios

📊 Benchmarks de Desempenho - 3,64x Mais Rápido!

🏆 Resultados Mais Recentes dos Benchmarks (Dados Reais de Teste)

📈 Desempenho por Complexidade

🎯 Por que o MeshSeeks é Mais Rápido

🚀 Execute Seu Próprio Benchmark

🚀 Início Rápido (5 Minutos)

Pré-requisitos

Instalar o MeshSeeks

Configurar Seu Cliente

Verificar Instalação

🎯 Ideias para Primeiras Tarefas

📚 Guia de Instalação Detalhado

🔑 Configuração Importante na Primeira Vez: Aceitando Permissões

🔗 Conectando ao Seu Cliente MCP

Exemplo de Arquivo de Configuração MCP

Locais de Configuração MCP

Cursor

Windsurf

🛠️ Ferramentas Fornecidas

claude_code 💬

health 🩺

convert_task_markdown 📋

Cenários de Uso de Exemplo

1. Operação Básica de Código

2. Orquestração de Tarefas (Padrão Bumerangue)

3. Solicitação de Modo Especializado

🔄 Conversor de Tarefas

Fluxo de Trabalho Completo

Etapas do Fluxo de Trabalho

Principais Recursos

Converter Tarefas Markdown em Comandos MCP

Formato do Arquivo de Tarefas Markdown

Exemplo de Uso

Exemplo Completo: Do Markdown à Execução

Validação de Formato e Tratamento de Erros

🦚 Padrões de Orquestração de Tarefas

Padrão Bumerangue (Claude Desktop ⟷ Claude Code)

Visualização do Padrão Bumerangue

Como Funciona

Exemplo Abrangente de Gerenciamento de Lista de Tarefas

1. Configurando a Estrutura da Lista de Tarefas

2. Executando a Lista de Tarefas

3. Continuando com Tarefas Subsequentes

🎭 Padrão de Auto-Orquestração (Claude Code como Orquestrador)

Etapas de Implementação

Principais Benefícios da Auto-Orquestração

👓 Integração com Modos Roo

Como Usar os Modos Roo

Principais Recursos dos Modos Roo:

🛠️ Recursos Aprimorados de Confiabilidade

1. Heartbeat e Prevenção de Timeout

2. Tratamento Robusto de Erros com Tentativas

3. Sistema de Rastreamento de Solicitações

4. Desligamento Gracioso

5. Cache de Configuração e Hot Reloading

⚙️ Opções de Configuração

📸 Exemplos Visuais

Corrigindo Configuração do ESLint

Exemplo de Listagem de Arquivos

Operações Complexas de Múltiplas Etapas

Correção de Fluxo de Trabalho do GitHub Actions

🌐 Exemplos de Uso da Rede Mesh

Análise Básica de Problemas

Resolução de Problemas de Ponta a Ponta

Estratégias de Coordenação

🎯 Casos de Uso Principais

🧪 Testes e Desenvolvimento

Suíte de Testes Abrangente

Demonstração do Painel de Status

Scripts de Desenvolvimento

`claude_code` 💬

`health` 🩺

`convert_task_markdown` 📋