MeshSeeks

Una red de malla multiagente diseñada para completar tareas de IA en paralelo.

Documentación

MeshSeeks

Red de Malla Multiagente para la Finalización Paralela de Tareas de IA

"La existencia es dolor para un MeshSeeks, ¡pero completar tareas es nuestro propósito!"

MeshSeeks genera agentes de IA especializados que trabajan en paralelo para resolver problemas de codificación complejos. Como las criaturas azules serviciales que inspiraron nuestro nombre, cada agente existe para un solo propósito: completar su tarea asignada y ayudarte a tener éxito. Originalmente bifurcado de claude-code-mcp-enhanced, ahora con inteligencia distribuida inspirada en Claude Research.

🚀 Características Principales

Red de Malla de Agentes

Procesamiento Paralelo: Múltiples agentes de Claude trabajando simultáneamente en diferentes aspectos
Roles Especializados: Agentes de Análisis, Implementación, Pruebas, Documentación y Depuración
Capacidad de Contexto 4x: Cada agente tiene su propia ventana de contexto de 200k tokens
Coordinación Inteligente: Gestión de dependencias y distribución inteligente de tareas
Síntesis de Resultados: Agregación automática y resolución de conflictos
🆕 Panel de Estado en Tiempo Real: Retroalimentación visual en vivo evita la apariencia de "congelamiento"

Herramientas MCP Mejoradas

Además de las herramientas mejoradas de Graham, la red de malla proporciona:

mesh_analyze_problem - Descomponer problemas complejos en tareas de agentes
mesh_execute_tasks - Ejecutar tareas con gestión de dependencias
mesh_solve_problem - Resolución de problemas de extremo a extremo con múltiples estrategias
mesh_status - Monitorear el rendimiento de la red y las métricas de los agentes

🆕 Panel de Estado en Tiempo Real

¡No más pantallas negras! El nuevo panel de estado proporciona:

Actualizaciones en Vivo: Progreso visual que se actualiza cada segundo
Seguimiento de Agentes: Ve qué agentes están activos y en qué están trabajando
Progreso de Tareas: Barras de progreso y visualización de dependencias
Métricas de Rendimiento: Rendimiento, tiempos y tasas de éxito
Registro de Actividad: Eventos recientes y cambios de estado

¡Ejecuta npm run demo:status para verlo en acción!

⚡ Comenzando en 60 Segundos

¿Quieres ver MeshSeeks en acción ahora mismo? Aquí está el camino más 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"]
    }
  }
}'

Luego reinicia Claude Desktop y prueba: "Use mesh_status to check MeshSeeks"

Guía de instalación completa: Ir a Inicio Rápido

🔍 Descripción General

Este servidor MCP proporciona herramientas potentes que pueden ser utilizadas por LLMs para interactuar con Claude Code. Cuando se integra con Claude Desktop u otros clientes MCP, permite a los LLMs:

Ejecutar Claude Code con todos los permisos omitidos (usando --dangerously-skip-permissions)
Ejecutar Claude Code con cualquier indicación sin interrupciones de permisos
Acceder directamente a las capacidades de edición de archivos
Ejecutar operaciones complejas de múltiples pasos con manejo robusto de errores y reintentos
Orquestar tareas a través de roles de agentes especializados usando el patrón boomerang
Mantener una ejecución confiable mediante mecanismos de latido para prevenir tiempos de espera

✨ Beneficios

Confiabilidad Mejorada: Manejo robusto de errores, reintentos automáticos, apagado elegante y seguimiento de solicitudes
Orquestación de Tareas: Los flujos de trabajo complejos se pueden dividir en subtareas especializadas
Automatización de Tareas: Convierte listas de tareas en markdown legibles por humanos en comandos MCP ejecutables automáticamente
Optimización del Rendimiento: Ejecución mejorada con caché de configuración y eficiencia de recursos
Mejor Monitoreo: API de verificación de salud, informes de errores detallados y registro integral
Experiencia del Desarrollador: Recarga en caliente de configuración, controles de entorno flexibles y API simplificada

Más todos los beneficios estándar de Claude Code:

