---
name: "AgentDB Vector Search"
description: "Implement semantic search with 150x-12,500x performance.
Use for RAG systems, documentation search, similarity matching."
---

# Instructions
[Detailed step-by-step guidance...]

# Examples
[Code examples and use cases...]

# Best Practices
[What works well, what to avoid...]

# Install claude-flow for 21 built-in skills
npm install -g claude-flow@alpha

# Add MCP server (makes skills available)
claude mcp add claude-flow npx claude-flow@alpha mcp start

# Verify it's running
claude mcp list
# ✓ claude-flow@alpha   npx claude-flow@alpha mcp start   ✓ Running

# That's it! All 21 skills are now available.

You: "I need semantic search for my documentation"

Claude: I'll use the agentdb-vector-search skill to implement this.
[Automatically loads skill instructions and implements solution]

# Install agentic-flow for custom skill creation
npm install -g agentic-flow@latest

# Initialize skill directories
npx agentic-flow skills init

# Create sample skills
npx agentic-flow skills create

# Install skill builder
npx agentic-flow skills init-builder

description: "Implement persistent memory patterns for AI agents using AgentDB.
Includes session memory, long-term storage, pattern learning, and context management.
Use when building stateful agents, chat systems, or intelligent assistants."

description: "Implement semantic vector search with AgentDB for intelligent
document retrieval, similarity matching, and context-aware querying. Use when
building RAG systems, semantic search engines, or intelligent knowledge bases."

description: "Implement adaptive learning with ReasoningBank for pattern recognition,
strategy optimization, and continuous improvement. Use when building self-learning
agents, optimizing workflows, or implementing meta-cognitive systems."

description: "Comprehensive Flow Nexus platform management - authentication,
sandboxes, app deployment, payments, and challenges."

description: "Train and deploy neural networks in distributed E2B sandboxes
with Flow Nexus."

description: "Cloud-based AI swarm deployment and event-driven workflow
automation with Flow Nexus platform."

description: "Comprehensive GitHub code review with AI-powered swarm coordination."

description: "Multi-repository coordination, synchronization, and architecture
management with AI swarm orchestration."

description: "Comprehensive GitHub project management with swarm-coordinated
issue tracking, project board automation, and sprint planning."

description: "Comprehensive GitHub release orchestration with AI swarm coordination
for automated versioning, testing, deployment, and rollback management."

description: "Advanced GitHub Actions workflow automation with AI swarm coordination,
intelligent CI/CD pipelines, and comprehensive repository management."

description: "Orchestrate multi-agent swarms with agentic-flow for parallel task
execution, dynamic topology, and intelligent coordination. Use when scaling beyond
single agents, implementing complex workflows, or building distributed AI systems."

description: "Advanced swarm orchestration patterns for research, development,
testing, and complex distributed workflows."

description: "Advanced Hive Mind collective intelligence system for queen-led
multi-agent coordination with consensus mechanisms and persistent memory."

description: "Stream-JSON chaining for multi-agent pipelines, data transformation,
and sequential workflows."

description: "SPARC (Specification, Pseudocode, Architecture, Refinement, Completion)
comprehensive development methodology with multi-agent orchestration."

description: "AI-assisted pair programming with multiple modes (driver/navigator/switch),
real-time verification, quality monitoring, and comprehensive testing. Supports TDD,
debugging, refactoring, and learning sessions."

description: "Comprehensive truth scoring, code quality verification, and automatic
rollback system with 0.95 accuracy threshold for ensuring high-quality agent outputs
and codebase reliability."

description: "Automated coordination, formatting, and learning from Claude Code
operations using intelligent hooks with MCP integration. Includes pre/post task
hooks, session management, Git integration, memory coordination, and neural pattern
training for enhanced development workflows."

description: "Create new Claude Code Skills with proper YAML frontmatter, progressive
disclosure structure, and complete directory organization. Use when you need to build
custom skills for specific workflows, generate skill templates, or understand the
Claude Skills specification."

description: "Comprehensive performance analysis, bottleneck detection, and
optimization recommendations for Claude Flow swarms."

You: "Add semantic search to our documentation site"

Claude (using agentdb-vector-search skill):
├─ Analyzes your documentation structure
├─ Sets up AgentDB vector database
├─ Generates embeddings for all docs
├─ Implements search API endpoint
├─ Creates search UI component
└─ Adds relevance scoring

Result: Working semantic search in minutes
Performance: 150x faster than traditional search
Learning: Pattern stored for 46% faster next time

You: "Review PR #123 for security and performance"

Claude (using github-code-review skill):
├─ Spawns security auditor agent
├─ Spawns performance analyzer agent
├─ Spawns code quality reviewer agent
├─ Coordinates findings via shared memory
└─ Generates unified review report

Result: Comprehensive multi-angle review
Agents: 3 specialized reviewers in parallel
Time: 3.2 seconds for 2,847 files

You: "Build user authentication system"

Claude (using sparc-methodology skill):
├─ Specification: Requirements analysis
├─ Pseudocode: Algorithm design
├─ Architecture: System design
├─ Refinement: TDD implementation
└─ Completion: Integration & testing

Result: Complete auth system with tests
Process: Systematic, test-driven approach
Quality: 90%+ code coverage

Task: "Build REST API with tests and deploy to GitHub"

Skills activated:
┌─────────────────────────────────────────┐
│ 1. sparc-methodology                     │
│    Plans development phases              │
├─────────────────────────────────────────┤
│ 2. swarm-orchestration                   │
│    Spawns parallel agents:               │
│    ├─ backend-dev (API)                  │
│    ├─ tester (tests)                     │
│    └─ reviewer (quality)                 │
├─────────────────────────────────────────┤
│ 3. agentdb-memory-patterns               │
│    Coordinates agents via shared memory  │
├─────────────────────────────────────────┤
│ 4. github-workflow-automation            │
│    Creates CI/CD pipeline                │
├─────────────────────────────────────────┤
│ 5. verification-quality                  │
│    Validates output (0.95 threshold)     │
├─────────────────────────────────────────┤
│ 6. reasoningbank-intelligence            │
│    Stores patterns for next time         │
└─────────────────────────────────────────┘

