@ruvector/agentic Integration

@ruvector/agentic-integration

Distributed agent coordination layer connecting RuVector vector databases with AI agent frameworks. Provides task routing, shared vector memory, agent-to-agent communication, and integration with claude-flow orchestration.

Quick Command Reference

Installation

Install: npx @ruvector/agentic-integration@latest See Installation Guide for hub details.

Core API

AgentCoordinator

Central orchestration hub for multi-agent systems.

import { AgentCoordinator, VectorMemory, TaskRouter } from '@ruvector/agentic-integration';

const coordinator = new AgentCoordinator({
  memory: { dimensions: 1536, metric: 'cosine' },
  maxAgents: 10,
  taskTimeout: 30_000,
  routingStrategy: 'capability',
});

CoordinatorConfig:

Register Agents

coordinator.registerAgent({
  id: 'researcher',
  capabilities: ['search', 'summarize'],
  model: 'claude-sonnet-4-5-20250929',
  maxConcurrent: 3,
  priority: 10,
});

coordinator.registerAgent({
  id: 'coder',
  capabilities: ['code', 'debug', 'test'],
  model: 'claude-sonnet-4-5-20250929',
});

Dispatch Tasks

const result = await coordinator.dispatch({
  description: 'Implement user authentication',
  requiredCapabilities: ['code'],
  context: relevantDocs,
  priority: 5,
});
console.log(`Assigned to: ${result.assignee}`);
console.log(`Duration: ${result.duration}ms`);

Shared Vector Memory

// Store knowledge
await coordinator.memory.store('auth-pattern', embedding, {
  text: 'JWT with refresh tokens for auth',
  source: 'coder',
});

// Search shared memory
const relevant = await coordinator.memory.search(queryEmbedding, 5);

// Get specific entry
const entry = await coordinator.memory.get('auth-pattern');

// Delete entry
await coordinator.memory.delete('auth-pattern');

Task Router

const router = new TaskRouter({
  strategy: 'capability',
  fallback: 'round-robin',
});

router.addRule({ capability: 'code', preferAgent: 'coder' });
router.addRule({ capability: 'search', preferAgent: 'researcher' });

Claude Flow Integration

coordinator.connectClaudeFlow({
  endpoint: 'http://localhost:3000',
  namespace: 'production',
});

Common Patterns

Agentic RAG Pipeline

const coordinator = new AgentCoordinator({
  memory: { dimensions: 1536, metric: 'cosine' },
});

coordinator.registerAgent({ id: 'retriever', capabilities: ['search'] });
coordinator.registerAgent({ id: 'generator', capabilities: ['generate'] });

// Retriever finds context
const context = await coordinator.dispatch({
  description: 'Find authentication patterns',
  requiredCapabilities: ['search'],
});

// Generator uses context
const answer = await coordinator.dispatch({
  description: 'Generate auth implementation',
  requiredCapabilities: ['generate'],
  context: [context.output],
});

Multi-Agent Code Review

coordinator.registerAgent({ id: 'security', capabilities: ['security-audit'] });
coordinator.registerAgent({ id: 'style', capabilities: ['lint', 'format'] });
coordinator.registerAgent({ id: 'logic', capabilities: ['test', 'review'] });

const reviews = await Promise.all([
  coordinator.dispatch({ description: 'Security audit', requiredCapabilities: ['security-audit'] }),
  coordinator.dispatch({ description: 'Style check', requiredCapabilities: ['lint'] }),
  coordinator.dispatch({ description: 'Logic review', requiredCapabilities: ['review'] }),
]);

Events

coordinator.on('task:dispatched', (task, assignee) => { });
coordinator.on('task:completed', (task, result) => { });
coordinator.on('task:failed', (task, error) => { });
coordinator.on('agent:registered', (agentId) => { });
coordinator.on('agent:idle', (agentId) => { });
coordinator.on('memory:stored', (key) => { });

RAN DDD Context

Bounded Context: Agent Orchestration

References

• Command reference: See references/commands.md
• Full README
• npm