Claude/Windsurf a menudo tienen problemas para editar archivos. Claude Code es mejor y más rápido en eso.
Se pueden poner en cola múltiples comandos en lugar de ejecución directa. Esto ahorra espacio de contexto para que la información más importante se retenga por más tiempo.
Las operaciones de archivos, git u otras no necesitan modelos costosos. Claude Code es rentable si te suscribes a Anthropic Max.
Claude tiene acceso más amplio al sistema, así que cuando los asistentes estándar se quedan atascados, solo pídeles que "usen claude code" para desbloquear el progreso.

📊 Puntos de Referencia de Rendimiento - ¡3.64x Más Rápido!

Resultados de Pruebas en Vivo: MeshSeeks completó una tarea compleja de desarrollo de API de comercio electrónico en 14.0 segundos mientras que Claude Code secuencial tomó 51.0 segundos - ¡eso es 3.64x más rápido! 🚀

🏆 Últimos Resultados de Referencia (Datos de Pruebas Reales)

Métrica	MeshSeeks	Claude Secuencial	Ventaja
Tiempo de Ejecución	14.0s	51.0s	3.64x más rápido ⚡
Tiempo Ahorrado	-	-	37.0 segundos ⏰
Ganancia de Eficiencia	3.3x paralelo	1.0x serial	+264% 📈
Tasa de Éxito	100%	100%	Calidad Igual ✅
Agentes Utilizados	5 paralelos	5 secuenciales	Mismo Trabajo, Menos Tiempo 🎯

📈 Rendimiento por Complejidad

Tipo de Problema	Agente Único	Red de Malla	Aceleración
Análisis de Código	2-5 minutos	30-60 segundos	3-5x
Implementación de Funcionalidades	10-20 minutos	3-8 minutos	2-4x
Refactorización Integral	30-60 minutos	8-15 minutos	4-6x
Configuración Completa del Proyecto	45-90 minutos	12-25 minutos	3-5x

📊 Ver Análisis de Rendimiento Completo | 📈 Ver Gráficos Visuales

🎯 Por Qué MeshSeeks es Más Rápido

Procesamiento Paralelo: 5 agentes especializados trabajan simultáneamente en lugar de esperar en cola
Especialización de Expertos: Cada agente está optimizado para tareas específicas (análisis, implementación, pruebas, documentación, seguridad)
Eficiencia de Contexto: Capacidad efectiva 4x mediante contextos distribuidos de 200k tokens por agente
Síntesis Inteligente: Combinación inteligente de resultados especializados
Aislamiento de Errores: Las fallas de agentes individuales no detienen todo el pipeline

🚀 Ejecuta Tu Propio Punto de Referencia

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

🚀 Inicio Rápido (5 Minutos)

Requisitos Previos

Node.js v20+ - Instala mediante nvm o fnm

Claude CLI - Instala y ejecuta una vez con permisos:

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

Instalar MeshSeeks

Opción 1: Desde 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)

Opción 2: Directamente desde npm (Próximamente)

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

Configurar Tu Cliente

Agrega MeshSeeks a tu archivo de configuración MCP:

Encuentra tu archivo de configuración:

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

Agrega esta configuración:

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

Consejo: Reemplaza /absolute/path/to/meshseeks con tu ruta real del paso de clonación

Verificar la Instalación

Reinicia tu cliente (Claude Desktop, Cursor o Windsurf)

Prueba MeshSeeks: En un nuevo chat, escribe:

Use the mesh_status tool to show me the MeshSeeks network status

Míralo en acción:

Use mesh_solve_problem to create a simple Python calculator with tests

¡Eso es todo! MeshSeeks está listo para acelerar tus tareas de codificación. 🎉

🎯 Ideas para las Primeras Tareas

Prueba estos comandos para experimentar el poder de los 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"

📚 Guía de Instalación Detallada

Para opciones de configuración avanzadas, solución de problemas o configuración manual, consulta nuestra guía de instalación integral.

🔑 Configuración Importante por Primera Vez: Aceptar Permisos

Antes de que el servidor MCP pueda usar exitosamente la herramienta claude_code, primero debes ejecutar manualmente la CLI de Claude una vez con la bandera --dangerously-skip-permissions, iniciar sesión y aceptar los términos.

Este es un requisito único de la CLI de Claude.

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

claude --dangerously-skip-permissions

Sigue las indicaciones para aceptar. Una vez hecho esto, el servidor MCP podrá usar la bandera de forma no interactiva.

macOS podría solicitar varios permisos de carpetas la primera vez que la herramienta se ejecuta, y la primera ejecución podría fallar. Las ejecuciones posteriores funcionarán normalmente.