Result: Production-ready API + CI/CD
Time: Minutes instead of hours
Learning: 46% faster on next similar project

Task: "Coordinate release across 5 microservices"

Skills activated:
┌─────────────────────────────────────────┐
│ 1. github-multi-repo                     │
│    Syncs versions across repos           │
├─────────────────────────────────────────┤
│ 2. github-release-management             │
│    Orchestrates release process          │
├─────────────────────────────────────────┤
│ 3. swarm-orchestration                   │
│    Parallel testing across services      │
├─────────────────────────────────────────┤
│ 4. verification-quality                  │
│    Validates each service                │
└─────────────────────────────────────────┘

Result: Coordinated multi-repo release
Services: 5 microservices in sync
Safety: Rollback on any failure

Task: "Optimize slow React application"

Skills activated:
┌─────────────────────────────────────────┐
│ 1. performance-analysis                  │
│    Identifies bottlenecks                │
├─────────────────────────────────────────┤
│ 2. agentdb-vector-search                 │
│    Finds similar optimization patterns   │
├─────────────────────────────────────────┤
│ 3. reasoningbank-intelligence            │
│    Applies learned optimizations         │
├─────────────────────────────────────────┤
│ 4. pair-programming                      │
│    Guides implementation step-by-step    │
└─────────────────────────────────────────┘

Result: 4x performance improvement
Approach: Data-driven + pattern-based
Validation: Before/after metrics

┌─────────────────────────────────────────────────────────────┐
│                     Claude Code (User)                       │
└────────────────┬───────────────────────┬────────────────────┘
                 │                       │
    ┌────────────▼─────────┐   ┌────────▼──────────┐
    │  claude-flow Skills  │   │ agentic-flow Skills│
    │  (21 Built-In)       │   │  (Custom Created)  │
    └────────────┬─────────┘   └────────┬──────────┘
                 │                       │
                 │    ┌──────────────────┘
                 │    │
    ┌────────────▼────▼──────────────────────────────┐
    │         MCP Integration Layer                  │
    │  • claude-flow: 213+ coordination tools        │
    │  • ruv-swarm: Enhanced coordination            │
    │  • flow-nexus: Cloud capabilities              │
    │  • agentic-flow: Multi-provider agent runtime  │
    └────────────┬───────────────────────────────────┘
                 │
    ┌────────────▼───────────────────────────────────┐
    │        Execution & Memory Layer                │
    │  • AgentDB: Vector search + memory             │
    │  • ReasoningBank: Pattern learning             │
    │  • 54 Specialized Agents                       │
    │  • SPARC Methodology                           │
    └────────────────────────────────────────────────┘

User Request: "Build a REST API with comprehensive tests and deploy to GitHub"

Claude Code coordinates:
┌─────────────────────────────────────────────────────────────┐
│ 1. sparc-methodology skill                                   │
│    └─> Plans systematic development phases                  │
├─────────────────────────────────────────────────────────────┤
│ 2. swarm-orchestration skill                                │
│    ├─> Spawns backend-dev agent (API implementation)        │
│    ├─> Spawns tester agent (test creation)                  │
│    └─> Spawns reviewer agent (code review)                  │
├─────────────────────────────────────────────────────────────┤
│ 3. agentdb-memory-patterns skill                            │
│    └─> Coordinates agents via shared memory                 │
├─────────────────────────────────────────────────────────────┤
│ 4. github-workflow-automation skill                         │
│    └─> Creates CI/CD pipeline                               │
├─────────────────────────────────────────────────────────────┤
│ 5. verification-quality skill                               │
│    └─> Validates output quality (0.95 threshold)            │
├─────────────────────────────────────────────────────────────┤
│ 6. reasoningbank-intelligence skill                         │
│    └─> Stores successful patterns for future use            │
└─────────────────────────────────────────────────────────────┘

MCP Tools Used:
- mcp__claude-flow__swarm_init (topology setup)
- mcp__claude-flow__agent_spawn (create agents)
- mcp__claude-flow__memory_usage (coordination)
- mcp__claude-flow__github_workflow_auto (CI/CD)

Result: Complete REST API with tests, deployed to GitHub,
        patterns stored for 46% faster next execution

// Traditional: Context lost every time
"Please analyze this API design"  // Forgets previous analyses

// With Skills: Context accumulates
AgentDB stores: [previous API patterns, success metrics, failure cases]
Skill applies: Learned best practices from 100+ prior analyses

# Personal project
~/.claude/skills/api-design/

# Team repository
.claude/skills/api-design/

# Organization-wide
Shared across all Claude Code instances

Swarm Orchestration Skill:
  1. Spawn coder agent (write implementation)
  2. Spawn tester agent (write tests)
  3. Spawn reviewer agent (code review)
  4. Coordinate via shared AgentDB memory
  5. Synthesize final output

# Create skill directory
npx agentic-flow skills init

# Create example skills
npx agentic-flow skills create

# That's it! Claude Code finds them automatically

# Verify Node.js installation
node --version    # v18.0.0 or higher
npm --version     # v9.0.0 or higher

# Option 1: Install claude-flow (includes 21 built-in skills + 213+ MCP tools)
npm install -g claude-flow@alpha
npx claude-flow --version  # Should show 2.7.0 or higher

# Option 2: Install agentic-flow (for custom skill creation)
npm install -g agentic-flow@latest
npx agentic-flow --version  # Should show 1.7.3 or higher

# Recommended: Install both for full capabilities
npm install -g claude-flow@alpha agentic-flow@latest

# Add claude-flow MCP server (required for 21 built-in skills)
claude mcp add claude-flow npx claude-flow@alpha mcp start

