ruvector 0.1.49 → 0.1.51

package/HOOKS.md

@@ -0,0 +1,221 @@
+# RuVector Hooks for Claude Code
+
+Self-learning intelligence hooks that enhance Claude Code with Q-learning, vector memory, and automatic agent routing.
+
+## Quick Start
+
+```bash
+# Full setup: hooks + pretrain + optimized agents
+npx ruvector hooks init --pretrain --build-agents quality
+
+# Or step by step:
+npx ruvector hooks init          # Setup hooks
+npx ruvector hooks pretrain      # Analyze repository
+npx ruvector hooks build-agents  # Generate agent configs
+```
+
+## What It Does
+
+RuVector hooks integrate with Claude Code to provide:
+
+| Feature | Description |
+|---------|-------------|
+| **Agent Routing** | Suggests the best agent for each file type based on learned patterns |
+| **Co-edit Patterns** | Predicts "likely next files" from git history |
+| **Vector Memory** | Semantic recall of project context |
+| **Command Analysis** | Risk assessment for bash commands |
+| **Self-Learning** | Q-learning improves suggestions over time |
+
+## Commands
+
+### Initialization
+
+```bash
+# Full configuration
+npx ruvector hooks init
+
+# With pretrain and agent building
+npx ruvector hooks init --pretrain --build-agents security
+
+# Minimal (basic hooks only)
+npx ruvector hooks init --minimal
+
+# Options
+--force           # Overwrite existing settings
+--minimal         # Basic hooks only
+--pretrain        # Run pretrain after init
+--build-agents    # Generate optimized agents (quality|speed|security|testing|fullstack)
+--no-claude-md    # Skip CLAUDE.md creation
+--no-permissions  # Skip permissions config
+--no-env          # Skip environment variables
+--no-gitignore    # Skip .gitignore update
+--no-mcp          # Skip MCP server config
+--no-statusline   # Skip status line config
+```
+
+### Pretrain
+
+Analyze your repository to bootstrap intelligence:
+
+```bash
+npx ruvector hooks pretrain
+
+# Options
+--depth <n>     # Git history depth (default: 100)
+--verbose       # Show detailed progress
+--skip-git      # Skip git history analysis
+--skip-files    # Skip file structure analysis
+```
+
+**What it learns:**
+- File type → Agent mapping (`.rs` → rust-developer)
+- Co-edit patterns from git history
+- Directory → Agent mapping
+- Project context memories
+
+### Build Agents
+
+Generate optimized `.claude/agents/` configurations:
+
+```bash
+npx ruvector hooks build-agents --focus quality
+
+# Focus modes
+--focus quality   # Code quality, best practices (default)
+--focus speed     # Rapid development, prototyping
+--focus security  # OWASP, input validation, encryption
+--focus testing   # TDD, comprehensive coverage
+--focus fullstack # Balanced frontend/backend/database
+
+# Options
+--output <dir>    # Output directory (default: .claude/agents)
+--format <fmt>    # yaml, json, or md (default: yaml)
+--include-prompts # Include system prompts in agent configs
+```
+
+### Verification & Diagnostics
+
+```bash
+# Check if hooks are working
+npx ruvector hooks verify
+
+# Diagnose and fix issues
+npx ruvector hooks doctor
+npx ruvector hooks doctor --fix
+```
+
+### Data Management
+
+```bash
+# View statistics
+npx ruvector hooks stats
+
+# Export intelligence data
+npx ruvector hooks export -o backup.json
+npx ruvector hooks export --include-all
+
+# Import intelligence data
+npx ruvector hooks import backup.json
+npx ruvector hooks import backup.json --merge
+```
+
+### Memory Operations
+
+```bash
+# Store context in vector memory
+npx ruvector hooks remember "API uses JWT auth" -t project
+
+# Semantic search memory
+npx ruvector hooks recall "authentication"
+
+# Route a task to best agent
+npx ruvector hooks route "implement user login"
+```
+
+## Hook Events
+
+| Event | Trigger | RuVector Action |
+|-------|---------|-----------------|
+| **PreToolUse** | Before Edit/Write/Bash | Agent routing, file analysis, command risk |
+| **PostToolUse** | After Edit/Write/Bash | Q-learning update, pattern recording |
+| **SessionStart** | Conversation begins | Load intelligence, display stats |
+| **Stop** | Conversation ends | Save learning data |
+| **UserPromptSubmit** | User sends message | Context suggestions |
+| **PreCompact** | Before context compaction | Preserve important context |
+| **Notification** | Any notification | Track events for learning |
+
+## Generated Files
+
+After running `hooks init`:
+
+```
+your-project/
+├── .claude/
+│   ├── settings.json      # Hooks configuration
+│   ├── statusline.sh      # Status bar script
+│   └── agents/            # Generated agents (with --build-agents)
+│       ├── rust-specialist.yaml
+│       ├── typescript-specialist.yaml
+│       ├── test-architect.yaml
+│       └── project-coordinator.yaml
+├── .ruvector/
+│   └── intelligence.json  # Learning data
+├── CLAUDE.md              # Project documentation
+└── .gitignore             # Updated with .ruvector/
+```
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `RUVECTOR_INTELLIGENCE_ENABLED` | `true` | Enable/disable intelligence |
+| `RUVECTOR_LEARNING_RATE` | `0.1` | Q-learning rate (0.0-1.0) |
+| `RUVECTOR_MEMORY_BACKEND` | `rvlite` | Memory storage backend |
+| `INTELLIGENCE_MODE` | `treatment` | A/B testing mode |
+
+## Example Output
+
+### Agent Routing
+```
+🧠 Intelligence Analysis:
+   📁 src/api/routes.ts
+   🤖 Recommended: typescript-developer (85% confidence)
+      → learned from 127 .ts files in repo
+   📎 Likely next files:
+      - src/api/handlers.ts (12 co-edits)
+      - src/types/api.ts (8 co-edits)
+```
+
+### Command Analysis
+```
+🧠 Command Analysis:
+   📦 Category: rust
+   🏷️  Type: test
+   ✅ Risk: LOW
+```
+
+## Best Practices
+
+1. **Run pretrain on existing repos** — Bootstrap intelligence before starting work
+2. **Use focus modes** — Match agent generation to your current task
+3. **Export before major changes** — Backup learning data
+4. **Let it learn** — Intelligence improves with each edit
+
+## Troubleshooting
+
+```bash
+# Check setup
+npx ruvector hooks verify
+
+# Fix common issues
+npx ruvector hooks doctor --fix
+
+# Reset and reinitialize
+npx ruvector hooks init --force --pretrain
+```
+
+## Links
+
+- [RuVector GitHub](https://github.com/ruvnet/ruvector)
+- [npm Package](https://www.npmjs.com/package/ruvector)
+- [Claude Code Documentation](https://docs.anthropic.com/claude-code)

package/README.md

@@ -20,6 +20,26 @@ Built by [rUv](https://ruv.io) with production-grade Rust performance and intell
 
 ---
 
+## 🧠 Claude Code Hooks (NEW)
+
+**Self-learning intelligence for Claude Code** — RuVector provides optimized hooks that learn from your development patterns.
+
+```bash
+# One-command setup with pretrain and agent generation
+npx ruvector hooks init --pretrain --build-agents quality
+```
+
+**Features:**
+- 🎯 **Smart Agent Routing** — Automatically suggests the best agent for each file type
+- 📚 **Repository Pretrain** — Analyzes your codebase to bootstrap intelligence
+- 🤖 **Agent Builder** — Generates optimized `.claude/agents/` configs for your stack
+- 🔗 **Co-edit Patterns** — Learns which files are edited together from git history
+- 💾 **Vector Memory** — Semantic recall of project context
+
+📖 **[Full Hooks Documentation →](https://github.com/ruvnet/ruvector/blob/main/npm/packages/ruvector/HOOKS.md)**
+
+---
+
 ## 🌟 Why Ruvector?
 
 ### The Problem with Existing Vector Databases

package/bin/cli.js

@@ -3628,4 +3628,59 @@ ${focus.description}` : null
     console.log(chalk.dim(`\nFocus mode "${opts.focus}": ${focus.description}`));
   });
 
+// MCP Server command
+const mcpCmd = program.command('mcp').description('MCP (Model Context Protocol) server for Claude Code integration');
+
+mcpCmd.command('start')
+  .description('Start the RuVector MCP server')
+  .action(() => {
+    // Execute the mcp-server.js directly
+    const mcpServerPath = path.join(__dirname, 'mcp-server.js');
+    if (!fs.existsSync(mcpServerPath)) {
+      console.error(chalk.red('Error: MCP server not found at'), mcpServerPath);
+      process.exit(1);
+    }
+    require(mcpServerPath);
+  });
+
+mcpCmd.command('info')
+  .description('Show MCP server information and setup instructions')
+  .action(() => {
+    console.log(chalk.bold.cyan('\n🔌 RuVector MCP Server\n'));
+    console.log(chalk.white('The RuVector MCP server provides self-learning intelligence'));
+    console.log(chalk.white('tools to Claude Code via the Model Context Protocol.\n'));
+
+    console.log(chalk.bold('Available Tools:'));
+    console.log(chalk.dim('  hooks_stats      - Get intelligence statistics'));
+    console.log(chalk.dim('  hooks_route      - Route task to best agent'));
+    console.log(chalk.dim('  hooks_remember   - Store context in vector memory'));
+    console.log(chalk.dim('  hooks_recall     - Search vector memory'));
+    console.log(chalk.dim('  hooks_init       - Initialize hooks in project'));
+    console.log(chalk.dim('  hooks_pretrain   - Pretrain from repository'));
+    console.log(chalk.dim('  hooks_build_agents - Generate agent configs'));
+    console.log(chalk.dim('  hooks_verify     - Verify hooks configuration'));
+    console.log(chalk.dim('  hooks_doctor     - Diagnose setup issues'));
+    console.log(chalk.dim('  hooks_export     - Export intelligence data'));
+
+    console.log(chalk.bold('\n📦 Resources:'));
+    console.log(chalk.dim('  ruvector://intelligence/stats     - Current statistics'));
+    console.log(chalk.dim('  ruvector://intelligence/patterns  - Learned patterns'));
+    console.log(chalk.dim('  ruvector://intelligence/memories  - Vector memories'));
+
+    console.log(chalk.bold.yellow('\n⚙️  Setup Instructions:\n'));
+    console.log(chalk.white('Add to Claude Code:'));
+    console.log(chalk.cyan('  claude mcp add ruvector npx ruvector mcp start\n'));
+
+    console.log(chalk.white('Or add to .claude/settings.json:'));
+    console.log(chalk.dim(`  {
+    "mcpServers": {
+      "ruvector": {
+        "command": "npx",
+        "args": ["ruvector", "mcp", "start"]
+      }
+    }
+  }`));
+    console.log();
+  });
+
 program.parse();

package/bin/mcp-server.js

@@ -0,0 +1,581 @@
+#!/usr/bin/env node
+
+/**
+ * RuVector MCP Server
+ *
+ * Model Context Protocol server for RuVector hooks
+ * Provides self-learning intelligence tools for Claude Code
+ *
+ * Usage:
+ *   npx ruvector mcp start
+ *   claude mcp add ruvector npx ruvector mcp start
+ */
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+// Intelligence class (simplified from cli.js)
+class Intelligence {
+  constructor() {
+    this.intelPath = this.getIntelPath();
+    this.data = this.load();
+  }
+
+  getIntelPath() {
+    const projectPath = path.join(process.cwd(), '.ruvector', 'intelligence.json');
+    const homePath = path.join(require('os').homedir(), '.ruvector', 'intelligence.json');
+    if (fs.existsSync(path.dirname(projectPath))) return projectPath;
+    if (fs.existsSync(path.join(process.cwd(), '.claude'))) return projectPath;
+    if (fs.existsSync(homePath)) return homePath;
+    return projectPath;
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.intelPath)) {
+        return JSON.parse(fs.readFileSync(this.intelPath, 'utf-8'));
+      }
+    } catch {}
+    return { patterns: {}, memories: [], trajectories: [], errors: {}, agents: {}, edges: [] };
+  }
+
+  save() {
+    const dir = path.dirname(this.intelPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(this.intelPath, JSON.stringify(this.data, null, 2));
+  }
+
+  stats() {
+    return {
+      total_patterns: Object.keys(this.data.patterns || {}).length,
+      total_memories: (this.data.memories || []).length,
+      total_trajectories: (this.data.trajectories || []).length,
+      total_errors: Object.keys(this.data.errors || {}).length
+    };
+  }
+
+  embed(text) {
+    const embedding = new Array(64).fill(0);
+    for (let i = 0; i < text.length; i++) {
+      const idx = (text.charCodeAt(i) + i * 7) % 64;
+      embedding[idx] += 1.0;
+    }
+    const norm = Math.sqrt(embedding.reduce((a, b) => a + b * b, 0));
+    if (norm > 0) for (let i = 0; i < embedding.length; i++) embedding[i] /= norm;
+    return embedding;
+  }
+
+  similarity(a, b) {
+    if (!a || !b || a.length !== b.length) return 0;
+    const dot = a.reduce((sum, v, i) => sum + v * b[i], 0);
+    const normA = Math.sqrt(a.reduce((sum, v) => sum + v * v, 0));
+    const normB = Math.sqrt(b.reduce((sum, v) => sum + v * v, 0));
+    return normA > 0 && normB > 0 ? dot / (normA * normB) : 0;
+  }
+
+  remember(content, type = 'general') {
+    this.data.memories = this.data.memories || [];
+    this.data.memories.push({
+      content,
+      type,
+      created: new Date().toISOString(),
+      embedding: this.embed(content)
+    });
+    this.save();
+    return { stored: true, total: this.data.memories.length };
+  }
+
+  recall(query, topK = 5) {
+    const queryEmbed = this.embed(query);
+    const scored = (this.data.memories || []).map((m, i) => ({
+      ...m,
+      index: i,
+      score: this.similarity(queryEmbed, m.embedding)
+    }));
+    return scored.sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+
+  route(task, file = null) {
+    const ext = file ? path.extname(file) : '';
+    const state = `edit:${ext || 'unknown'}`;
+    const actions = this.data.patterns[state] || {};
+
+    // Default agent mapping
+    const defaults = {
+      '.rs': 'rust-developer',
+      '.ts': 'typescript-developer',
+      '.tsx': 'react-developer',
+      '.js': 'javascript-developer',
+      '.py': 'python-developer',
+      '.go': 'go-developer',
+      '.sql': 'database-specialist'
+    };
+
+    let bestAgent = defaults[ext] || 'coder';
+    let bestScore = 0.5;
+
+    for (const [agent, score] of Object.entries(actions)) {
+      if (score > bestScore) {
+        bestAgent = agent;
+        bestScore = score;
+      }
+    }
+
+    return {
+      agent: bestAgent,
+      confidence: Math.min(bestScore, 1.0),
+      reason: Object.keys(actions).length > 0 ? 'learned from patterns' : 'default mapping'
+    };
+  }
+}
+
+// Create MCP server
+const server = new Server(
+  {
+    name: 'ruvector',
+    version: '0.1.51',
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+    },
+  }
+);
+
+const intel = new Intelligence();
+
+// Define tools
+const TOOLS = [
+  {
+    name: 'hooks_stats',
+    description: 'Get RuVector intelligence statistics including learned patterns, memories, and trajectories',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'hooks_route',
+    description: 'Route a task to the best agent based on learned patterns',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        task: { type: 'string', description: 'Task description' },
+        file: { type: 'string', description: 'File path (optional)' }
+      },
+      required: ['task']
+    }
+  },
+  {
+    name: 'hooks_remember',
+    description: 'Store context in vector memory for later recall',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Content to remember' },
+        type: { type: 'string', description: 'Memory type (project, code, decision, context)', default: 'general' }
+      },
+      required: ['content']
+    }
+  },
+  {
+    name: 'hooks_recall',
+    description: 'Search vector memory for relevant context',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        top_k: { type: 'number', description: 'Number of results', default: 5 }
+      },
+      required: ['query']
+    }
+  },
+  {
+    name: 'hooks_init',
+    description: 'Initialize RuVector hooks in the current project',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pretrain: { type: 'boolean', description: 'Run pretrain after init', default: false },
+        build_agents: { type: 'string', description: 'Focus for agent generation (quality, speed, security, testing, fullstack)' },
+        force: { type: 'boolean', description: 'Force overwrite existing settings', default: false }
+      },
+      required: []
+    }
+  },
+  {
+    name: 'hooks_pretrain',
+    description: 'Pretrain intelligence by analyzing the repository structure and git history',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        depth: { type: 'number', description: 'Git history depth to analyze', default: 100 },
+        skip_git: { type: 'boolean', description: 'Skip git history analysis', default: false },
+        verbose: { type: 'boolean', description: 'Show detailed progress', default: false }
+      },
+      required: []
+    }
+  },
+  {
+    name: 'hooks_build_agents',
+    description: 'Generate optimized agent configurations based on repository analysis',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        focus: {
+          type: 'string',
+          description: 'Focus type for agent generation',
+          enum: ['quality', 'speed', 'security', 'testing', 'fullstack'],
+          default: 'quality'
+        },
+        include_prompts: { type: 'boolean', description: 'Include system prompts in agent configs', default: true }
+      },
+      required: []
+    }
+  },
+  {
+    name: 'hooks_verify',
+    description: 'Verify that hooks are configured correctly',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: 'hooks_doctor',
+    description: 'Diagnose and optionally fix setup issues',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        fix: { type: 'boolean', description: 'Automatically fix issues', default: false }
+      },
+      required: []
+    }
+  },
+  {
+    name: 'hooks_export',
+    description: 'Export intelligence data for backup',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        include_all: { type: 'boolean', description: 'Include all data (patterns, memories, trajectories)', default: false }
+      },
+      required: []
+    }
+  }
+];
+
+// List tools handler
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools: TOOLS };
+});
+
+// Call tool handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'hooks_stats': {
+        const stats = intel.stats();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              stats,
+              intel_path: intel.intelPath
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'hooks_route': {
+        const result = intel.route(args.task, args.file);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              task: args.task,
+              file: args.file,
+              ...result
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'hooks_remember': {
+        const result = intel.remember(args.content, args.type || 'general');
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              ...result
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'hooks_recall': {
+        const results = intel.recall(args.query, args.top_k || 5);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              query: args.query,
+              results: results.map(r => ({
+                content: r.content,
+                type: r.type,
+                score: r.score.toFixed(3),
+                created: r.created
+              }))
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'hooks_init': {
+        let cmd = 'npx ruvector hooks init';
+        if (args.force) cmd += ' --force';
+        if (args.pretrain) cmd += ' --pretrain';
+        if (args.build_agents) cmd += ` --build-agents ${args.build_agents}`;
+
+        try {
+          const output = execSync(cmd, { encoding: 'utf-8', timeout: 60000 });
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: true, output }, null, 2)
+            }]
+          };
+        } catch (e) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: false, error: e.message }, null, 2)
+            }]
+          };
+        }
+      }
+
+      case 'hooks_pretrain': {
+        let cmd = 'npx ruvector hooks pretrain';
+        if (args.depth) cmd += ` --depth ${args.depth}`;
+        if (args.skip_git) cmd += ' --skip-git';
+        if (args.verbose) cmd += ' --verbose';
+
+        try {
+          const output = execSync(cmd, { encoding: 'utf-8', timeout: 120000 });
+          // Reload intelligence after pretrain
+          intel.data = intel.load();
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                output,
+                new_stats: intel.stats()
+              }, null, 2)
+            }]
+          };
+        } catch (e) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: false, error: e.message }, null, 2)
+            }]
+          };
+        }
+      }
+
+      case 'hooks_build_agents': {
+        let cmd = 'npx ruvector hooks build-agents';
+        if (args.focus) cmd += ` --focus ${args.focus}`;
+        if (args.include_prompts) cmd += ' --include-prompts';
+
+        try {
+          const output = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: true, output }, null, 2)
+            }]
+          };
+        } catch (e) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: false, error: e.message }, null, 2)
+            }]
+          };
+        }
+      }
+
+      case 'hooks_verify': {
+        try {
+          const output = execSync('npx ruvector hooks verify', { encoding: 'utf-8', timeout: 15000 });
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: true, output }, null, 2)
+            }]
+          };
+        } catch (e) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: false, error: e.message, output: e.stdout }, null, 2)
+            }]
+          };
+        }
+      }
+
+      case 'hooks_doctor': {
+        let cmd = 'npx ruvector hooks doctor';
+        if (args.fix) cmd += ' --fix';
+
+        try {
+          const output = execSync(cmd, { encoding: 'utf-8', timeout: 15000 });
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: true, output }, null, 2)
+            }]
+          };
+        } catch (e) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ success: false, error: e.message }, null, 2)
+            }]
+          };
+        }
+      }
+
+      case 'hooks_export': {
+        const exportData = {
+          version: '1.0',
+          exported_at: new Date().toISOString(),
+          patterns: intel.data.patterns || {},
+          memories: args.include_all ? (intel.data.memories || []) : [],
+          trajectories: args.include_all ? (intel.data.trajectories || []) : [],
+          errors: intel.data.errors || {},
+          stats: intel.stats()
+        };
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ success: true, data: exportData }, null, 2)
+          }]
+        };
+      }
+
+      default:
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ success: false, error: `Unknown tool: ${name}` }, null, 2)
+          }],
+          isError: true
+        };
+    }
+  } catch (error) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ success: false, error: error.message }, null, 2)
+      }],
+      isError: true
+    };
+  }
+});
+
+// Resources - expose intelligence data
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return {
+    resources: [
+      {
+        uri: 'ruvector://intelligence/stats',
+        name: 'Intelligence Stats',
+        description: 'Current RuVector intelligence statistics',
+        mimeType: 'application/json'
+      },
+      {
+        uri: 'ruvector://intelligence/patterns',
+        name: 'Learned Patterns',
+        description: 'Q-learning patterns for agent routing',
+        mimeType: 'application/json'
+      },
+      {
+        uri: 'ruvector://intelligence/memories',
+        name: 'Vector Memories',
+        description: 'Stored context memories',
+        mimeType: 'application/json'
+      }
+    ]
+  };
+});
+
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+
+  switch (uri) {
+    case 'ruvector://intelligence/stats':
+      return {
+        contents: [{
+          uri,
+          mimeType: 'application/json',
+          text: JSON.stringify(intel.stats(), null, 2)
+        }]
+      };
+
+    case 'ruvector://intelligence/patterns':
+      return {
+        contents: [{
+          uri,
+          mimeType: 'application/json',
+          text: JSON.stringify(intel.data.patterns || {}, null, 2)
+        }]
+      };
+
+    case 'ruvector://intelligence/memories':
+      return {
+        contents: [{
+          uri,
+          mimeType: 'application/json',
+          text: JSON.stringify((intel.data.memories || []).map(m => ({
+            content: m.content,
+            type: m.type,
+            created: m.created
+          })), null, 2)
+        }]
+      };
+
+    default:
+      throw new Error(`Unknown resource: ${uri}`);
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('RuVector MCP server running on stdio');
+}
+
+main().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -52,6 +52,7 @@
     "directory": "npm/packages/ruvector"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
     "@ruvector/core": "^0.1.25",
     "@ruvector/attention": "^0.1.3",
     "@ruvector/gnn": "^0.1.22",