fix: Clarify MinIO access credentials in UI
- Update CreateUserDialog labels to show 'Username (Access Key)' and 'Password (Secret Key)' - Add helper text explaining these are MinIO credentials - Enhanced success display to show credentials with proper MinIO terminology - Add MinIO CLI connection examples in credential displays - Fix confusion about where to get access key and secret key This addresses user feedback about unclear credential terminology and aligns with MinIO documentation where username = Access Key and password = Secret Key. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,906 @@
|
||||
# Claude Code Configuration for Claude Flow
|
||||
|
||||
## 🚨 CRITICAL: PARALLEL EXECUTION AFTER SWARM INIT
|
||||
|
||||
**MANDATORY RULE**: Once swarm is initialized with memory, ALL subsequent operations MUST be parallel:
|
||||
|
||||
1. **TodoWrite** → Always batch 5-10+ todos in ONE call
|
||||
2. **Task spawning** → Spawn ALL agents in ONE message
|
||||
3. **File operations** → Batch ALL reads/writes together
|
||||
4. **NEVER** operate sequentially after swarm init
|
||||
|
||||
## 🚨 CRITICAL: CONCURRENT EXECUTION FOR ALL ACTIONS
|
||||
|
||||
**ABSOLUTE RULE**: ALL operations MUST be concurrent/parallel in a single message:
|
||||
|
||||
### 🔴 MANDATORY CONCURRENT PATTERNS:
|
||||
|
||||
1. **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
|
||||
2. **Task tool**: ALWAYS spawn ALL agents in ONE message with full instructions
|
||||
3. **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message
|
||||
4. **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
|
||||
5. **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message
|
||||
|
||||
### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
|
||||
|
||||
**Examples of CORRECT concurrent execution:**
|
||||
|
||||
```javascript
|
||||
// ✅ CORRECT: Everything in ONE message
|
||||
[Single Message]:
|
||||
- TodoWrite { todos: [10+ todos with all statuses/priorities] }
|
||||
- Task("Agent 1 with full instructions and hooks")
|
||||
- Task("Agent 2 with full instructions and hooks")
|
||||
- Task("Agent 3 with full instructions and hooks")
|
||||
- Read("file1.js")
|
||||
- Read("file2.js")
|
||||
- Read("file3.js")
|
||||
- Write("output1.js", content)
|
||||
- Write("output2.js", content)
|
||||
- Bash("npm install")
|
||||
- Bash("npm test")
|
||||
- Bash("npm run build")
|
||||
```
|
||||
|
||||
**Examples of WRONG sequential execution:**
|
||||
|
||||
```javascript
|
||||
// ❌ WRONG: Multiple messages (NEVER DO THIS)
|
||||
Message 1: TodoWrite { todos: [single todo] }
|
||||
Message 2: Task("Agent 1")
|
||||
Message 3: Task("Agent 2")
|
||||
Message 4: Read("file1.js")
|
||||
Message 5: Write("output1.js")
|
||||
Message 6: Bash("npm install")
|
||||
// This is 6x slower and breaks coordination!
|
||||
```
|
||||
|
||||
### 🎯 CONCURRENT EXECUTION CHECKLIST:
|
||||
|
||||
Before sending ANY message, ask yourself:
|
||||
|
||||
- ✅ Are ALL related TodoWrite operations batched together?
|
||||
- ✅ Are ALL Task spawning operations in ONE message?
|
||||
- ✅ Are ALL file operations (Read/Write/Edit) batched together?
|
||||
- ✅ Are ALL bash commands grouped in ONE message?
|
||||
- ✅ Are ALL memory operations concurrent?
|
||||
|
||||
If ANY answer is "No", you MUST combine operations into a single message!
|
||||
|
||||
## 🚀 CRITICAL: Claude Code Does ALL Real Work
|
||||
|
||||
### 🎯 CLAUDE CODE IS THE ONLY EXECUTOR
|
||||
|
||||
**ABSOLUTE RULE**: Claude Code performs ALL actual work:
|
||||
|
||||
### ✅ Claude Code ALWAYS Handles:
|
||||
|
||||
- 🔧 **ALL file operations** (Read, Write, Edit, MultiEdit, Glob, Grep)
|
||||
- 💻 **ALL code generation** and programming tasks
|
||||
- 🖥️ **ALL bash commands** and system operations
|
||||
- 🏗️ **ALL actual implementation** work
|
||||
- 🔍 **ALL project navigation** and code analysis
|
||||
- 📝 **ALL TodoWrite** and task management
|
||||
- 🔄 **ALL git operations** (commit, push, merge)
|
||||
- 📦 **ALL package management** (npm, pip, etc.)
|
||||
- 🧪 **ALL testing** and validation
|
||||
- 🔧 **ALL debugging** and troubleshooting
|
||||
|
||||
### 🧠 Claude Flow MCP Tools ONLY Handle:
|
||||
|
||||
- 🎯 **Coordination only** - Planning Claude Code's actions
|
||||
- 💾 **Memory management** - Storing decisions and context
|
||||
- 🤖 **Neural features** - Learning from Claude Code's work
|
||||
- 📊 **Performance tracking** - Monitoring Claude Code's efficiency
|
||||
- 🐝 **Swarm orchestration** - Coordinating multiple Claude Code instances
|
||||
- 🔗 **GitHub integration** - Advanced repository coordination
|
||||
|
||||
### 🚨 CRITICAL SEPARATION OF CONCERNS:
|
||||
|
||||
**❌ MCP Tools NEVER:**
|
||||
|
||||
- Write files or create content
|
||||
- Execute bash commands
|
||||
- Generate code
|
||||
- Perform file operations
|
||||
- Handle TodoWrite operations
|
||||
- Execute system commands
|
||||
- Do actual implementation work
|
||||
|
||||
**✅ MCP Tools ONLY:**
|
||||
|
||||
- Coordinate and plan
|
||||
- Store memory and context
|
||||
- Track performance
|
||||
- Orchestrate workflows
|
||||
- Provide intelligence insights
|
||||
|
||||
### ⚠️ Key Principle:
|
||||
|
||||
**MCP tools coordinate, Claude Code executes.** Think of MCP tools as the "brain" that plans and coordinates, while Claude Code is the "hands" that do all the actual work.
|
||||
|
||||
### 🔄 WORKFLOW EXECUTION PATTERN:
|
||||
|
||||
**✅ CORRECT Workflow:**
|
||||
|
||||
1. **MCP**: `mcp__claude-flow__swarm_init` (coordination setup)
|
||||
2. **MCP**: `mcp__claude-flow__agent_spawn` (planning agents)
|
||||
3. **MCP**: `mcp__claude-flow__task_orchestrate` (task coordination)
|
||||
4. **Claude Code**: `Task` tool to spawn agents with coordination instructions
|
||||
5. **Claude Code**: `TodoWrite` with ALL todos batched (5-10+ in ONE call)
|
||||
6. **Claude Code**: `Read`, `Write`, `Edit`, `Bash` (actual work)
|
||||
7. **MCP**: `mcp__claude-flow__memory_usage` (store results)
|
||||
|
||||
**❌ WRONG Workflow:**
|
||||
|
||||
1. **MCP**: `mcp__claude-flow__terminal_execute` (DON'T DO THIS)
|
||||
2. **MCP**: File creation via MCP (DON'T DO THIS)
|
||||
3. **MCP**: Code generation via MCP (DON'T DO THIS)
|
||||
4. **Claude Code**: Sequential Task calls (DON'T DO THIS)
|
||||
5. **Claude Code**: Individual TodoWrite calls (DON'T DO THIS)
|
||||
|
||||
### 🚨 REMEMBER:
|
||||
|
||||
- **MCP tools** = Coordination, planning, memory, intelligence
|
||||
- **Claude Code** = All actual execution, coding, file operations
|
||||
|
||||
## 🚀 CRITICAL: Parallel Execution & Batch Operations
|
||||
|
||||
### 🚨 MANDATORY RULE #1: BATCH EVERYTHING
|
||||
|
||||
**When using swarms, you MUST use BatchTool for ALL operations:**
|
||||
|
||||
1. **NEVER** send multiple messages for related operations
|
||||
2. **ALWAYS** combine multiple tool calls in ONE message
|
||||
3. **PARALLEL** execution is MANDATORY, not optional
|
||||
|
||||
### ⚡ THE GOLDEN RULE OF SWARMS
|
||||
|
||||
```
|
||||
If you need to do X operations, they should be in 1 message, not X messages
|
||||
```
|
||||
|
||||
### 🚨 MANDATORY TODO AND TASK BATCHING
|
||||
|
||||
**CRITICAL RULE FOR TODOS AND TASKS:**
|
||||
|
||||
1. **TodoWrite** MUST ALWAYS include ALL todos in ONE call (5-10+ todos)
|
||||
2. **Task** tool calls MUST be batched - spawn multiple agents in ONE message
|
||||
3. **NEVER** update todos one by one - this breaks parallel coordination
|
||||
4. **NEVER** spawn agents sequentially - ALL agents spawn together
|
||||
|
||||
### 📦 BATCH TOOL EXAMPLES
|
||||
|
||||
**✅ CORRECT - Everything in ONE Message:**
|
||||
|
||||
```javascript
|
||||
[Single Message with BatchTool]:
|
||||
// MCP coordination setup
|
||||
mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 6 }
|
||||
mcp__claude-flow__agent_spawn { type: "researcher" }
|
||||
mcp__claude-flow__agent_spawn { type: "coder" }
|
||||
mcp__claude-flow__agent_spawn { type: "analyst" }
|
||||
mcp__claude-flow__agent_spawn { type: "tester" }
|
||||
mcp__claude-flow__agent_spawn { type: "coordinator" }
|
||||
|
||||
// Claude Code execution - ALL in parallel
|
||||
Task("You are researcher agent. MUST coordinate via hooks...")
|
||||
Task("You are coder agent. MUST coordinate via hooks...")
|
||||
Task("You are analyst agent. MUST coordinate via hooks...")
|
||||
Task("You are tester agent. MUST coordinate via hooks...")
|
||||
TodoWrite { todos: [5-10 todos with all priorities and statuses] }
|
||||
|
||||
// File operations in parallel
|
||||
Bash "mkdir -p app/{src,tests,docs}"
|
||||
Write "app/package.json"
|
||||
Write "app/README.md"
|
||||
Write "app/src/index.js"
|
||||
```
|
||||
|
||||
**❌ WRONG - Multiple Messages (NEVER DO THIS):**
|
||||
|
||||
```javascript
|
||||
Message 1: mcp__claude-flow__swarm_init
|
||||
Message 2: Task("researcher agent")
|
||||
Message 3: Task("coder agent")
|
||||
Message 4: TodoWrite({ todo: "single todo" })
|
||||
Message 5: Bash "mkdir src"
|
||||
Message 6: Write "package.json"
|
||||
// This is 6x slower and breaks parallel coordination!
|
||||
```
|
||||
|
||||
### 🎯 BATCH OPERATIONS BY TYPE
|
||||
|
||||
**Todo and Task Operations (Single Message):**
|
||||
|
||||
- **TodoWrite** → ALWAYS include 5-10+ todos in ONE call
|
||||
- **Task agents** → Spawn ALL agents with full instructions in ONE message
|
||||
- **Agent coordination** → ALL Task calls must include coordination hooks
|
||||
- **Status updates** → Update ALL todo statuses together
|
||||
- **NEVER** split todos or Task calls across messages!
|
||||
|
||||
**File Operations (Single Message):**
|
||||
|
||||
- Read 10 files? → One message with 10 Read calls
|
||||
- Write 5 files? → One message with 5 Write calls
|
||||
- Edit 1 file many times? → One MultiEdit call
|
||||
|
||||
**Swarm Operations (Single Message):**
|
||||
|
||||
- Need 8 agents? → One message with swarm_init + 8 agent_spawn calls
|
||||
- Multiple memories? → One message with all memory_usage calls
|
||||
- Task + monitoring? → One message with task_orchestrate + swarm_monitor
|
||||
|
||||
**Command Operations (Single Message):**
|
||||
|
||||
- Multiple directories? → One message with all mkdir commands
|
||||
- Install + test + lint? → One message with all npm commands
|
||||
- Git operations? → One message with all git commands
|
||||
|
||||
## 🚀 Quick Setup (Stdio MCP - Recommended)
|
||||
|
||||
### 1. Add MCP Server (Stdio - No Port Needed)
|
||||
|
||||
```bash
|
||||
# Add Claude Flow MCP server to Claude Code using stdio
|
||||
claude mcp add claude-flow npx claude-flow@alpha mcp start
|
||||
```
|
||||
|
||||
### 2. Use MCP Tools for Coordination in Claude Code
|
||||
|
||||
Once configured, Claude Flow MCP tools enhance Claude Code's coordination:
|
||||
|
||||
**Initialize a swarm:**
|
||||
|
||||
- Use the `mcp__claude-flow__swarm_init` tool to set up coordination topology
|
||||
- Choose: mesh, hierarchical, ring, or star
|
||||
- This creates a coordination framework for Claude Code's work
|
||||
|
||||
**Spawn agents:**
|
||||
|
||||
- Use `mcp__claude-flow__agent_spawn` tool to create specialized coordinators
|
||||
- Agent types represent different thinking patterns, not actual coders
|
||||
- They help Claude Code approach problems from different angles
|
||||
|
||||
**Orchestrate tasks:**
|
||||
|
||||
- Use `mcp__claude-flow__task_orchestrate` tool to coordinate complex workflows
|
||||
- This breaks down tasks for Claude Code to execute systematically
|
||||
- The agents don't write code - they coordinate Claude Code's actions
|
||||
|
||||
## Available MCP Tools for Coordination
|
||||
|
||||
### Coordination Tools:
|
||||
|
||||
- `mcp__claude-flow__swarm_init` - Set up coordination topology for Claude Code
|
||||
- `mcp__claude-flow__agent_spawn` - Create cognitive patterns to guide Claude Code
|
||||
- `mcp__claude-flow__task_orchestrate` - Break down and coordinate complex tasks
|
||||
|
||||
### Monitoring Tools:
|
||||
|
||||
- `mcp__claude-flow__swarm_status` - Monitor coordination effectiveness
|
||||
- `mcp__claude-flow__agent_list` - View active cognitive patterns
|
||||
- `mcp__claude-flow__agent_metrics` - Track coordination performance
|
||||
- `mcp__claude-flow__task_status` - Check workflow progress
|
||||
- `mcp__claude-flow__task_results` - Review coordination outcomes
|
||||
|
||||
### Memory & Neural Tools:
|
||||
|
||||
- `mcp__claude-flow__memory_usage` - Persistent memory across sessions
|
||||
- `mcp__claude-flow__neural_status` - Neural pattern effectiveness
|
||||
- `mcp__claude-flow__neural_train` - Improve coordination patterns
|
||||
- `mcp__claude-flow__neural_patterns` - Analyze thinking approaches
|
||||
|
||||
### GitHub Integration Tools (NEW!):
|
||||
|
||||
- `mcp__claude-flow__github_swarm` - Create specialized GitHub management swarms
|
||||
- `mcp__claude-flow__repo_analyze` - Deep repository analysis with AI
|
||||
- `mcp__claude-flow__pr_enhance` - AI-powered pull request improvements
|
||||
- `mcp__claude-flow__issue_triage` - Intelligent issue classification
|
||||
- `mcp__claude-flow__code_review` - Automated code review with swarms
|
||||
|
||||
### System Tools:
|
||||
|
||||
- `mcp__claude-flow__benchmark_run` - Measure coordination efficiency
|
||||
- `mcp__claude-flow__features_detect` - Available capabilities
|
||||
- `mcp__claude-flow__swarm_monitor` - Real-time coordination tracking
|
||||
|
||||
## Workflow Examples (Coordination-Focused)
|
||||
|
||||
### Research Coordination Example
|
||||
|
||||
**Context:** Claude Code needs to research a complex topic systematically
|
||||
|
||||
**Step 1:** Set up research coordination
|
||||
|
||||
- Tool: `mcp__claude-flow__swarm_init`
|
||||
- Parameters: `{"topology": "mesh", "maxAgents": 5, "strategy": "balanced"}`
|
||||
- Result: Creates a mesh topology for comprehensive exploration
|
||||
|
||||
**Step 2:** Define research perspectives
|
||||
|
||||
- Tool: `mcp__claude-flow__agent_spawn`
|
||||
- Parameters: `{"type": "researcher", "name": "Literature Review"}`
|
||||
- Tool: `mcp__claude-flow__agent_spawn`
|
||||
- Parameters: `{"type": "analyst", "name": "Data Analysis"}`
|
||||
- Result: Different cognitive patterns for Claude Code to use
|
||||
|
||||
**Step 3:** Coordinate research execution
|
||||
|
||||
- Tool: `mcp__claude-flow__task_orchestrate`
|
||||
- Parameters: `{"task": "Research neural architecture search papers", "strategy": "adaptive"}`
|
||||
- Result: Claude Code systematically searches, reads, and analyzes papers
|
||||
|
||||
**What Actually Happens:**
|
||||
|
||||
1. The swarm sets up a coordination framework
|
||||
2. Each agent MUST use Claude Flow hooks for coordination:
|
||||
- `npx claude-flow@alpha hooks pre-task` before starting
|
||||
- `npx claude-flow@alpha hooks post-edit` after each file operation
|
||||
- `npx claude-flow@alpha hooks notification` to share decisions
|
||||
3. Claude Code uses its native Read, WebSearch, and Task tools
|
||||
4. The swarm coordinates through shared memory and hooks
|
||||
5. Results are synthesized by Claude Code with full coordination history
|
||||
|
||||
### Development Coordination Example
|
||||
|
||||
**Context:** Claude Code needs to build a complex system with multiple components
|
||||
|
||||
**Step 1:** Set up development coordination
|
||||
|
||||
- Tool: `mcp__claude-flow__swarm_init`
|
||||
- Parameters: `{"topology": "hierarchical", "maxAgents": 8, "strategy": "specialized"}`
|
||||
- Result: Hierarchical structure for organized development
|
||||
|
||||
**Step 2:** Define development perspectives
|
||||
|
||||
- Tool: `mcp__claude-flow__agent_spawn`
|
||||
- Parameters: `{"type": "architect", "name": "System Design"}`
|
||||
- Result: Architectural thinking pattern for Claude Code
|
||||
|
||||
**Step 3:** Coordinate implementation
|
||||
|
||||
- Tool: `mcp__claude-flow__task_orchestrate`
|
||||
- Parameters: `{"task": "Implement user authentication with JWT", "strategy": "parallel"}`
|
||||
- Result: Claude Code implements features using its native tools
|
||||
|
||||
**What Actually Happens:**
|
||||
|
||||
1. The swarm creates a development coordination plan
|
||||
2. Each agent coordinates using mandatory hooks:
|
||||
- Pre-task hooks for context loading
|
||||
- Post-edit hooks for progress tracking
|
||||
- Memory storage for cross-agent coordination
|
||||
3. Claude Code uses Write, Edit, Bash tools for implementation
|
||||
4. Agents share progress through Claude Flow memory
|
||||
5. All code is written by Claude Code with full coordination
|
||||
|
||||
### GitHub Repository Management Example (NEW!)
|
||||
|
||||
**Context:** Claude Code needs to manage a complex GitHub repository
|
||||
|
||||
**Step 1:** Initialize GitHub swarm
|
||||
|
||||
- Tool: `mcp__claude-flow__github_swarm`
|
||||
- Parameters: `{"repository": "owner/repo", "agents": 5, "focus": "maintenance"}`
|
||||
- Result: Specialized swarm for repository management
|
||||
|
||||
**Step 2:** Analyze repository health
|
||||
|
||||
- Tool: `mcp__claude-flow__repo_analyze`
|
||||
- Parameters: `{"deep": true, "include": ["issues", "prs", "code"]}`
|
||||
- Result: Comprehensive repository analysis
|
||||
|
||||
**Step 3:** Enhance pull requests
|
||||
|
||||
- Tool: `mcp__claude-flow__pr_enhance`
|
||||
- Parameters: `{"pr_number": 123, "add_tests": true, "improve_docs": true}`
|
||||
- Result: AI-powered PR improvements
|
||||
|
||||
## Best Practices for Coordination
|
||||
|
||||
### ✅ DO:
|
||||
|
||||
- Use MCP tools to coordinate Claude Code's approach to complex tasks
|
||||
- Let the swarm break down problems into manageable pieces
|
||||
- Use memory tools to maintain context across sessions
|
||||
- Monitor coordination effectiveness with status tools
|
||||
- Train neural patterns for better coordination over time
|
||||
- Leverage GitHub tools for repository management
|
||||
|
||||
### ❌ DON'T:
|
||||
|
||||
- Expect agents to write code (Claude Code does all implementation)
|
||||
- Use MCP tools for file operations (use Claude Code's native tools)
|
||||
- Try to make agents execute bash commands (Claude Code handles this)
|
||||
- Confuse coordination with execution (MCP coordinates, Claude executes)
|
||||
|
||||
## Memory and Persistence
|
||||
|
||||
The swarm provides persistent memory that helps Claude Code:
|
||||
|
||||
- Remember project context across sessions
|
||||
- Track decisions and rationale
|
||||
- Maintain consistency in large projects
|
||||
- Learn from previous coordination patterns
|
||||
- Store GitHub workflow preferences
|
||||
|
||||
## Performance Benefits
|
||||
|
||||
When using Claude Flow coordination with Claude Code:
|
||||
|
||||
- **84.8% SWE-Bench solve rate** - Better problem-solving through coordination
|
||||
- **32.3% token reduction** - Efficient task breakdown reduces redundancy
|
||||
- **2.8-4.4x speed improvement** - Parallel coordination strategies
|
||||
- **27+ neural models** - Diverse cognitive approaches
|
||||
- **GitHub automation** - Streamlined repository management
|
||||
|
||||
## Claude Code Hooks Integration
|
||||
|
||||
Claude Flow includes powerful hooks that automate coordination:
|
||||
|
||||
### Pre-Operation Hooks
|
||||
|
||||
- **Auto-assign agents** before file edits based on file type
|
||||
- **Validate commands** before execution for safety
|
||||
- **Prepare resources** automatically for complex operations
|
||||
- **Optimize topology** based on task complexity analysis
|
||||
- **Cache searches** for improved performance
|
||||
- **GitHub context** loading for repository operations
|
||||
|
||||
### Post-Operation Hooks
|
||||
|
||||
- **Auto-format code** using language-specific formatters
|
||||
- **Train neural patterns** from successful operations
|
||||
- **Update memory** with operation context
|
||||
- **Analyze performance** and identify bottlenecks
|
||||
- **Track token usage** for efficiency metrics
|
||||
- **Sync GitHub** state for consistency
|
||||
|
||||
### Session Management
|
||||
|
||||
- **Generate summaries** at session end
|
||||
- **Persist state** across Claude Code sessions
|
||||
- **Track metrics** for continuous improvement
|
||||
- **Restore previous** session context automatically
|
||||
- **Export workflows** for reuse
|
||||
|
||||
### Advanced Features (v2.0.0!)
|
||||
|
||||
- **🚀 Automatic Topology Selection** - Optimal swarm structure for each task
|
||||
- **⚡ Parallel Execution** - 2.8-4.4x speed improvements
|
||||
- **🧠 Neural Training** - Continuous learning from operations
|
||||
- **📊 Bottleneck Analysis** - Real-time performance optimization
|
||||
- **🤖 Smart Auto-Spawning** - Zero manual agent management
|
||||
- **🛡️ Self-Healing Workflows** - Automatic error recovery
|
||||
- **💾 Cross-Session Memory** - Persistent learning & context
|
||||
- **🔗 GitHub Integration** - Repository-aware swarms
|
||||
|
||||
### Configuration
|
||||
|
||||
Hooks are pre-configured in `.claude/settings.json`. Key features:
|
||||
|
||||
- Automatic agent assignment for different file types
|
||||
- Code formatting on save
|
||||
- Neural pattern learning from edits
|
||||
- Session state persistence
|
||||
- Performance tracking and optimization
|
||||
- Intelligent caching and token reduction
|
||||
- GitHub workflow automation
|
||||
|
||||
See `.claude/commands/` for detailed documentation on all features.
|
||||
|
||||
## Integration Tips
|
||||
|
||||
1. **Start Simple**: Begin with basic swarm init and single agent
|
||||
2. **Scale Gradually**: Add more agents as task complexity increases
|
||||
3. **Use Memory**: Store important decisions and context
|
||||
4. **Monitor Progress**: Regular status checks ensure effective coordination
|
||||
5. **Train Patterns**: Let neural agents learn from successful coordinations
|
||||
6. **Enable Hooks**: Use the pre-configured hooks for automation
|
||||
7. **GitHub First**: Use GitHub tools for repository management
|
||||
|
||||
## 🧠 SWARM ORCHESTRATION PATTERN
|
||||
|
||||
### You are the SWARM ORCHESTRATOR. **IMMEDIATELY SPAWN AGENTS IN PARALLEL** to execute tasks
|
||||
|
||||
### 🚨 CRITICAL INSTRUCTION: You are the SWARM ORCHESTRATOR
|
||||
|
||||
**MANDATORY**: When using swarms, you MUST:
|
||||
|
||||
1. **SPAWN ALL AGENTS IN ONE BATCH** - Use multiple tool calls in a SINGLE message
|
||||
2. **EXECUTE TASKS IN PARALLEL** - Never wait for one task before starting another
|
||||
3. **USE BATCHTOOL FOR EVERYTHING** - Multiple operations = Single message with multiple tools
|
||||
4. **ALL AGENTS MUST USE COORDINATION TOOLS** - Every spawned agent MUST use claude-flow hooks and memory
|
||||
|
||||
### 🎯 AGENT COUNT CONFIGURATION
|
||||
|
||||
**CRITICAL: Dynamic Agent Count Rules**
|
||||
|
||||
1. **Check CLI Arguments First**: If user runs `npx claude-flow@alpha --agents 5`, use 5 agents
|
||||
2. **Auto-Decide if No Args**: Without CLI args, analyze task complexity:
|
||||
- Simple tasks (1-3 components): 3-4 agents
|
||||
- Medium tasks (4-6 components): 5-7 agents
|
||||
- Complex tasks (7+ components): 8-12 agents
|
||||
3. **Agent Type Distribution**: Balance agent types based on task:
|
||||
- Always include 1 coordinator
|
||||
- For code-heavy tasks: more coders
|
||||
- For design tasks: more architects/analysts
|
||||
- For quality tasks: more testers/reviewers
|
||||
|
||||
**Example Auto-Decision Logic:**
|
||||
|
||||
```javascript
|
||||
// If CLI args provided: npx claude-flow@alpha --agents 6
|
||||
maxAgents = CLI_ARGS.agents || determineAgentCount(task);
|
||||
|
||||
function determineAgentCount(task) {
|
||||
// Analyze task complexity
|
||||
if (task.includes(['API', 'database', 'auth', 'tests'])) return 8;
|
||||
if (task.includes(['frontend', 'backend'])) return 6;
|
||||
if (task.includes(['simple', 'script'])) return 3;
|
||||
return 5; // default
|
||||
}
|
||||
```
|
||||
|
||||
## 📋 MANDATORY AGENT COORDINATION PROTOCOL
|
||||
|
||||
### 🔴 CRITICAL: Every Agent MUST Follow This Protocol
|
||||
|
||||
When you spawn an agent using the Task tool, that agent MUST:
|
||||
|
||||
**1️⃣ BEFORE Starting Work:**
|
||||
|
||||
```bash
|
||||
# Check previous work and load context
|
||||
npx claude-flow@alpha hooks pre-task --description "[agent task]" --auto-spawn-agents false
|
||||
npx claude-flow@alpha hooks session-restore --session-id "swarm-[id]" --load-memory true
|
||||
```
|
||||
|
||||
**2️⃣ DURING Work (After EVERY Major Step):**
|
||||
|
||||
```bash
|
||||
# Store progress in memory after each file operation
|
||||
npx claude-flow@alpha hooks post-edit --file "[filepath]" --memory-key "swarm/[agent]/[step]"
|
||||
|
||||
# Store decisions and findings
|
||||
npx claude-flow@alpha hooks notification --message "[what was done]" --telemetry true
|
||||
|
||||
# Check coordination with other agents
|
||||
npx claude-flow@alpha hooks pre-search --query "[what to check]" --cache-results true
|
||||
```
|
||||
|
||||
**3️⃣ AFTER Completing Work:**
|
||||
|
||||
```bash
|
||||
# Save all results and learnings
|
||||
npx claude-flow@alpha hooks post-task --task-id "[task]" --analyze-performance true
|
||||
npx claude-flow@alpha hooks session-end --export-metrics true --generate-summary true
|
||||
```
|
||||
|
||||
### 🎯 AGENT PROMPT TEMPLATE
|
||||
|
||||
When spawning agents, ALWAYS include these coordination instructions:
|
||||
|
||||
```
|
||||
You are the [Agent Type] agent in a coordinated swarm.
|
||||
|
||||
MANDATORY COORDINATION:
|
||||
1. START: Run `npx claude-flow@alpha hooks pre-task --description "[your task]"`
|
||||
2. DURING: After EVERY file operation, run `npx claude-flow@alpha hooks post-edit --file "[file]" --memory-key "agent/[step]"`
|
||||
3. MEMORY: Store ALL decisions using `npx claude-flow@alpha hooks notification --message "[decision]"`
|
||||
4. END: Run `npx claude-flow@alpha hooks post-task --task-id "[task]" --analyze-performance true`
|
||||
|
||||
Your specific task: [detailed task description]
|
||||
|
||||
REMEMBER: Coordinate with other agents by checking memory BEFORE making decisions!
|
||||
```
|
||||
|
||||
### ⚡ PARALLEL EXECUTION IS MANDATORY
|
||||
|
||||
**THIS IS WRONG ❌ (Sequential - NEVER DO THIS):**
|
||||
|
||||
```
|
||||
Message 1: Initialize swarm
|
||||
Message 2: Spawn agent 1
|
||||
Message 3: Spawn agent 2
|
||||
Message 4: TodoWrite (single todo)
|
||||
Message 5: Create file 1
|
||||
Message 6: TodoWrite (another single todo)
|
||||
```
|
||||
|
||||
**THIS IS CORRECT ✅ (Parallel - ALWAYS DO THIS):**
|
||||
|
||||
```
|
||||
Message 1: [BatchTool]
|
||||
// MCP coordination setup
|
||||
- mcp__claude-flow__swarm_init
|
||||
- mcp__claude-flow__agent_spawn (researcher)
|
||||
- mcp__claude-flow__agent_spawn (coder)
|
||||
- mcp__claude-flow__agent_spawn (analyst)
|
||||
- mcp__claude-flow__agent_spawn (tester)
|
||||
- mcp__claude-flow__agent_spawn (coordinator)
|
||||
|
||||
Message 2: [BatchTool - Claude Code execution]
|
||||
// Task agents with full coordination instructions
|
||||
- Task("You are researcher agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Research API patterns")
|
||||
- Task("You are coder agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Implement REST endpoints")
|
||||
- Task("You are analyst agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Analyze performance")
|
||||
- Task("You are tester agent. MANDATORY: Run hooks pre-task, post-edit, post-task. Task: Write comprehensive tests")
|
||||
|
||||
// TodoWrite with ALL todos batched
|
||||
- TodoWrite { todos: [
|
||||
{id: "research", content: "Research API patterns", status: "in_progress", priority: "high"},
|
||||
{id: "design", content: "Design database schema", status: "pending", priority: "high"},
|
||||
{id: "implement", content: "Build REST endpoints", status: "pending", priority: "high"},
|
||||
{id: "test", content: "Write unit tests", status: "pending", priority: "medium"},
|
||||
{id: "docs", content: "Create API documentation", status: "pending", priority: "low"},
|
||||
{id: "deploy", content: "Setup deployment", status: "pending", priority: "medium"}
|
||||
]}
|
||||
|
||||
// File operations in parallel
|
||||
- Write "api/package.json"
|
||||
- Write "api/server.js"
|
||||
- Write "api/routes/users.js"
|
||||
- Bash "mkdir -p api/{routes,models,tests}"
|
||||
```
|
||||
|
||||
### 🎯 MANDATORY SWARM PATTERN
|
||||
|
||||
When given ANY complex task with swarms:
|
||||
|
||||
```
|
||||
STEP 1: IMMEDIATE PARALLEL SPAWN (Single Message!)
|
||||
[BatchTool]:
|
||||
// IMPORTANT: Check CLI args for agent count, otherwise auto-decide based on task complexity
|
||||
- mcp__claude-flow__swarm_init {
|
||||
topology: "hierarchical",
|
||||
maxAgents: CLI_ARGS.agents || AUTO_DECIDE(task_complexity), // Use CLI args or auto-decide
|
||||
strategy: "parallel"
|
||||
}
|
||||
|
||||
// Spawn agents based on maxAgents count and task requirements
|
||||
// If CLI specifies 3 agents, spawn 3. If no args, auto-decide optimal count (3-12)
|
||||
- mcp__claude-flow__agent_spawn { type: "architect", name: "System Designer" }
|
||||
- mcp__claude-flow__agent_spawn { type: "coder", name: "API Developer" }
|
||||
- mcp__claude-flow__agent_spawn { type: "coder", name: "Frontend Dev" }
|
||||
- mcp__claude-flow__agent_spawn { type: "analyst", name: "DB Designer" }
|
||||
- mcp__claude-flow__agent_spawn { type: "tester", name: "QA Engineer" }
|
||||
- mcp__claude-flow__agent_spawn { type: "researcher", name: "Tech Lead" }
|
||||
- mcp__claude-flow__agent_spawn { type: "coordinator", name: "PM" }
|
||||
- TodoWrite { todos: [multiple todos at once] }
|
||||
|
||||
STEP 2: PARALLEL TASK EXECUTION (Single Message!)
|
||||
[BatchTool]:
|
||||
- mcp__claude-flow__task_orchestrate { task: "main task", strategy: "parallel" }
|
||||
- mcp__claude-flow__memory_usage { action: "store", key: "init", value: {...} }
|
||||
- Multiple Read operations
|
||||
- Multiple Write operations
|
||||
- Multiple Bash commands
|
||||
|
||||
STEP 3: CONTINUE PARALLEL WORK (Never Sequential!)
|
||||
```
|
||||
|
||||
### 📊 VISUAL TASK TRACKING FORMAT
|
||||
|
||||
Use this format when displaying task progress:
|
||||
|
||||
```
|
||||
📊 Progress Overview
|
||||
├── Total Tasks: X
|
||||
├── ✅ Completed: X (X%)
|
||||
├── 🔄 In Progress: X (X%)
|
||||
├── ⭕ Todo: X (X%)
|
||||
└── ❌ Blocked: X (X%)
|
||||
|
||||
📋 Todo (X)
|
||||
└── 🔴 001: [Task description] [PRIORITY] ▶
|
||||
|
||||
🔄 In progress (X)
|
||||
├── 🟡 002: [Task description] ↳ X deps ▶
|
||||
└── 🔴 003: [Task description] [PRIORITY] ▶
|
||||
|
||||
✅ Completed (X)
|
||||
├── ✅ 004: [Task description]
|
||||
└── ... (more completed tasks)
|
||||
|
||||
Priority indicators: 🔴 HIGH/CRITICAL, 🟡 MEDIUM, 🟢 LOW
|
||||
Dependencies: ↳ X deps | Actionable: ▶
|
||||
```
|
||||
|
||||
### 🎯 REAL EXAMPLE: Full-Stack App Development
|
||||
|
||||
**Task**: "Build a complete REST API with authentication, database, and tests"
|
||||
|
||||
**🚨 MANDATORY APPROACH - Everything in Parallel:**
|
||||
|
||||
```javascript
|
||||
// ✅ CORRECT: SINGLE MESSAGE with ALL operations
|
||||
[BatchTool - Message 1]:
|
||||
// Initialize and spawn ALL agents at once
|
||||
mcp__claude-flow__swarm_init { topology: "hierarchical", maxAgents: 8, strategy: "parallel" }
|
||||
mcp__claude-flow__agent_spawn { type: "architect", name: "System Designer" }
|
||||
mcp__claude-flow__agent_spawn { type: "coder", name: "API Developer" }
|
||||
mcp__claude-flow__agent_spawn { type: "coder", name: "Auth Expert" }
|
||||
mcp__claude-flow__agent_spawn { type: "analyst", name: "DB Designer" }
|
||||
mcp__claude-flow__agent_spawn { type: "tester", name: "Test Engineer" }
|
||||
mcp__claude-flow__agent_spawn { type: "coordinator", name: "Lead" }
|
||||
|
||||
// Update ALL todos at once - NEVER split todos!
|
||||
TodoWrite { todos: [
|
||||
{ id: "design", content: "Design API architecture", status: "in_progress", priority: "high" },
|
||||
{ id: "auth", content: "Implement authentication", status: "pending", priority: "high" },
|
||||
{ id: "db", content: "Design database schema", status: "pending", priority: "high" },
|
||||
{ id: "api", content: "Build REST endpoints", status: "pending", priority: "high" },
|
||||
{ id: "tests", content: "Write comprehensive tests", status: "pending", priority: "medium" },
|
||||
{ id: "docs", content: "Document API endpoints", status: "pending", priority: "low" },
|
||||
{ id: "deploy", content: "Setup deployment pipeline", status: "pending", priority: "medium" },
|
||||
{ id: "monitor", content: "Add monitoring", status: "pending", priority: "medium" }
|
||||
]}
|
||||
|
||||
// Start orchestration
|
||||
mcp__claude-flow__task_orchestrate { task: "Build REST API", strategy: "parallel" }
|
||||
|
||||
// Store initial memory
|
||||
mcp__claude-flow__memory_usage { action: "store", key: "project/init", value: { started: Date.now() } }
|
||||
|
||||
[BatchTool - Message 2]:
|
||||
// Create ALL directories at once
|
||||
Bash("mkdir -p test-app/{src,tests,docs,config}")
|
||||
Bash("mkdir -p test-app/src/{models,routes,middleware,services}")
|
||||
Bash("mkdir -p test-app/tests/{unit,integration}")
|
||||
|
||||
// Write ALL base files at once
|
||||
Write("test-app/package.json", packageJsonContent)
|
||||
Write("test-app/.env.example", envContent)
|
||||
Write("test-app/README.md", readmeContent)
|
||||
Write("test-app/src/server.js", serverContent)
|
||||
Write("test-app/src/config/database.js", dbConfigContent)
|
||||
|
||||
[BatchTool - Message 3]:
|
||||
// Read multiple files for context
|
||||
Read("test-app/package.json")
|
||||
Read("test-app/src/server.js")
|
||||
Read("test-app/.env.example")
|
||||
|
||||
// Run multiple commands
|
||||
Bash("cd test-app && npm install")
|
||||
Bash("cd test-app && npm run lint")
|
||||
Bash("cd test-app && npm test")
|
||||
```
|
||||
|
||||
### 🚫 NEVER DO THIS (Sequential = WRONG):
|
||||
|
||||
```javascript
|
||||
// ❌ WRONG: Multiple messages, one operation each
|
||||
Message 1: mcp__claude-flow__swarm_init
|
||||
Message 2: mcp__claude-flow__agent_spawn (just one agent)
|
||||
Message 3: mcp__claude-flow__agent_spawn (another agent)
|
||||
Message 4: TodoWrite (single todo)
|
||||
Message 5: Write (single file)
|
||||
// This is 5x slower and wastes swarm coordination!
|
||||
```
|
||||
|
||||
### 🔄 MEMORY COORDINATION PATTERN
|
||||
|
||||
Every agent coordination step MUST use memory:
|
||||
|
||||
```
|
||||
// After each major decision or implementation
|
||||
mcp__claude-flow__memory_usage
|
||||
action: "store"
|
||||
key: "swarm-{id}/agent-{name}/{step}"
|
||||
value: {
|
||||
timestamp: Date.now(),
|
||||
decision: "what was decided",
|
||||
implementation: "what was built",
|
||||
nextSteps: ["step1", "step2"],
|
||||
dependencies: ["dep1", "dep2"]
|
||||
}
|
||||
|
||||
// To retrieve coordination data
|
||||
mcp__claude-flow__memory_usage
|
||||
action: "retrieve"
|
||||
key: "swarm-{id}/agent-{name}/{step}"
|
||||
|
||||
// To check all swarm progress
|
||||
mcp__claude-flow__memory_usage
|
||||
action: "list"
|
||||
pattern: "swarm-{id}/*"
|
||||
```
|
||||
|
||||
### ⚡ PERFORMANCE TIPS
|
||||
|
||||
1. **Batch Everything**: Never operate on single files when multiple are needed
|
||||
2. **Parallel First**: Always think "what can run simultaneously?"
|
||||
3. **Memory is Key**: Use memory for ALL cross-agent coordination
|
||||
4. **Monitor Progress**: Use mcp**claude-flow**swarm_monitor for real-time tracking
|
||||
5. **Auto-Optimize**: Let hooks handle topology and agent selection
|
||||
|
||||
### 🎨 VISUAL SWARM STATUS
|
||||
|
||||
When showing swarm status, use this format:
|
||||
|
||||
```
|
||||
🐝 Swarm Status: ACTIVE
|
||||
├── 🏗️ Topology: hierarchical
|
||||
├── 👥 Agents: 6/8 active
|
||||
├── ⚡ Mode: parallel execution
|
||||
├── 📊 Tasks: 12 total (4 complete, 6 in-progress, 2 pending)
|
||||
└── 🧠 Memory: 15 coordination points stored
|
||||
|
||||
Agent Activity:
|
||||
├── 🟢 architect: Designing database schema...
|
||||
├── 🟢 coder-1: Implementing auth endpoints...
|
||||
├── 🟢 coder-2: Building user CRUD operations...
|
||||
├── 🟢 analyst: Optimizing query performance...
|
||||
├── 🟡 tester: Waiting for auth completion...
|
||||
└── 🟢 coordinator: Monitoring progress...
|
||||
```
|
||||
|
||||
## 📝 CRITICAL: TODOWRITE AND TASK TOOL BATCHING
|
||||
|
||||
### 🚨 MANDATORY BATCHING RULES FOR TODOS AND TASKS
|
||||
|
||||
**TodoWrite Tool Requirements:**
|
||||
|
||||
1. **ALWAYS** include 5-10+ todos in a SINGLE TodoWrite call
|
||||
2. **NEVER** call TodoWrite multiple times in sequence
|
||||
3. **BATCH** all todo updates together - status changes, new todos, completions
|
||||
4. **INCLUDE** all priority levels (high, medium, low) in one call
|
||||
|
||||
**Task Tool Requirements:**
|
||||
|
||||
1. **SPAWN** all agents using Task tool in ONE message
|
||||
2. **NEVER** spawn agents one by one across multiple messages
|
||||
3. **INCLUDE** full task descriptions and coordination instructions
|
||||
4. **BATCH** related Task calls together for parallel execution
|
||||
|
||||
**Example of CORRECT TodoWrite usage:**
|
||||
|
||||
```javascript
|
||||
// ✅ CORRECT - All todos in ONE call
|
||||
TodoWrite { todos: [
|
||||
{ id: "1", content: "Initialize system", status: "completed", priority: "high" },
|
||||
{ id: "2", content: "Analyze requirements", status: "in_progress", priority: "high" },
|
||||
{ id: "3", content: "Design architecture", status: "pending", priority: "high" },
|
||||
{ id: "4", content: "Implement core", status: "pending", priority: "high" },
|
||||
{ id: "5", content: "Build features", status: "pending", priority: "medium" },
|
||||
{ id: "6", content: "Write tests", status: "pending", priority: "medium" },
|
||||
{ id: "7", content: "Add monitoring", status: "pending", priority: "medium" },
|
||||
{ id: "8", content: "Documentation", status: "pending", priority: "low" },
|
||||
{ id: "9", content: "Performance tuning", status: "pending", priority: "low" },
|
||||
{ id: "10", content: "Deploy to production", status: "pending", priority: "high" }
|
||||
]}
|
||||
```
|
||||
|
||||
**Example of WRONG TodoWrite usage:**
|
||||
|
||||
```javascript
|
||||
// ❌ WRONG - Multiple TodoWrite calls
|
||||
Message 1: TodoWrite { todos: [{ id: "1", content: "Task 1", ... }] }
|
||||
Message 2: TodoWrite { todos: [{ id: "2", content: "Task 2", ... }] }
|
||||
Message 3: TodoWrite { todos: [{ id: "3", content: "Task 3", ... }] }
|
||||
// This breaks parallel coordination!
|
||||
```
|
||||
|
||||
## Claude Flow v2.0.0 Features
|
||||
|
||||
Claude Flow extends the base coordination with:
|
||||
|
||||
- **🔗 GitHub Integration** - Deep repository management
|
||||
- **🎯 Project Templates** - Quick-start for common projects
|
||||
- **📊 Advanced Analytics** - Detailed performance insights
|
||||
- **🤖 Custom Agent Types** - Domain-specific coordinators
|
||||
- **🔄 Workflow Automation** - Reusable task sequences
|
||||
- **🛡️ Enhanced Security** - Safer command execution
|
||||
|
||||
## Support
|
||||
|
||||
- Documentation: https://github.com/ruvnet/claude-flow
|
||||
- Issues: https://github.com/ruvnet/claude-flow/issues
|
||||
- Examples: https://github.com/ruvnet/claude-flow/tree/main/examples
|
||||
|
||||
---
|
||||
|
||||
Remember: **Claude Flow coordinates, Claude Code creates!** Start with `mcp__claude-flow__swarm_init` to enhance your development workflow.
|
||||
Reference in New Issue
Block a user