# Optional: Add additional MCP servers for enhanced capabilities
claude mcp add ruv-swarm npx ruv-swarm mcp start              # Enhanced coordination
claude mcp add flow-nexus npx flow-nexus@latest mcp start    # Cloud features
claude mcp add agentic-flow npx agentic-flow@latest mcp start  # Multi-provider agents

# Verify MCP servers are running
claude mcp list

# Should show:
# claude-flow@alpha   npx claude-flow@alpha mcp start   ✓ Running

# Initialize both personal and project skills
npx agentic-flow skills init

🎨 Initializing agentic-flow Skills
═══════════════════════════════════════════════════════════════

✓ Created personal skills directory: /home/user/.claude/skills
✓ Created project skills directory: /workspace/.claude/skills

✓ Skills directories initialized!

# Create 4 built-in agentic-flow skills
npx agentic-flow skills create

✓ Created 4 agentic-flow skills!

Skills installed:
  • AgentDB Vector Search    - Semantic search with vector embeddings
  • AgentDB Memory Patterns  - Memory management & persistence
  • Swarm Orchestration      - Multi-agent coordination
  • ReasoningBank Intelligence - Pattern learning & adaptation

.claude/skills/
  ├── agentdb-vector-search/
  │   └── SKILL.md
  ├── agentdb-memory-patterns/
  │   └── SKILL.md
  ├── swarm-orchestration/
  │   └── SKILL.md
  └── reasoningbank-intelligence/
      └── SKILL.md

# Install the comprehensive skill creation framework
npx agentic-flow skills init-builder

.claude/skills/skill-builder/
  ├── SKILL.md                    # Main skill-builder skill
  ├── README.md                   # Quick reference guide
  ├── docs/
  │   ├── SPECIFICATION.md        # Complete Claude Skills spec
  │   ├── EXAMPLES.md             # Real-world examples
  │   └── BEST_PRACTICES.md       # Design patterns
  ├── scripts/
  │   ├── generate-skill.sh       # Interactive skill generator
  │   ├── validate-skill.sh       # YAML/structure validator
  │   ├── test-skill.sh           # Skill testing utility
  │   └── publish-skill.sh        # Team sharing helper
  ├── resources/
  │   ├── templates/              # Pre-built skill templates
  │   │   ├── minimal.md          # Basic skill structure
  │   │   ├── full-featured.md    # Complete with all sections
  │   │   └── advanced.md         # Multi-agent coordination
  │   └── schemas/
  │       ├── skill-schema.json   # JSON schema for validation
  │       └── frontmatter.yaml    # YAML frontmatter spec
  └── templates/                  # Working example skills
      ├── api-design-pattern.md
      ├── testing-framework.md
      └── documentation-generator.md

# See all installed skills
npx agentic-flow skills list

📚 Installed Claude Code Skills
═══════════════════════════════════════════════════════════════

Personal Skills (~/.claude/skills/)
  • Skill Builder
     Create new Claude Code Skills with proper YAML frontmatter...

Project Skills (.claude/skills/)
  • AgentDB Memory Patterns
     Implement persistent memory patterns for AI agents...
  • AgentDB Vector Search
     Implement semantic vector search with AgentDB...
  • Swarm Orchestration
     Orchestrate multi-agent swarms with agentic-flow...
  • ReasoningBank Intelligence
     Implement adaptive learning with ReasoningBank...

// Vector embeddings with AgentDB
await db.vectorDB.insert(embedding, {
  id: 'doc-123',
  content: 'React hooks tutorial',
  tags: ['react', 'hooks']
});

// Semantic search (finds similar meaning, not just keywords)
const results = await db.vectorDB.search(queryEmbedding, {
  k: 10,  // Top 10 results
  threshold: 0.7  // 70% similarity minimum
});

// Session memory - persists across conversations
await reasoningbank.storeMemory('user_preference', 'dark mode', {
  namespace: 'settings',
  sessionId: 'user-123'
});

// Cross-session retrieval
const prefs = await reasoningbank.queryMemories('user preferences', {
  namespace: 'settings',
  sessionId: 'user-123'
});

// Pattern learning - remember what works
await reasoningbank.storePattern({
  pattern: 'api-pagination',
  approach: 'cursor-based',
  success: true,
  confidence: 0.95
});

// Initialize coordinated swarm
const swarm = await initializeSwarm({
  topology: 'mesh',  // Agents communicate peer-to-peer
  agents: [
    { type: 'coder', focus: 'implementation' },
    { type: 'tester', focus: 'test coverage' },
    { type: 'reviewer', focus: 'code quality' }
  ],
  coordination: 'agentdb'  // Shared memory
});

// Agents work in parallel, share context via AgentDB
for (const agent of swarm.agents) {
  await agent.execute();  // Parallel execution
  await agentDB.store(agent.results);  // Share findings
}

// Synthesize collective intelligence
const synthesis = await agentDB.synthesize({
  namespace: 'code-review',
  strategy: 'consensus'
});

// Store successful patterns
await reasoningbank.storePattern({
  domain: 'api-design',
  pattern: 'authentication',
  approach: 'JWT with refresh tokens',
  metrics: {
    security: 'excellent',
    performance: 'optimized',
    maintainability: 'high'
  },
  success: true
});

// Query learned patterns
const bestApproach = await reasoningbank.queryPatterns('authentication', {
  domain: 'api-design',
  sortBy: 'success_rate'
});

// Continuous improvement - learns from each execution
// First time: generic approach
// After 10 runs: optimized with learned patterns
// After 100 runs: domain expertise

I need to implement semantic search for our documentation.
The docs are in markdown files and I want users to search by meaning, not keywords.

I'll help you implement semantic search using AgentDB's vector search capabilities.
I found the AgentDB Vector Search skill which provides a 150x-12,500x performance
improvement over traditional search.

Here's my implementation plan:
[Detailed plan based on skill instructions...]

// 1. Initialize AgentDB with vector support
import { AgentDB } from 'agentdb';

const db = new AgentDB({
  mode: 'node',
  vectorDimensions: 384,  // From skill template
  enableOptimizations: true
});