🔗 Conectando a Tu Cliente MCP

Después de configurar el servidor, necesitas configurar tu cliente MCP (como Cursor, Claude Desktop u otros que usen mcp.json o mcp_config.json).

Ejemplo de Archivo de Configuración MCP

Aquí hay un ejemplo de cómo agregar el servidor MCP de Claude Code a tu archivo .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
    }
  }
}

Ubicaciones de Configuración MCP

La configuración normalmente se realiza en un archivo JSON. El nombre y la ubicación pueden variar según tu cliente.

Cursor

Cursor usa mcp.json.

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

Windsurf

Los usuarios de Windsurf usan mcp_config.json

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

(Nota: En algunas configuraciones mixtas, si Cursor también está instalado, estos clientes podrían recurrir a la ruta ~/.cursor/mcp.json de Cursor. Prioriza las rutas específicas de Codeium si usas la extensión de Codeium).

Crea este archivo si no existe.

🛠️ Herramientas Proporcionadas

Este servidor expone tres herramientas principales:

`claude_code` 💬

Ejecuta una indicación directamente usando la CLI de Claude Code con --dangerously-skip-permissions.

Argumentos:

prompt (cadena, requerido): La indicación para enviar a Claude Code.
workFolder (cadena, opcional): El directorio de trabajo para la ejecución de la CLI de Claude, requerido cuando se usan operaciones de archivos o se hace referencia a cualquier archivo.
parentTaskId (cadena, opcional): ID de la tarea padre que creó esta tarea (para orquestación de tareas/boomerang).
returnMode (cadena, opcional): Cómo se deben devolver los resultados: 'summary' (conciso) o 'full' (detallado). El valor predeterminado es 'full'.
taskDescription (cadena, opcional): Descripción breve de la tarea para una mejor organización y seguimiento en flujos de trabajo orquestados.
mode (cadena, opcional): Cuando MCP_USE_ROOMODES=true, especifica el modo de Roo a usar (por ejemplo, "boomerang-mode", "coder", "designer", etc.).

`health` 🩺

Devuelve el estado de salud, la información de versión y la configuración actual del servidor MCP de Claude Code.

Ejemplo de Solicitud de Verificación de Salud:

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

Ejemplo de Respuesta:

{
  "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` 📋

Convierte archivos de tareas en markdown al formato JSON compatible con Claude Code MCP.

Argumentos:

markdownPath (cadena, requerido): Ruta al archivo de tareas en markdown para convertir.
outputPath (cadena, opcional): Ruta donde guardar la salida JSON. Si no se proporciona, devuelve el JSON directamente.

Ejemplo de Solicitud:

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

Escenarios de Uso de Ejemplo

1. Operación Básica de Código

Ejemplo de Solicitud 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. Orquestación de Tareas (Patrón Boomerang)

Solicitud de Tarea Padre:

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

Solicitud de Subtarea (Generada por el Padre):

{
  "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. Solicitud de Modo Especializado

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

🔄 Convertidor de Tareas

El servidor MCP incluye una poderosa herramienta convertidora de tareas que transforma automáticamente listas de tareas en markdown legibles por humanos en comandos MCP totalmente ejecutables. Este convertidor inteligente cierra la brecha entre cómo los humanos piensan sobre las tareas y cómo las máquinas las ejecutan.

Flujo de Trabajo 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

Pasos del Flujo de Trabajo

El usuario agrega el MCP a su archivo de configuración
El usuario le indica a Claude: "Usa convert_task_markdown para ejecutar mi archivo tasks.md"
El MCP automáticamente:
- Carga el archivo markdown
- Valida el formato (devuelve errores si faltan secciones)
- Convierte las tareas legibles por humanos en comandos ejecutables exactos
- Devuelve JSON que Claude Code puede ejecutar secuencialmente
Claude recibe el JSON y puede ejecutar cada tarea usando la herramienta claude_code

Características Clave

Resolución Automática de Rutas: Convierte instrucciones genéricas como "cambiar directorio al proyecto" en comandos ejecutables exactos con rutas completas
Traducción Inteligente de Comandos: Transforma instrucciones en inglés en comandos de terminal precisos (por ejemplo, "activar el entorno virtual" → source .venv/bin/activate)
Cumplimiento del Protocolo MCP: Asegura que toda la salida sea 100% compatible con el Model Context Protocol
Sin Ambigüedad: Todos los comandos generados usan rutas exactas y sintaxis ejecutable - sin marcadores de posición ni referencias genéricas
Validación de Formato: Aplica una estructura de markdown adecuada y proporciona mensajes de error útiles para formatos incorrectos
Actualizaciones de Progreso en Tiempo Real: Proporciona actualizaciones de progreso en vivo durante la conversión mostrando qué tareas se están procesando

Convertir Tareas de Markdown a Comandos MCP

La herramienta convert_task_markdown procesa archivos markdown estructurados y genera JSON compatible con MCP:

Formato de Solicitud:

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

Formato de Respuesta:

{
  "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 de Archivo de Tareas Markdown

Los archivos de tareas markdown deben seguir esta estructura:

# 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

El convertidor:

Analizará la estructura markdown
Extraerá los metadatos y requisitos de la tarea
Generará indicaciones detalladas para cada tarea de validación
Incluirá la configuración adecuada del directorio de trabajo
Añadirá resúmenes de verificación y finalización

Ejemplo de Uso

Crear un archivo de tarea (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

Convertir a tareas MCP:

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

El convertidor muestra el progreso en tiempo 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!

El convertidor transforma instrucciones genéricas en comandos exactos:
- "Cambiar directorio al proyecto y activar .venv" se convierte en:
```
cd /home/user/project && source .venv/bin/activate
```
- Todas las rutas se resuelven a rutas absolutas
- Todos los comandos son totalmente ejecutables sin ambigüedad
Ejecutar las tareas convertidas: Las tareas devueltas contienen comandos exactos y ejecutables y pueden ejecutarse secuencialmente usando la herramienta claude_code.

Ejemplo Completo: De Markdown a Ejecución

Paso 1: El usuario crea un archivo de tareas 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

Paso 2: El usuario solicita a Claude:

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

Paso 3: MCP convierte y valida:

Si el formato es correcto: Devuelve JSON ejecutable
Si el formato es incorrecto: Devuelve un error con orientación

Paso 4: Resultado (si tiene éxito):

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

Paso 5: Claude puede ejecutar cada tarea secuencialmente

Validación de Formato y Manejo de Errores

El convertidor de tareas aplica una estructura markdown específica para garantizar una conversión de tareas consistente y confiable. Si su archivo markdown tiene un formato incorrecto, el convertidor proporciona mensajes de error útiles:

Ejemplo de respuesta de error:

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

La validación asegura:

Las secciones requeridas están presentes (Título, Objetivo, Requisitos)
Las tareas usan el formato de casilla de verificación adecuado
Cada tarea tiene pasos indentados
Los requisitos usan formato de casilla de verificación para consistencia

🦚 Patrones de Orquestación de Tareas

Este servidor MCP admite potentes capacidades de orquestación de tareas para manejar flujos de trabajo complejos de manera eficiente.

Patrón Boomerang (Claude Desktop ⟷ Claude Code)

El patrón Boomerang permite a Claude Desktop orquestar tareas y delegarlas a Claude Code. Esto le permite:

Dividir flujos de trabajo complejos en subtareas más pequeñas y manejables
Pasar contexto de tareas principales a subtareas
Obtener resultados de subtareas de vuelta a la tarea principal
Elegir entre resultados detallados o resumidos
Rastrear y gestionar el progreso a través de listas de tareas estructuradas

Visualización del Patrón Boomerang

Aquí hay un diagrama simple que muestra cómo Claude divide una tarea de receta en pasos y los delega a 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

En este ejemplo:

El usuario pide a Claude hacer una receta de pastel de chocolate
Claude (Principal) divide esto en tareas separadas
Claude delega la tarea "Encontrar receta" a Claude Code con un ID de tarea principal
Claude Code devuelve la información de la receta a Claude
Claude delega la tarea "Convertir medidas" a Claude Code
Claude Code devuelve las medidas convertidas
Claude combina todos los resultados y presenta la solución completa al usuario

Ejemplos de Tareas Simples:

Tarea 1 - Encontrar Receta:

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

Tarea 2 - Convertir 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"
  }
}

Cómo Funciona

Crear una Subtarea:
- Genere un ID de tarea único en su tarea principal
- Envíe una solicitud a la herramienta claude_code con:
  - Su indicación específica
  - El ID de la tarea principal
  - Una descripción de la tarea
  - El modo de retorno deseado ('summary' o 'full')
Recibir Resultados:
- El resultado de la subtarea incluirá un marcador especial: 
- Este marcador contiene JSON con los metadatos de la tarea
- La tarea principal puede analizar esto para identificar subtareas completadas
Ejemplo de Flujo de Trabajo con 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...

Este enfoque es particularmente útil para tareas complejas que requieren análisis profundo o múltiples pasos.

Ejemplo Integral de Gestión de Lista de Tareas

Aquí hay un ejemplo detallado de uso de Claude con el MCP de Claude Code para gestionar y ejecutar una lista de tareas estructurada:

1. Configuración de la Estructura de la Lista de Tareas

Primero, cree un archivo de lista de tareas (por ejemplo, tasks.md) con la siguiente estructura:

# 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. Ejecución de la Lista de Tareas

Claude ahora puede trabajar sistemáticamente a través de las tareas usando 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. Continuación con Tareas Posteriores

Después de obtener confirmación, Claude continuaría con la siguiente subtarea:

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?

Este enfoque estructurado permite a Claude trabajar sistemáticamente a través de listas de tareas complejas mientras mantiene documentación clara del progreso, suposiciones y archivos relevantes durante todo el proceso.

🎭 Patrón de Auto-Orquestación (Claude Code como Orquestador)

Mientras que Claude Desktop se usa a menudo como el agente principal, puede usar Claude Code en sí mismo como orquestador y ejecutor. Este enfoque crea un sistema autocontenido donde Claude Code gestiona su propia orquestación de tareas, sin requerir 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

Pasos de Implementación

Cree un script de entrada que inicialice su estructura de tareas y lance Claude Code como orquestador
Diseñe una estructura de datos de tareas (típicamente en formato JSON) que rastree el estado y las dependencias de las tareas
Cree scripts de ejecución de tareas para procesar tareas individuales y actualizar el estado de las tareas

Beneficios Clave de la Auto-Orquestación

Autocontenido: No se requiere un orquestador externo (como Claude Desktop)
Estado persistente: Toda la información de las tareas se almacena en archivos JSON
Recuperación de errores: Puede reanudar desde la última tarea exitosa si se interrumpe
Gestión simplificada de dependencias: Un solo sistema gestiona todas las interacciones de Claude Code
Automatización de scripts de shell: Fácilmente integrable en pipelines de CI/CD o flujos de trabajo automatizados

Para una guía de implementación detallada con scripts de ejemplo y estructuras de tareas, consulte Auto-Orquestación con Claude Code.

👓 Integración de Modos Roo

Este servidor MCP admite integración con modos especializados a través de un archivo de configuración .roomodes. Cuando está habilitado, puede especificar qué modo usar para cada tarea, permitiendo un comportamiento especializado.

Cómo Usar los Modos Roo

Habilitar el Soporte de Modo Roo:
- Establezca la variable de entorno MCP_USE_ROOMODES=true en su configuración MCP
- Cree un archivo .roomodes en el directorio raíz de su servidor MCP
- Opcionalmente, habilite la recarga en caliente con MCP_WATCH_ROOMODES=true para recargar automáticamente la configuración cuando el archivo cambie
Configurar Sus Modos:
- El archivo .roomodes debe contener un objeto JSON con un array customModes
- Cada modo debe tener un slug, name, roleDefinition, y opcionalmente un apiConfiguration con un modelId
Usar un Modo:
- Al hacer solicitudes a la herramienta claude_code, incluya un parámetro mode con el slug del modo deseado
- El servidor MCP aplicará automáticamente la definición de rol y la configuración del modelo

Ejemplo de Archivo .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."
    }
  ]
}

