Claude Flow is a powerful Model Context Protocol (MCP) server that provides advanced AI swarm orchestration, memory management, and performance monitoring capabilities. It enables sophisticated multi-agent coordination with real-time tracing and observability.

• 🤖 AI Swarm Orchestration: Coordinate multiple AI agents with different topologies (mesh, hierarchical, ring, star)
• 🧠 Persistent Memory: SQLite-based memory storage for cross-session context retention
• 📊 Real-time Monitoring: Live performance tracking and visualization
• 🔗 MCP Integration: Full Model Context Protocol server implementation
• 📈 Langfuse Tracing: Comprehensive observability with Langfuse integration
• 🚀 Performance Optimization: Automatic bottleneck detection and optimization

• Neural Pattern Learning: Agents learn from successful operations
• GitHub Integration: Repository-aware swarms for code management
• Hooks System: Pre/post operation hooks for automation
• Session Management: Persistent state across sessions
• Parallel Execution: 2.8-4.4x speed improvements through parallelization

# Add Claude Flow MCP server to Claude Code
claude mcp add claude-flow npx claude-flow@alpha mcp start

# Global installation
npm install -g claude-flow@alpha

# Or use directly with npx
npx claude-flow@alpha [command]

# Using Docker Compose
docker-compose -f docker-compose.yml up -d

# Minimal setup
docker-compose -f docker-compose.minimal.yml up -d

# Full stack with monitoring
docker-compose -f docker-compose.stack.yml up -d

# Start MCP server
npx claude-flow@alpha mcp start

# Initialize a swarm
npx claude-flow@alpha swarm init --topology mesh --agents 5

# Spawn an agent
npx claude-flow@alpha agent spawn --type researcher --name "API Explorer"

# Use hooks
npx claude-flow@alpha hooks pre-task --description "Analyze codebase"
npx claude-flow@alpha hooks post-edit --file "src/app.js" --format true

Once configured as an MCP server, use these tools:

• mcp__claude-flow__swarm_init - Initialize swarm coordination
• mcp__claude-flow__agent_spawn - Create specialized agents
• mcp__claude-flow__task_orchestrate - Coordinate complex tasks
• mcp__claude-flow__memory_usage - Store/retrieve persistent memory
• mcp__claude-flow__swarm_monitor - Real-time monitoring

claude-flow/
├── src/
│   ├── agents/           # Agent implementations
│   ├── mcp/              # MCP server
│   ├── memory/           # Memory management
│   ├── monitoring/       # Performance monitoring
│   ├── tracing/          # Langfuse integration
│   └── hooks/            # Hook system
├── bin/                  # CLI executables
├── scripts/              # Utility scripts
└── docs/                 # Documentation

1. MCP Server (src/mcp/server.js)

   • Handles MCP protocol communication
   • Provides tool interfaces for Claude

2. Swarm Manager (src/agents/swarm-manager.js)

   • Orchestrates multi-agent coordination
   • Manages different topology patterns

3. Memory Store (src/memory/store.js)

   • SQLite-based persistent storage
   • Cross-session context retention

4. Trace Manager (src/instrumentation/trace-manager.js)

   • Langfuse integration for observability
   • Performance metrics collection

# Langfuse Configuration (optional)
LANGFUSE_SECRET_KEY=your-secret-key
LANGFUSE_PUBLIC_KEY=your-public-key
LANGFUSE_HOST=https://cloud.langfuse.com

# Performance Settings
MAX_AGENTS=10
PARALLEL_EXECUTION=true
MEMORY_DB_PATH=.swarm/memory.db

Hooks are configured in .claude/settings.json:

• Automatic agent assignment
• Code formatting on save
• Performance optimization
• Session persistence

• 84.8% SWE-Bench solve rate - Superior problem-solving
• 32.3% token reduction - Efficient task coordination
• 2.8-4.4x speed improvement - Through parallelization
• 27+ neural models - Diverse cognitive approaches

• claude-flow:latest - Full server with all features
• claude-flow:worker - Lightweight worker image
• claude-flow:dashboard - Monitoring dashboard

• docker-compose.yml - Standard deployment
• docker-compose.minimal.yml - Minimal setup
• docker-compose.stack.yml - Full monitoring stack

npm test
npm run test:integration
npm run test:performance

npm run build
npm run docker:build

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Run tests
5. Submit a pull request

MIT License - see LICENSE file for details

• Issues: GitHub Issues
• Documentation: Full Docs
• Examples: See /docs directory

Claude Flow - Empowering AI coordination and collaboration 🚀