// 2. Create vector index (from skill instructions)
await db.vectorDB.createIndex({
  dimension: 384,
  metric: 'cosine'
});

// 3. Index documents with embeddings
const docs = await loadMarkdownFiles('./docs/**/*.md');
for (const doc of docs) {
  const embedding = await generateEmbedding(doc.content);
  await db.vectorDB.insert(embedding, {
    id: doc.id,
    title: doc.title,
    content: doc.content,
    url: doc.url
  });
}

// 4. Implement search function
async function searchDocs(query) {
  const queryEmbedding = await generateEmbedding(query);
  const results = await db.vectorDB.search(queryEmbedding, {
    k: 10,
    includeMetadata: true
  });
  return results;
}

// AgentDB stores the pattern
await db.storePattern({
  skill: 'agentdb-vector-search',
  task: 'documentation search',
  approach: 'markdown indexing with 384-dim embeddings',
  performance: { searchTime: '2ms', accuracy: '95%' },
  success: true
});

I need a comprehensive code review of our TypeScript backend.
Check for bugs, security issues, performance problems, and best practices.

I'll coordinate a swarm of specialized review agents:

Spawning agents:
  1. Security Auditor - Scanning for vulnerabilities
  2. Performance Analyzer - Identifying bottlenecks
  3. Code Quality Reviewer - Checking best practices
  4. Type Safety Checker - Verifying TypeScript types

Coordination mode: Mesh topology with shared AgentDB memory

// Behind the scenes (from swarm-orchestration skill)
const swarm = await initializeSwarm({
  topology: 'mesh',
  agents: [
    { type: 'security', focus: 'OWASP Top 10' },
    { type: 'performance', focus: 'Big O analysis' },
    { type: 'quality', focus: 'SOLID principles' },
    { type: 'types', focus: 'TypeScript strictness' }
  ],
  coordination: 'agentdb'  // Shared memory via AgentDB
});

// Each agent stores findings in shared memory
for (const agent of swarm.agents) {
  await agent.execute();
  await agentDB.store(agent.findings, {
    namespace: 'code-review',
    agentId: agent.id
  });
}

// Synthesize final report
const allFindings = await agentDB.query({
  namespace: 'code-review',
  similarity: 'cluster'  // Group related issues
});

Code Review Complete (4 agents, 2,847 files analyzed in 3.2 seconds)

🔴 Critical (3):
  - SQL injection vulnerability in auth.ts:42
  - Unvalidated user input in api/users.ts:156
  - Memory leak in websocket handler

🟡 Warnings (12):
  - N+1 query pattern in database/posts.ts
  - Missing error boundaries in React components
  [...]

✅ Best Practices (8 suggestions):
  - Consider using dependency injection
  - Add JSDoc comments for public APIs
  [...]

Performance Analysis:
  - Average response time: 45ms → could be 12ms with caching
  - Database queries: 234 → could be 67 with batching

Create a REST API endpoint for user registration.

// Basic implementation (no prior learning)
app.post('/api/users', async (req, res) => {
  const user = await User.create(req.body);
  res.json(user);
});

This needs better error handling, validation, and security.

// Improved implementation
app.post('/api/users', [
  validateRequest(userSchema),    // Added validation
  sanitizeInput(),                 // Added sanitization
  async (req, res, next) => {
    try {
      const user = await User.create(req.body);
      res.status(201).json({
        success: true,
        data: user
      });
    } catch (error) {
      next(error);  // Proper error handling
    }
  }
]);

// AgentDB stores this pattern via ReasoningBank skill
await reasoningbank.storePattern({
  domain: 'rest-api',
  pattern: 'user-registration',
  approach: 'validation + sanitization + try-catch',
  confidence: 0.95
});

Create a REST API endpoint for password reset.

// Automatically applies learned patterns!
app.post('/api/auth/reset-password', [
  validateRequest(passwordResetSchema),  // ✅ Remembered validation
  sanitizeInput(),                       // ✅ Remembered sanitization
  rateLimiter({ max: 5, window: '15m' }), // ✅ Added security best practice
  async (req, res, next) => {
    try {
      const token = await generateResetToken(req.body.email);
      await sendResetEmail(req.body.email, token);

      res.status(200).json({
        success: true,
        message: 'Reset email sent'
      });
    } catch (error) {
      next(error);  // ✅ Proper error handling
    }
  }
]);

import { Agent } from '@anthropic-ai/claude-agent-sdk';

// Create agent (auto-discovers skills in ~/.claude/skills/)
const agent = new Agent({
  apiKey: process.env.ANTHROPIC_API_KEY,
  model: 'claude-sonnet-4-5-20250929',
  skillsDir: './.claude/skills'  // Project-specific skills
});

// Agent automatically uses relevant skills
const result = await agent.run({
  task: 'Implement semantic search for our documentation'
});

// Skills are loaded automatically based on task description matching

import * as agenticFlow from 'agentic-flow';
import { AgentDB } from 'agentdb';

// Initialize with AgentDB memory backend
const db = new AgentDB({
  mode: 'node',
  vectorDimensions: 384,
  enableOptimizations: true
});

// Initialize ReasoningBank with AgentDB
await agenticFlow.reasoningbank.initialize({
  backend: 'agentdb',
  db
});

// Run agent with persistent learning
const agent = await agenticFlow.createAgent({
  type: 'coder',
  model: 'claude-sonnet-4-5-20250929',
  skillsDir: './.claude/skills',
  memory: db,  // Persistent memory across sessions
  learning: true  // Enable ReasoningBank pattern learning
});

// Execute task - skills auto-discovered + patterns learned
const result = await agent.execute({
  task: 'Implement semantic search for our documentation'
});

// Pattern automatically stored in AgentDB for future use
// Next time: 46% faster with learned patterns

import * as agenticFlow from 'agentic-flow';