Ejemplo de Configuración de Entorno:

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

Haciendo Solicitudes con 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"
  }
}

Características Clave de los Modos Roo:

Comportamientos Especializados: Diferentes modos pueden tener diferentes indicaciones de sistema y configuraciones de modelo
Recarga en Caliente: Cuando MCP_WATCH_ROOMODES=true, el servidor recarga automáticamente la configuración cuando el archivo .roomodes cambia
Rendimiento: El servidor almacena en caché la configuración de roomodes para un mejor rendimiento
Respaldo: Si un modo no se encuentra o los roomodes están deshabilitados, el servidor continúa con el comportamiento predeterminado

🛠️ Características Mejoradas de Confiabilidad

Este servidor incluye varias mejoras para aumentar la confiabilidad y el rendimiento:

1. Latido y Prevención de Tiempos de Espera

Para prevenir tiempos de espera del lado del cliente durante operaciones de larga duración:

Se añadió un mecanismo de latido configurable que envía actualizaciones de progreso cada 15 segundos
Se implementó el seguimiento y reporte del tiempo de ejecución
Se añadieron parámetros de tiempo de espera configurables a través de variables de entorno

2. Manejo Robusto de Errores con Reintentos

Se añadió lógica de reintento inteligente para errores transitorios:

Se implementó reintento automático con parámetros configurables
Se añadió clasificación de errores para identificar problemas reintentables
Se creó reporte y seguimiento detallado de errores

3. Sistema de Seguimiento de Solicitudes

Se implementó una gestión integral del ciclo de vida de las solicitudes:

Se añadieron IDs únicos para cada solicitud
Se creó seguimiento para solicitudes en curso
Se aseguró una limpieza adecuada al completar o fallar

4. Apagado Elegante

Se añadió manejo adecuado de terminación de procesos:

Se implementaron manejadores de señales para SIGINT y SIGTERM
Se añadió seguimiento para solicitudes en curso
Se creó lógica de espera para un apagado limpio
Se aseguró una limpieza adecuada al salir

5. Caché de Configuración y Recarga en Caliente

Se añadió optimización de rendimiento para la configuración:

Se implementó caché para el archivo roomodes
Se añadió invalidación automática basada en cambios de archivos
Se creó un mecanismo configurable de vigilancia de archivos

⚙️ Opciones de Configuración

El comportamiento del servidor se puede personalizar usando estas variables de entorno:

Variable	Descripción	Predeterminado
`CLAUDE_CLI_PATH`	Ruta absoluta al ejecutable de la CLI de Claude	Auto-detección
`MCP_CLAUDE_DEBUG`	Habilitar registro de depuración verboso	`false`
`MCP_HEARTBEAT_INTERVAL_MS`	Intervalo entre informes de progreso	15000 (15s)
`MCP_EXECUTION_TIMEOUT_MS`	Tiempo de espera para la ejecución de la CLI	1800000 (30m)
`MCP_MAX_RETRIES`	Máximo de intentos de reintento para errores transitorios	3
`MCP_RETRY_DELAY_MS`	Retraso entre intentos de reintento	1000 (1s)
`MCP_USE_ROOMODES`	Habilitar integración de modos Roo	`false`
`MCP_WATCH_ROOMODES`	Recargar automáticamente .roomodes en cambios	`false`
Variables de Red Mesh
`MCP_MESH_MAX_AGENTS`	Máximo de agentes concurrentes	5
`MCP_MESH_TIMEOUT`	Tiempo de espera de ejecución del agente	300000 (5m)
`MCP_MESH_VERBOSE`	Habilitar registro detallado del agente	`false`

Estas se pueden establecer en su entorno de shell o dentro del bloque env de su configuración del servidor mcp.json.

📸 Ejemplos Visuales

Aquí hay algunos ejemplos visuales del servidor en acción:

Corrigiendo la Configuración de ESLint

Aquí hay un ejemplo de uso de la herramienta MCP de Claude Code para corregir interactivamente una configuración de ESLint eliminando archivos de configuración antiguos y creando uno nuevo:

Ejemplo de Listado de Archivos

Aquí hay un ejemplo de la herramienta de Claude Code listando archivos en un directorio:

Operaciones Complejas de Múltiples Pasos

Este ejemplo ilustra a claude_code manejando una tarea más compleja de múltiples pasos, como preparar un lanzamiento creando una rama, actualizando múltiples archivos (package.json, CHANGELOG.md), confirmando cambios e iniciando una solicitud de extracción, todo dentro de una sola operación coherente.

Corrección del Flujo de Trabajo de GitHub Actions

🌐 Ejemplos de Uso de la Red Mesh

Análisis Básico de Problemas

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

Resolución de Problemas de Extremo a Extremo

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

Estrategias de Coordinación

1. Análisis Primero (Predeterminado) Ideal para problemas bien definidos que requieren un enfoque sistemático.

2. Exploración en Paralelo Ideal para tareas de investigación que necesitan múltiples perspectivas:

approach: parallel_exploration

3. Refinamiento Iterativo Ideal para refactorización compleja con bucles de retroalimentación:

approach: iterative_refinement

🎯 Casos de Uso Clave

Este servidor, a través de su herramienta unificada claude_code, desbloquea una amplia gama de capacidades potentes al darle a tu IA acceso directo a la CLI de Claude Code. Aquí hay algunos ejemplos de lo que puedes lograr:

Generación, Análisis y Refactorización de Código:
- "Generate a Python script to parse CSV data and output JSON."
- "Analyze my_script.py for potential bugs and suggest improvements."
Operaciones del Sistema de Archivos (Crear, Leer, Editar, Gestionar):
- Crear Archivos: "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"
- Editar Archivos: "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'."
- Mover/Copiar/Eliminar: "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'."
Control de Versiones (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."
Ejecutar 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."
Búsqueda Web y Resumen:
- "Search the web for 'benefits of server-side rendering' and provide a concise summary."
Flujos de Trabajo Complejos de Múltiples Pasos:
- Automatiza incrementos de versión, actualiza registros de cambios y etiqueta versiones: "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."
Reparar Archivos con Errores de Sintaxis:
- "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."
Interactuar con GitHub (p. ej., Crear una Solicitud de Extracción):
- "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.'"
Interactuar con GitHub (p. ej., Verificar el Estado de CI de 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: Recuerda proporcionar el contexto del Directorio de Trabajo Actual (CWD) en tus indicaciones para operaciones del sistema de archivos o git (p. ej., "Your work folder is /path/to/project\n\n...your command...").

🧪 Pruebas y Desarrollo

Suite de Pruebas Integral

MeshSeeks incluye un marco de pruebas completo con:

Pruebas Unitarias - Prueban la funcionalidad principal del coordinador:

npm run test:unit

Pruebas de Integración - Prueban las herramientas del servidor MCP:

npm run test:integration

Pruebas de Manejo de Errores - Prueban escenarios de fallo:

npm run test:errors

Pruebas de Rendimiento - Prueban escalabilidad y concurrencia:

npm run test:performance

Ejecutar Todas las Pruebas - Suite de pruebas completa:

npm run test:all

Demostración del Panel de Estado

Ve el panel de estado en tiempo real en acción:

npm run demo:status

Scripts de Desarrollo

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

🔧 Solución de Problemas

"Comando no encontrado" (claude-code-mcp): Si está instalado globalmente, asegúrate de que el directorio bin global de npm esté en el PATH de tu sistema. Si usas npx, asegúrate de que npx funcione correctamente.
"Comando no encontrado" (claude o ~/.claude/local/claude): Asegúrate de que la CLI de Claude esté instalada correctamente. Ejecuta claude/doctor o consulta su documentación.
Problemas de Permisos: Asegúrate de haber ejecutado el paso de "Configuración Importante por Primera Vez".
Errores JSON del Servidor: Si MCP_CLAUDE_DEBUG es true, los mensajes de error o registros podrían interferir con el análisis JSON de MCP. Configúralo en false para operación normal.
Errores ESM/Importación: Asegúrate de usar Node.js v20 o posterior.
Tiempos de Espera del Cliente: Para operaciones de larga duración, el servidor envía mensajes de latido cada 15 segundos para evitar tiempos de espera del cliente. Si aún experimentas tiempos de espera, puedes ajustar el intervalo de latido usando la variable de entorno MCP_HEARTBEAT_INTERVAL_MS.
Errores de Red/Servidor: El servidor ahora incluye lógica de reintento automático para errores transitorios. Si aún experimentas problemas, intenta aumentar los valores de MCP_MAX_RETRIES y MCP_RETRY_DELAY_MS.
Advertencia de Respaldo de la CLI de Claude: Si ves una advertencia sobre que la CLI de Claude no se encontró en ~/.claude/local/claude, esto es normal. El servidor está usando como respaldo el comando claude de tu PATH. Puedes configurar la variable de entorno CLAUDE_CLI_PATH para especificar la ruta exacta a tu ejecutable de la CLI de Claude si es necesario.

👨‍💻 Para Desarrolladores: Configuración Local y Contribución

Si deseas desarrollar o contribuir a este servidor, o ejecutarlo desde un repositorio clonado para pruebas, consulta nuestra Guía de Instalación Local y Configuración de Desarrollo.

📚 Documentación Adicional

Guía de Arquitectura de Red Mesh - Documentación detallada sobre la red mesh de agentes
Guía del Panel de Estado - Visualización y monitoreo en tiempo real
Guía de Inicio Rápido - Ponte en marcha rápidamente
Configuración de Desarrollo Local - Para contribuyentes y desarrolladores
Documentación de la Suite de Pruebas - Guía integral de pruebas

💪 Contribuciones

¡Las contribuciones son bienvenidas! Este proyecto extiende el servidor MCP mejorado de Graham con capacidades de red mesh.

Envía problemas y solicitudes de extracción al repositorio de GitHub.

⚖️ Licencia

MIT

💬 Comentarios y Soporte

Si encuentras algún problema o tienes preguntas sobre el uso del servidor MCP de Claude Code, por favor:

Consulta la sección de Solución de Problemas anterior
Envía un problema en el repositorio de GitHub
Únete a la discusión en la sección de discusiones del repositorio

¡Apreciamos tus comentarios y contribuciones para mejorar esta herramienta!

MeshSeeks

Documentación

MeshSeeks

🚀 Características Principales

Red de Malla de Agentes

Herramientas MCP Mejoradas

🆕 Panel de Estado en Tiempo Real

⚡ Comenzando en 60 Segundos

🔍 Descripción General

✨ Beneficios

📊 Puntos de Referencia de Rendimiento - ¡3.64x Más Rápido!

🏆 Últimos Resultados de Referencia (Datos de Pruebas Reales)

📈 Rendimiento por Complejidad

🎯 Por Qué MeshSeeks es Más Rápido

🚀 Ejecuta Tu Propio Punto de Referencia

🚀 Inicio Rápido (5 Minutos)

Requisitos Previos

Instalar MeshSeeks

Configurar Tu Cliente

Verificar la Instalación

🎯 Ideas para las Primeras Tareas

📚 Guía de Instalación Detallada

🔑 Configuración Importante por Primera Vez: Aceptar Permisos

🔗 Conectando a Tu Cliente MCP

Ejemplo de Archivo de Configuración MCP

Ubicaciones de Configuración MCP

Cursor

Windsurf

🛠️ Herramientas Proporcionadas

claude_code 💬

health 🩺

convert_task_markdown 📋

Escenarios de Uso de Ejemplo

1. Operación Básica de Código

2. Orquestación de Tareas (Patrón Boomerang)

3. Solicitud de Modo Especializado

🔄 Convertidor de Tareas

Flujo de Trabajo Completo

Pasos del Flujo de Trabajo

Características Clave

Convertir Tareas de Markdown a Comandos MCP

Formato de Archivo de Tareas Markdown

Ejemplo de Uso

Ejemplo Completo: De Markdown a Ejecución

Validación de Formato y Manejo de Errores

🦚 Patrones de Orquestación de Tareas

Patrón Boomerang (Claude Desktop ⟷ Claude Code)

Visualización del Patrón Boomerang

Cómo Funciona

Ejemplo Integral de Gestión de Lista de Tareas

1. Configuración de la Estructura de la Lista de Tareas

2. Ejecución de la Lista de Tareas

3. Continuación con Tareas Posteriores

🎭 Patrón de Auto-Orquestación (Claude Code como Orquestador)

Pasos de Implementación

Beneficios Clave de la Auto-Orquestación

👓 Integración de Modos Roo

Cómo Usar los Modos Roo

Características Clave de los Modos Roo:

🛠️ Características Mejoradas de Confiabilidad

1. Latido y Prevención de Tiempos de Espera

2. Manejo Robusto de Errores con Reintentos

3. Sistema de Seguimiento de Solicitudes

4. Apagado Elegante

5. Caché de Configuración y Recarga en Caliente

⚙️ Opciones de Configuración

📸 Ejemplos Visuales

Corrigiendo la Configuración de ESLint

Ejemplo de Listado de Archivos

Operaciones Complejas de Múltiples Pasos

Corrección del Flujo de Trabajo de GitHub Actions

🌐 Ejemplos de Uso de la Red Mesh

Análisis Básico de Problemas

Resolución de Problemas de Extremo a Extremo

Estrategias de Coordinación

🎯 Casos de Uso Clave

🧪 Pruebas y Desarrollo

Suite de Pruebas Integral

Demostración del Panel de Estado

Scripts de Desarrollo

`claude_code` 💬

`health` 🩺

`convert_task_markdown` 📋