// Initialize swarm with shared AgentDB memory
const swarm = await agenticFlow.swarm.initialize({
  topology: 'mesh',  // Agents communicate peer-to-peer
  agents: [
    {
      type: 'researcher',
      skillsDir: './.claude/skills',  // All agents share skills
      memory: 'shared'  // Shared AgentDB instance
    },
    {
      type: 'coder',
      skillsDir: './.claude/skills',
      memory: 'shared'
    },
    {
      type: 'tester',
      skillsDir: './.claude/skills',
      memory: 'shared'
    }
  ],
  coordination: {
    backend: 'agentdb',  // Coordinate via vector memory
    consensus: 'majority'  // Decision-making strategy
  }
});

// Orchestrate task across multiple agents
// Each agent uses relevant skills + shares learnings via AgentDB
const result = await swarm.orchestrate({
  task: 'Build a REST API with comprehensive tests'
});

// All agents contribute patterns to shared memory
// Future executions benefit from collective intelligence

┌─────────────────────────────────────────────────────────┐
│                    User Application                      │
└────────────────────┬────────────────────────────────────┘
                     │
        ┌────────────▼────────────┐
        │  Claude Agent SDK       │  ← Official Anthropic SDK
        │  - Agent creation       │
        │  - Skill discovery      │
        │  - Task execution       │
        └────────────┬────────────┘
                     │
        ┌────────────▼────────────┐
        │  agentic-flow Layer     │  ← Enterprise features
        │  - Multi-agent swarms   │
        │  - AgentDB integration  │
        │  - ReasoningBank        │
        │  - Skill-builder        │
        └────────────┬────────────┘
                     │
     ┌───────────────┼───────────────┐
     │               │               │
┌────▼─────┐  ┌─────▼──────┐  ┌────▼──────┐
│  Skills  │  │  AgentDB   │  │ Reasoning │
│ (.claude)│  │  (Memory)  │  │   Bank    │
└──────────┘  └────────────┘  └───────────┘

# Run an agent with specific skill context
npx agentic-flow \
  --agent coder \
  --task "Implement semantic search" \
  --skill agentdb-vector-search

# Scenario: Build a complete app with coordinated agents
npx agentic-flow \
  --agent swarm \
  --task "Build a todo app with React + Node + PostgreSQL" \
  --skill swarm-orchestration

// swarm-orchestration skill coordinates multiple agents
const swarm = {
  agents: [
    { type: 'backend-dev', task: 'Build Node/Express API', skill: 'api-patterns' },
    { type: 'frontend-dev', task: 'Build React UI', skill: 'react-patterns' },
    { type: 'database-architect', task: 'Design PostgreSQL schema', skill: 'db-design' },
    { type: 'tester', task: 'Write Jest tests', skill: 'testing-patterns' },
    { type: 'reviewer', task: 'Code review', skill: 'quality-checks' }
  ],
  coordination: {
    memory: 'agentdb',      // Shared context
    topology: 'hierarchical', // Backend → Frontend → Tests
    feedback: 'continuous'    // Real-time learning
  }
};

// Execute with skill-guided reasoning
for (const agent of swarm.agents) {
  const skillContext = await loadSkill(agent.skill);
  const result = await agent.execute({
    task: agent.task,
    context: skillContext,
    sharedMemory: agentDB
  });

  // Store patterns for future use
  await reasoningbank.learn(result);
}

Use the skill-builder to create a custom skill for GraphQL API design.
I want it to cover schema design, resolvers, and performance optimization.

I'll help you create a GraphQL API Design skill using the skill-builder framework.

Following the skill-builder template...
✓ Analyzing requirements
✓ Selecting template: full-featured (comprehensive with examples)
✓ Generating YAML frontmatter
✓ Creating progressive disclosure structure
✓ Adding code examples
✓ Validating skill structure

Creating: .claude/skills/graphql-api-design/SKILL.md

---
name: "GraphQL API Design"
description: "Design GraphQL APIs following best practices for schema design,
resolvers, and performance. Use when building or refactoring GraphQL services."
---

# GraphQL API Design

## What This Skill Does
Guides the design of GraphQL APIs with focus on schema-first development,
efficient resolvers, and query optimization.

## When to Use
- Designing new GraphQL schemas
- Refactoring existing APIs
- Optimizing query performance
- Implementing federation

## Prerequisites
- Node.js 18+
- GraphQL 16+
- Apollo Server or similar

## Quick Start

### 1. Schema Design
\`\`\`graphql
# Design schema with clear types
type User {
  id: ID!
  email: String!
  posts: [Post!]!
}

type Post {
  id: ID!
  title: String!
  content: String!
  author: User!
}
\`\`\`

### 2. Resolver Pattern
\`\`\`javascript
const resolvers = {
  Query: {
    user: async (_, { id }, { dataSources }) => {
      return dataSources.userAPI.getUser(id);
    }
  },
  User: {
    posts: async (user, _, { dataSources }) => {
      return dataSources.postAPI.getPostsByUserId(user.id);
    }
  }
};
\`\`\`

### 3. Performance Optimization
- Use DataLoader for N+1 query prevention
- Implement query complexity analysis
- Add caching layers
- Monitor resolver timing

## Advanced Patterns
[Detailed federation, subscriptions, etc...]

## Learn More
- Schema design principles
- Resolver best practices
- Performance optimization strategies

# Verify it's available
npx agentic-flow skills list

# Output includes:
# • GraphQL API Design
#    Design GraphQL APIs following best practices...

mkdir -p .claude/skills/my-custom-skill

cat > .claude/skills/my-custom-skill/SKILL.md << 'EOF'
---
name: "My Custom Skill"
description: "Brief description of what this skill does and when to use it.
Maximum 1024 characters."
---

# My Custom Skill

## What This Skill Does
Explain the skill's purpose clearly.

## When to Use
- Use case 1
- Use case 2

## Prerequisites
- Requirement 1
- Requirement 2

## Quick Start
Step-by-step instructions...

EOF

# Use skill-builder to validate
npx agentic-flow skills validate .claude/skills/my-custom-skill/SKILL.md

✓ YAML frontmatter valid
✓ Name field present (64 char max)
✓ Description field present (1024 char max)
✓ Markdown structure valid
✓ Skill ready to use

Use skill-builder to create a skill for microservice architecture design.
Include service boundaries, communication patterns, and observability.
Base it on our Node.js + Docker + Kubernetes stack.

Creating "Microservice Architecture Design" skill...

✓ Analyzing domain: microservices, Node.js, K8s
✓ Loading template: advanced (multi-agent coordination)
✓ Generating sections:
  - Service boundary patterns
  - Communication strategies (sync/async)
  - Observability stack (logs, metrics, traces)
  - Deployment patterns
  - Testing strategies
✓ Adding tech-specific examples (Node.js, Docker, K8s)
✓ Validating against Claude Skills specification

Created: .claude/skills/microservice-architecture-design/SKILL.md

Use skill-builder to create a microservice testing skill.
Cover unit, integration, contract, and E2E testing.

.claude/skills/microservice-testing-patterns/SKILL.md

Design and implement a payment microservice with complete test coverage.

Use skill-builder to create a React performance optimization skill.
Make it learn from each optimization and improve recommendations.

---
name: "React Performance Optimization"
description: "Adaptive React optimization with learning from past improvements.
Uses ReasoningBank to remember successful patterns."
---

# React Performance Optimization

## Quick Start

### 1. Profile Current Performance
\`\`\`javascript
// ReasoningBank checks: Have we optimized similar components?
const priorOptimizations = await reasoningbank.queryPatterns('react-perf', {
  componentType: 'data-table',
  sortBy: 'impact'
});

// Apply learned patterns automatically
if (priorOptimizations.length > 0) {
  console.log('Applying learned patterns:', priorOptimizations[0].approach);
}
\`\`\`

### 2. Apply Optimizations
[Skill guides through optimizations...]

### 3. Store Results
\`\`\`javascript
// After optimization, record results
await reasoningbank.storePattern({
  domain: 'react-perf',
  componentType: 'data-table',
  approach: 'virtualization + memoization',
  metrics: {
    beforeFPS: 15,
    afterFPS: 60,
    improvement: '4x'
  },
  success: true
});
\`\`\`

Optimize this React data table component.

---
name: "Full-Stack E-Commerce Platform"
description: "Build complete e-commerce platform coordinating multiple skills."
---

# Full-Stack E-Commerce Platform

## Skill Dependencies
This meta-skill orchestrates:
1. `microservice-architecture-design` - Backend services
2. `react-performance-optimization` - Frontend performance
3. `agentdb-vector-search` - Product search
4. `swarm-orchestration` - Multi-agent coordination
5. `reasoningbank-intelligence` - Pattern learning

## Execution Flow
1. **Architecture Phase** (microservice-architecture-design)
   - Design service boundaries
   - Define communication patterns
   - Plan data consistency strategy

2. **Implementation Phase** (swarm-orchestration)
   - Spawn: Backend team (payment, catalog, user services)
   - Spawn: Frontend team (React components)
   - Spawn: Testing team (contract + E2E tests)
   - Coordinate via AgentDB shared memory

3. **Optimization Phase** (react-performance-optimization, agentdb-vector-search)
   - Optimize product catalog rendering
   - Implement semantic product search
   - Add intelligent recommendations

4. **Learning Phase** (reasoningbank-intelligence)
   - Store successful patterns
   - Record performance metrics
   - Prepare for next e-commerce project

Build an e-commerce platform for selling digital products.

// After each execution, store metrics
await reasoningbank.recordExecution({
  skill: 'graphql-api-design',
  task: 'user-service-schema',
  approach: 'federation with dataloaders',
  metrics: {
    executionTime: '2.3s',
    queryComplexity: 'optimized',
    resolverEfficiency: '98%'
  },
  success: true,
  feedback: 'Excellent performance, will use this pattern again'
});

// Next time: Skill adapts based on learned patterns

# 1. Create team-specific skills in project directory
cd /your-project
npx agentic-flow skills init  # Creates .claude/skills/

# 2. Generate team skills with skill-builder
# Ask Claude Code:
"Use skill-builder to create our team's API design standards skill.
Include our preferred patterns: REST with OpenAPI, JWT auth,
cursor pagination, and error handling standards."

# 3. Commit to version control
git add .claude/skills/
git commit -m "feat: Add team API design standards skill"
git push origin main

# 4. Team members pull and use automatically
git pull
# Claude Code discovers team skills on next run

# 1. Copy the sample skill
cp -r .claude/skills/agentdb-vector-search \
      .claude/skills/agentdb-python-search

# 2. Edit and customize
code .claude/skills/agentdb-python-search/SKILL.md

---
name: "AgentDB Vector Search (Python)"
description: "Semantic vector search with AgentDB for Python projects.
150x-12,500x performance improvement. Use for RAG systems and semantic search."
---

# AgentDB Vector Search (Python)

## Quick Start

### 1. Installation
\`\`\`bash
pip install agentdb
\`\`\`

### 2. Initialize
\`\`\`python
from agentdb import AgentDB

db = AgentDB(
    mode='python',
    vector_dimensions=384,
    enable_optimizations=True
)
\`\`\`

### 3. Index Documents
\`\`\`python
# Generate embeddings
from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2')

docs = load_documents('./docs/**/*.md')
for doc in docs:
    embedding = model.encode(doc.content)
    db.vector_db.insert(
        embedding=embedding,
        metadata={
            'id': doc.id,
            'title': doc.title,
            'content': doc.content
        }
    )
\`\`\`

### 4. Semantic Search
\`\`\`python
query = "How do I implement authentication?"
query_embedding = model.encode(query)

results = db.vector_db.search(
    query_embedding,
    k=10,
    threshold=0.7
)

for result in results:
    print(f"{result.score:.2f} - {result.metadata['title']}")
\`\`\`

Implement semantic search for our Python documentation.

# 1. Create organization skill repository
git clone https://github.com/your-org/claude-skills.git ~/.claude/skills-org

# 2. Symlink org skills to personal directory
ln -s ~/.claude/skills-org/* ~/.claude/skills/

# 3. Keep skills updated
cd ~/.claude/skills-org
git pull

# Now all org skills available in all projects!

~/.claude/skills-org/
  ├── security/
  │   ├── owasp-top-10/SKILL.md
  │   └── security-review/SKILL.md
  ├── api-design/
  │   ├── rest-standards/SKILL.md
  │   └── graphql-patterns/SKILL.md
  ├── testing/
  │   ├── unit-testing/SKILL.md
  │   └── e2e-testing/SKILL.md
  └── deployment/
      ├── kubernetes-deploy/SKILL.md
      └── ci-cd-pipeline/SKILL.md

# 1. Create skill package
mkdir agentic-flow-skills-web3
cd agentic-flow-skills-web3

# 2. Package structure
cat > package.json << 'EOF'
{
  "name": "agentic-flow-skills-web3",
  "version": "1.0.0",
  "description": "Claude Code skills for Web3 development",
  "keywords": ["agentic-flow", "claude-code", "skills", "web3"],
  "files": ["skills/"],
  "scripts": {
    "postinstall": "mkdir -p ~/.claude/skills && cp -r skills/* ~/.claude/skills/"
  }
}
EOF

# 3. Add your skills
mkdir -p skills/
cp -r .claude/skills/solidity-patterns skills/
cp -r .claude/skills/smart-contract-security skills/

# 4. Publish
npm publish

# 5. Users install with:
npm install -g agentic-flow-skills-web3
# Skills automatically copied to ~/.claude/skills/

---
name: "Code Formatter"
description: "Format code with Prettier/ESLint standards."
---

# Code Formatter

## What This Skill Does
Applies consistent code formatting.

## When to Use
- Before committing code
- Enforcing team standards

## Quick Start
[Basic formatting commands...]

## Examples
[2-3 code examples]

## Learn More
[Links to docs]

---
name: "API Design Patterns"
description: "Design REST/GraphQL APIs following industry best practices."
---

# API Design Patterns

## What This Skill Does
[Detailed description]

## When to Use
[5+ use cases]

## Prerequisites
[Requirements]

## Quick Start
[Getting started]

## Step-by-Step Guide
[Detailed walkthrough]

## Advanced Patterns
[Complex scenarios]

## Best Practices
[Industry standards]

## Common Pitfalls
[What to avoid]

## Troubleshooting
[Solutions to common issues]

## Examples
[10+ real-world examples]

## Reference
[Complete API docs]

## Learn More
[External resources]

---
name: "Full-Stack Application Builder"
description: "Coordinate multiple agents to build complete applications."
---

# Full-Stack Application Builder

## What This Skill Does
[Orchestration overview]

## Skill Dependencies
- backend-api-design
- frontend-react-patterns
- database-optimization
- testing-frameworks
- deployment-automation

## Multi-Agent Coordination
[How agents collaborate]

## Prerequisites
[Tech stack requirements]

## Architecture Overview
[System design patterns]

## Phase 1: Planning
[Requirements analysis]

## Phase 2: Backend Development
[API implementation with coordination]

## Phase 3: Frontend Development
[UI implementation with coordination]

## Phase 4: Integration
[Connecting frontend + backend]

## Phase 5: Testing
[Comprehensive test strategy]

## Phase 6: Deployment
[CI/CD pipeline]

## Agent Communication Patterns
[How agents share context via AgentDB]

## Learning & Optimization
[ReasoningBank integration]

## Monitoring & Observability
[Performance tracking]

## Troubleshooting
[Debug multi-agent issues]

## Examples
[Complete application examples]

bash .claude/skills/skill-builder/scripts/validate-skill.sh my-skill/SKILL.md

🔍 Validating: microservice-patterns/SKILL.md
═══════════════════════════════════════════════

✓ YAML frontmatter: Valid
  - name: "Microservice Patterns" (21 chars)
  - description: 487 chars (max 1024)

✓ Markdown structure: Valid
  - 12 sections
  - Proper heading hierarchy
  - 18 code blocks

✓ Progressive disclosure: Excellent
  - Quick Start: 5 min read
  - Step-by-Step: 15 min
  - Advanced: 30+ min

✓ Code examples: 18 found
  - All have syntax highlighting
  - All runnable

✓ Security: No issues

✅ Skill ready for use!

Next steps:
  1. Test with Claude Code
  2. Share with team (git commit)
  3. Publish to npm (optional)

bash .claude/skills/skill-builder/scripts/generate-skill.sh

🎨 agentic-flow Skill Generator
═══════════════════════════════════════

Let's create a new skill!

Skill name: Database Query Optimization
Description: Optimize SQL queries with indexing, query
             planning, and performance analysis.

Category:
  1. api-design
  2. testing
  3. database       ← Selected
  4. documentation
  5. custom

Template:
  1. minimal        (Quick reference)
  2. full-featured  ← Selected (Comprehensive guide)
  3. advanced       (Multi-agent coordination)

Include sections:
  [✓] Quick Start
  [✓] Prerequisites
  [✓] Step-by-Step Guide
  [✓] Examples (how many? 10)
  [✓] Best Practices
  [✓] Troubleshooting
  [ ] Advanced Patterns (optional)

Generate code examples?
  Technology: PostgreSQL
  Examples: [indexes, query plans, EXPLAIN ANALYZE]

✓ Generating skill...
✓ Adding 10 examples...
✓ Validating...
✓ Success!

Created: .claude/skills/database-query-optimization/SKILL.md

Test it:
  "Optimize this slow database query: SELECT * FROM users..."

bash .claude/skills/skill-builder/scripts/batch-generate.sh skills.yaml

skills:
  - name: "API Authentication"
    description: "JWT, OAuth2, and session-based auth patterns"
    template: full-featured
    category: api-design

  - name: "React Component Library"
    description: "Build reusable React components"
    template: full-featured
    category: frontend

  - name: "Docker Compose Workflows"
    description: "Multi-container development environments"
    template: minimal
    category: devops

🎨 Batch Skill Generator
═══════════════════════════════════════

Processing 3 skills...

✓ [1/3] API Authentication
✓ [2/3] React Component Library
✓ [3/3] Docker Compose Workflows

All skills created successfully!

Skills available:
  • api-authentication
  • react-component-library
  • docker-compose-workflows

Test them with Claude Code!

bash .claude/skills/skill-builder/scripts/test-skill.sh \
     database-query-optimization/SKILL.md

🧪 Testing Skill: database-query-optimization
═══════════════════════════════════════════════

Test 1: Discovery
  Query: "List installed skills"
  ✓ Skill appears in list

Test 2: Activation
  Query: "Optimize this slow query"
  ✓ Skill automatically activated

Test 3: Execution
  Query: "Add index to speed up user lookups"
  ✓ Provided correct guidance
  ✓ Generated runnable SQL
  ✓ Explained trade-offs

Test 4: Learning
  ✓ Pattern stored in AgentDB
  ✓ Confidence score: 0.92

Test 5: Repeated Use
  Query: "Optimize another user query"
  ✓ Applied learned patterns
  ✓ 38% faster than first execution

✅ All tests passed!

Skill performance:
  - Activation rate: 95%
  - Correctness: 100%
  - Learning improvement: 38%

✅ Good: "GraphQL API Design"
❌ Bad: "gql" or "api_design_123"

✅ Good: "React Component Patterns"
❌ Bad: "ReactStuff"

✅ Good:
description: "Design GraphQL APIs with schema-first development,
efficient resolvers, and federation. Use when building or
refactoring GraphQL services."

❌ Bad:
description: "GraphQL stuff"

✅ Good Structure:
## Quick Start (5 minutes)
Basic usage

## Step-by-Step Guide (15 minutes)
Detailed walkthrough

## Advanced Patterns (30+ minutes)
Complex scenarios

## Reference
Complete API docs

✅ Good:
await reasoningbank.storePattern({
  skill: 'api-design',
  pattern: 'pagination',
  approach: 'cursor-based',
  performance: 'excellent'
});

❌ Bad:
// No learning loop, patterns forgotten

✅ Good:
# Reference other skills
See also: `agentdb-vector-search`, `swarm-orchestration`

❌ Bad:
# Duplicate instructions from other skills

# 1. Verify skill location (MUST be top level!)
ls ~/.claude/skills/          # Personal
ls .claude/skills/            # Project

# Should see: my-skill/SKILL.md
# NOT: subdirectory/my-skill/SKILL.md

# 2. Validate YAML frontmatter
npx agentic-flow skills validate .claude/skills/my-skill/SKILL.md

# 3. Restart Claude Code
# Skills are loaded at startup

# 4. Check file permissions
chmod 644 .claude/skills/my-skill/SKILL.md

# 1. Check skill description matches use case
npx agentic-flow skills list

# 2. Add debugging context
await reasoningbank.debug({
  skill: 'my-skill',
  context: 'What am I trying to do?',
  expected: 'What should happen?',
  actual: 'What actually happened?'
});

# 3. Review skill instructions
cat .claude/skills/my-skill/SKILL.md

# Make descriptions more specific
❌ description: "Build APIs"
✅ description: "Build REST APIs with Express and TypeScript.
                Use for traditional RESTful services, not GraphQL."

# Install and setup MCP server
npm install -g claude-flow@alpha
claude mcp add claude-flow npx claude-flow@alpha mcp start

# Verify 21 skills are available
claude mcp list

# Skills auto-discovered by Claude Code - no additional setup!

# Initialize skill directories
npx agentic-flow skills init

# Create 4 sample skills
npx agentic-flow skills create

# List all skills (built-in + custom)
npx agentic-flow skills list

# Install skill builder framework
npx agentic-flow skills init-builder

# Validate custom skill
npx agentic-flow skills validate <path>

# Install both systems
npm install -g claude-flow@alpha agentic-flow@latest

# Setup MCP servers
claude mcp add claude-flow npx claude-flow@alpha mcp start

# Create custom skills
npx agentic-flow skills init
npx agentic-flow skills create

# Now you have:
# ✅ 21 built-in claude-flow skills
# ✅ 4 sample agentic-flow skills
# ✅ 213+ MCP coordination tools
# ✅ 54 specialized agents
# ✅ Custom skill creation framework

User: "Implement semantic search"
→ agentdb-vector-search skill (built-in)
→ Done in minutes

User: "Build REST API with tests and deploy"
→ sparc-methodology (planning)
→ swarm-orchestration (parallel dev)
→ agentdb-memory-patterns (coordination)
→ github-workflow-automation (CI/CD)
→ verification-quality (validation)
→ reasoningbank-intelligence (learning)
→ Complete production-ready system

1. Use claude-flow built-in: swarm-orchestration
2. Create custom: your-company-api-standards (agentic-flow)
3. Combine: Company-specific development with best practices
4. Learn: Patterns stored for 46% faster next time

# Full installation (recommended)
npm install -g claude-flow@alpha agentic-flow@latest

# Setup MCP server for built-in skills
claude mcp add claude-flow npx claude-flow@alpha mcp start

# Create custom skills
npx agentic-flow skills init
npx agentic-flow skills create
npx agentic-flow skills init-builder

# You now have access to:
# ✅ 21 claude-flow built-in skills
# ✅ 4 agentic-flow sample skills
# ✅ 213+ MCP coordination tools
# ✅ 54 specialized agents
# ✅ Custom skill creation framework
# ✅ AgentDB vector memory
# ✅ ReasoningBank pattern learning
# ✅ SPARC methodology
# ✅ Complete GitHub integration

# Ready to build production AI systems! 🎯