+------------------------------------------------------------------+
|                        Claude Code / MCP Client                   |
+------------------------------------------------------------------+
                                |
                                | MCP Protocol (stdio/HTTP/WebSocket)
                                v
+------------------------------------------------------------------+
|                    Claude-Flow v3 MCP Server                      |
|  +------------------------------------------------------------+  |
|  |                 RuVector PostgreSQL Bridge                  |  |
|  |  +----------------+  +----------------+  +---------------+  |  |
|  |  | Connection     |  | Tool           |  | Query         |  |  |
|  |  | Pool Manager   |  | Registry       |  | Executor      |  |  |
|  |  +----------------+  +----------------+  +---------------+  |  |
|  +------------------------------------------------------------+  |
+------------------------------------------------------------------+
                                |
                                | pg Protocol (libpq/node-postgres)
                                v
+------------------------------------------------------------------+
|                    PostgreSQL + RuVector Extensions               |
|  +------------------+  +------------------+  +----------------+   |
|  | pg_ruvector      |  | pg_ruvector_gnn  |  | pg_ruvector    |   |
|  | (vectors)        |  | (graph ops)      |  | _attention     |   |
|  +------------------+  +------------------+  +----------------+   |
+------------------------------------------------------------------+

@claude-flow/plugins/src/integrations/ruvector/
|
+-- index.ts                    # Plugin entry point & exports
+-- plugin.ts                   # Main plugin class (extends BasePlugin)
+-- ARCHITECTURE.md             # This document
|
+-- core/
|   +-- connection-manager.ts   # PostgreSQL connection pooling
|   +-- query-executor.ts       # Query execution with metrics
|   +-- schema-manager.ts       # Extension & schema management
|   +-- types.ts                # Core type definitions
|
+-- sql/
|   +-- index.ts                # SQL function registry
|   +-- vector-functions.ts     # 15+ vector similarity functions
|   +-- graph-functions.ts      # 12+ graph-aware query functions
|   +-- pattern-functions.ts    # 10+ pattern matching functions
|   +-- index-functions.ts      # 8+ index management functions
|   +-- aggregate-functions.ts  # 8+ vector aggregation functions
|
+-- attention/
|   +-- index.ts                # Attention mechanism registry
|   +-- multi-head.ts           # Multi-head attention (8 variants)
|   +-- self-attention.ts       # Self-attention (6 variants)
|   +-- cross-attention.ts      # Cross-attention (5 variants)
|   +-- sparse-attention.ts     # Sparse attention (10 variants)
|   +-- linear-attention.ts     # Linear attention (5 variants)
|   +-- flash-attention.ts      # Flash Attention v2 integration
|   +-- types.ts                # Attention type definitions
|
+-- gnn/
|   +-- index.ts                # GNN layer registry
|   +-- graph-conv.ts           # Graph convolution layers
|   +-- message-passing.ts      # Message passing networks
|   +-- node-embeddings.ts      # Node embedding generation
|   +-- edge-embeddings.ts      # Edge embedding generation
|   +-- pooling.ts              # Graph pooling operations
|   +-- types.ts                # GNN type definitions
|
+-- hyperbolic/
|   +-- index.ts                # Hyperbolic embedding registry
|   +-- poincare.ts             # Poincare ball model
|   +-- lorentz.ts              # Lorentz (hyperboloid) model
|   +-- distance.ts             # Distance calculations
|   +-- operations.ts           # Mobius operations
|   +-- types.ts                # Hyperbolic type definitions
|
+-- learning/
|   +-- index.ts                # Self-learning registry
|   +-- query-optimizer.ts      # Query plan optimization
|   +-- index-tuner.ts          # Index parameter tuning
|   +-- pattern-recognizer.ts   # Pattern recognition engine
|   +-- statistics-collector.ts # Usage statistics collection
|   +-- types.ts                # Learning type definitions
|
+-- mcp/
|   +-- index.ts                # MCP tool registration
|   +-- vector-tools.ts         # Vector operation tools
|   +-- attention-tools.ts      # Attention mechanism tools
|   +-- gnn-tools.ts            # GNN operation tools
|   +-- hyperbolic-tools.ts     # Hyperbolic embedding tools
|   +-- admin-tools.ts          # Administration tools

/**
 * PostgreSQL Connection Pool Manager
 *
 * Manages connection lifecycle, health checks, and load balancing
 * for PostgreSQL instances with RuVector extensions.
 */
interface IConnectionManager {
  // Connection lifecycle
  initialize(config: ConnectionConfig): Promise<void>;
  shutdown(): Promise<void>;

  // Connection acquisition
  acquire(): Promise<PooledConnection>;
  release(connection: PooledConnection): void;

  // Health monitoring
  healthCheck(): Promise<HealthCheckResult>;
  getStats(): ConnectionPoolStats;

  // Extension management
  ensureExtensions(): Promise<ExtensionStatus[]>;
}

interface ConnectionConfig {
  host: string;
  port: number;
  database: string;
  user: string;
  password: string;
  ssl?: SSLConfig;
  pool: {
    min: number;           // Default: 2
    max: number;           // Default: 10
    idleTimeout: number;   // Default: 30000ms
    acquireTimeout: number; // Default: 5000ms
  };
  extensions: {
    ruvector: boolean;
    ruvector_gnn?: boolean;
    ruvector_attention?: boolean;
  };
}

/**
 * Query Executor with Metrics Collection
 *
 * Executes SQL queries with timing, caching, and error handling.
 */
interface IQueryExecutor {
  // Query execution
  execute<T>(query: string, params?: unknown[]): Promise<QueryResult<T>>;
  executeMany<T>(queries: BatchQuery[]): Promise<QueryResult<T>[]>;

  // Prepared statements
  prepare(name: string, query: string): Promise<PreparedStatement>;
  executePrepared<T>(name: string, params?: unknown[]): Promise<QueryResult<T>>;

  // Transaction support
  beginTransaction(): Promise<Transaction>;

  // Metrics
  getQueryStats(): QueryStatistics;
  resetStats(): void;
}

interface QueryResult<T> {
  rows: T[];
  rowCount: number;
  fields: FieldInfo[];
  duration: number;
  fromCache: boolean;
}

interface VectorFunctions {
  // Similarity/Distance
  similarity(a: Float32Array, b: Float32Array): Promise<number>;
  distance(a: Float32Array, b: Float32Array, metric: DistanceMetric): Promise<number>;

  // Operations
  normalize(v: Float32Array): Promise<Float32Array>;
  add(a: Float32Array, b: Float32Array): Promise<Float32Array>;
  subtract(a: Float32Array, b: Float32Array): Promise<Float32Array>;
  multiply(v: Float32Array, scalar: number): Promise<Float32Array>;

  // Transformations
  quantize(v: Float32Array, bits: 4 | 8 | 16): Promise<Uint8Array>;
  dequantize(data: Uint8Array, bits: 4 | 8 | 16): Promise<Float32Array>;
}

type DistanceMetric = 'euclidean' | 'cosine' | 'manhattan' | 'inner_product';

interface MultiHeadAttention {
  // Standard implementations
  standard(query: Tensor, key: Tensor, value: Tensor, config: MHAConfig): Promise<Tensor>;
  scaled(query: Tensor, key: Tensor, value: Tensor, config: MHAConfig): Promise<Tensor>;

  // Optimized variants
  flashAttention(query: Tensor, key: Tensor, value: Tensor, config: FlashConfig): Promise<Tensor>;
  memoryEfficient(query: Tensor, key: Tensor, value: Tensor, config: MEConfig): Promise<Tensor>;

  // Specialized variants
  rotary(query: Tensor, key: Tensor, value: Tensor, config: RoPEConfig): Promise<Tensor>;
  alibi(query: Tensor, key: Tensor, value: Tensor, config: ALiBiConfig): Promise<Tensor>;
  grouped(query: Tensor, key: Tensor, value: Tensor, config: GQAConfig): Promise<Tensor>;
  multiQuery(query: Tensor, key: Tensor, value: Tensor, config: MQAConfig): Promise<Tensor>;
}

interface MHAConfig {
  numHeads: number;
  headDim: number;
  dropout?: number;
  causal?: boolean;
  maxSeqLen?: number;
}

interface GraphConvolutionLayers {
  // Standard layers
  gcn(features: Tensor, adjacency: SparseTensor, weights: Tensor): Promise<Tensor>;
  graphSAGE(features: Tensor, adjacency: SparseTensor, config: SAGEConfig): Promise<Tensor>;
  gat(features: Tensor, adjacency: SparseTensor, config: GATConfig): Promise<Tensor>;
  gin(features: Tensor, adjacency: SparseTensor, config: GINConfig): Promise<Tensor>;

  // Advanced layers
  edgeConv(features: Tensor, edges: Tensor, config: EdgeConvConfig): Promise<Tensor>;
  gatv2(features: Tensor, adjacency: SparseTensor, config: GATv2Config): Promise<Tensor>;
  pna(features: Tensor, adjacency: SparseTensor, config: PNAConfig): Promise<Tensor>;
}

interface MessagePassingNetwork {
  // Core operations
  propagate(
    nodeFeatures: Tensor,
    edgeIndex: Tensor,
    edgeFeatures?: Tensor
  ): Promise<Tensor>;

  // Message functions
  message(source: Tensor, target: Tensor, edge?: Tensor): Promise<Tensor>;
  aggregate(messages: Tensor, index: Tensor, method: AggregateMethod): Promise<Tensor>;
  update(nodeFeatures: Tensor, aggregated: Tensor): Promise<Tensor>;
}

type AggregateMethod = 'sum' | 'mean' | 'max' | 'min' | 'attention' | 'lstm';

interface EmbeddingGenerator {
  // Node embeddings
  node2vec(adjacency: SparseTensor, config: Node2VecConfig): Promise<Tensor>;
  deepwalk(adjacency: SparseTensor, config: DeepWalkConfig): Promise<Tensor>;
  struc2vec(adjacency: SparseTensor, config: Struc2VecConfig): Promise<Tensor>;

  // Edge embeddings
  edgeEmbedding(nodeEmbeddings: Tensor, edgeIndex: Tensor, method: EdgeMethod): Promise<Tensor>;

  // Subgraph embeddings
  subgraphEmbedding(nodeEmbeddings: Tensor, subgraphNodes: number[]): Promise<Float32Array>;
}

type EdgeMethod = 'hadamard' | 'average' | 'l1' | 'l2' | 'concat';

interface PoincareBallOperations {
  // Core operations (curvature c = -1 default)
  expMap(v: Float32Array, base?: Float32Array): Promise<Float32Array>;
  logMap(point: Float32Array, base?: Float32Array): Promise<Float32Array>;

  // Distance
  distance(a: Float32Array, b: Float32Array): Promise<number>;

  // Mobius operations
  mobiusAdd(a: Float32Array, b: Float32Array): Promise<Float32Array>;
  mobiusScalarMul(r: number, v: Float32Array): Promise<Float32Array>;
  mobiusMatVecMul(M: Float32Array[], v: Float32Array): Promise<Float32Array>;

  // Transformations
  euclideanToPoincare(v: Float32Array): Promise<Float32Array>;
  poincareToEuclidean(v: Float32Array): Promise<Float32Array>;

  // Aggregation
  centroid(points: Float32Array[], weights?: number[]): Promise<Float32Array>;
  midpoint(a: Float32Array, b: Float32Array): Promise<Float32Array>;

  // Utilities
  norm(v: Float32Array): Promise<number>;
  project(v: Float32Array): Promise<Float32Array>;
  isInBall(v: Float32Array): Promise<boolean>;
}

interface LorentzModelOperations {
  // Core operations
  expMap(v: Float32Array, base?: Float32Array): Promise<Float32Array>;
  logMap(point: Float32Array, base?: Float32Array): Promise<Float32Array>;

  // Distance (Minkowski inner product based)
  distance(a: Float32Array, b: Float32Array): Promise<number>;
  minkowskiInnerProduct(a: Float32Array, b: Float32Array): Promise<number>;

  // Transformations
  lorentzToPoincare(v: Float32Array): Promise<Float32Array>;
  poincareToLorentz(v: Float32Array): Promise<Float32Array>;

  // Lorentz operations
  lorentzBoost(v: Float32Array, velocity: Float32Array): Promise<Float32Array>;
  parallelTransport(v: Float32Array, from: Float32Array, to: Float32Array): Promise<Float32Array>;

  // Utilities
  lorentzNorm(v: Float32Array): Promise<number>;
  projectToHyperboloid(v: Float32Array): Promise<Float32Array>;
}

interface QueryOptimizer {
  // Query analysis
  analyzeQuery(sql: string): Promise<QueryAnalysis>;
  suggestOptimizations(sql: string): Promise<Optimization[]>;

  // Learning
  recordExecution(query: string, plan: QueryPlan, duration: number): Promise<void>;
  learnFromHistory(): Promise<LearningReport>;

  // Optimization application
  rewrite(sql: string): Promise<string>;
  selectIndex(query: string, available: Index[]): Promise<Index | null>;
}

interface QueryAnalysis {
  complexity: 'low' | 'medium' | 'high';
  estimatedCost: number;
  bottlenecks: Bottleneck[];
  recommendations: string[];
  vectorOperations: VectorOperation[];
}

interface Optimization {
  type: 'index' | 'rewrite' | 'parallel' | 'cache';
  description: string;
  expectedSpeedup: number;
  sql?: string;
}

interface IndexTuner {
  // Analysis
  analyzeWorkload(queries: QueryLog[]): Promise<WorkloadAnalysis>;
  recommendIndexes(analysis: WorkloadAnalysis): Promise<IndexRecommendation[]>;

  // HNSW tuning
  tuneHNSW(indexName: string): Promise<HNSWParams>;
  estimateHNSWParams(dataSize: number, dimensions: number, queryPattern: QueryPattern): HNSWParams;

  // IVF tuning
  tuneIVF(indexName: string): Promise<IVFParams>;
  estimateIVFParams(dataSize: number, dimensions: number): IVFParams;

  // Monitoring
  monitorPerformance(indexName: string): Promise<PerformanceMetrics>;
}

interface HNSWParams {
  m: number;              // Max connections per layer (default: 16)
  efConstruction: number; // Construction search depth (default: 200)
  efSearch: number;       // Query search depth (default: 100)
  ml: number;            // Level multiplier (default: 1/ln(M))
}

interface PatternRecognizer {
  // Query pattern detection
  detectQueryPatterns(queries: Query[]): Promise<QueryPattern[]>;
  classifyQuery(sql: string): Promise<QueryClassification>;

  // Data pattern detection
  detectDataPatterns(vectors: Float32Array[]): Promise<DataPattern[]>;
  detectAnomalies(vectors: Float32Array[], threshold: number): Promise<Anomaly[]>;

  // Learning
  trainOnPatterns(patterns: Pattern[]): Promise<void>;
  predictPattern(query: string): Promise<PatternPrediction>;
}

interface QueryPattern {
  id: string;
  template: string;
  frequency: number;
  avgDuration: number;
  vectorOperations: string[];
}

+-------------+     +-----------------+     +------------------+
|   Client    |     |  RuVector       |     |   PostgreSQL     |
|   Request   | --> |  Bridge Plugin  | --> |   + RuVector     |
+-------------+     +-----------------+     +------------------+
      |                    |                        |
      | 1. MCP Tool Call   |                        |
      | (vector_search)    |                        |
      |                    |                        |
      |              2. Validate input              |
      |              3. Get connection              |
      |                    |                        |
      |                    | 4. Execute query       |
      |                    | SELECT * FROM items   |
      |                    | ORDER BY embedding    |
      |                    | <=> $1 LIMIT $2       |
      |                    |----------------------->|
      |                    |                        |
      |                    | 5. HNSW index scan    |
      |                    |<-----------------------|
      |                    |                        |
      |              6. Transform results          |
      |              7. Update metrics             |
      |<-------------------|                        |
      | 8. MCP Response    |                        |

+-------------+     +-----------------+     +------------------+
|   Input     |     |   Attention     |     |   PostgreSQL     |
|   Tensors   | --> |   Module        | --> |   UDF Execution  |
+-------------+     +-----------------+     +------------------+
      |                    |                        |
      | Q, K, V tensors    |                        |
      |                    |                        |
      |              1. Select variant              |
      |              2. Prepare parameters          |
      |                    |                        |
      |                    | 3. Execute UDF         |
      |                    | rv_attention_mha(      |
      |                    |   $Q, $K, $V, $config  |
      |                    | )                      |
      |                    |----------------------->|
      |                    |                        |
      |                    | 4. SIMD computation   |
      |                    | (in-database)         |
      |                    |<-----------------------|
      |                    |                        |
      |              5. Return attention output    |
      |<-------------------|                        |

+-------------+     +-----------------+     +------------------+
|   Query     |     |   Learning      |     |   Statistics     |
|   Execution | --> |   Module        | --> |   Storage        |
+-------------+     +-----------------+     +------------------+
      |                    |                        |
      | Query + Results    |                        |
      |                    |                        |
      |              1. Record execution           |
      |              2. Extract features           |
      |                    |                        |
      |                    | 3. Store statistics   |
      |                    |----------------------->|
      |                    |                        |
      |              4. Analyze patterns           |
      |              5. Update models              |
      |                    |                        |
      |              6. Generate recommendations   |
      |<-------------------|                        |

import { BasePlugin } from '@claude-flow/plugins';

export class RuVectorPostgreSQLBridgePlugin extends BasePlugin {
  // Metadata
  static readonly PLUGIN_NAME = 'ruvector-postgresql-bridge';
  static readonly VERSION = '1.0.0';

  // Components
  private connectionManager: ConnectionManager;
  private queryExecutor: QueryExecutor;
  private sqlFunctions: SQLFunctionRegistry;
  private attentionMechanisms: AttentionRegistry;
  private gnnLayers: GNNRegistry;
  private hyperbolicOps: HyperbolicRegistry;
  private learningEngine: LearningEngine;

  // Plugin lifecycle
  protected async onInitialize(): Promise<void>;
  protected async onShutdown(): Promise<void>;
  protected async onHealthCheck(): Promise<Record<string, HealthStatus>>;

  // Extension registration
  registerMCPTools(): MCPToolDefinition[];
  registerHooks(): HookDefinition[];
  registerAgentTypes(): AgentTypeDefinition[];
}

// Vector Operations Tools
interface VectorTools {
  'ruvector:search': {
    input: {
      query: number[];      // Query vector
      table: string;        // Table name
      column: string;       // Vector column
      k: number;           // Number of results
      metric?: string;      // Distance metric
      filter?: string;      // SQL WHERE clause
    };
    output: {
      results: Array<{
        id: string;
        score: number;
        metadata: Record<string, unknown>;
      }>;
      duration: number;
    };
  };

  'ruvector:index:create': {
    input: {
      table: string;
      column: string;
      type: 'hnsw' | 'ivf' | 'flat';
      params?: {
        m?: number;
        efConstruction?: number;
        lists?: number;
      };
    };
    output: {
      indexName: string;
      created: boolean;
    };
  };

  // ... 50+ more tools
}

// Attention Tools
interface AttentionTools {
  'ruvector:attention:mha': {
    input: {
      query: number[][];
      key: number[][];
      value: number[][];
      config: {
        numHeads: number;
        dropout?: number;
        causal?: boolean;
      };
    };
    output: {
      attention: number[][];
      weights?: number[][][];
    };
  };

  // ... more attention tools
}

// GNN Tools
interface GNNTools {
  'ruvector:gnn:propagate': {
    input: {
      features: number[][];
      edgeIndex: number[][];
      layer: 'gcn' | 'gat' | 'sage' | 'gin';
      config: Record<string, unknown>;
    };
    output: {
      features: number[][];
    };
  };

  // ... more GNN tools
}

interface RuVectorBridgeConfig {
  // Connection settings
  connection: {
    host: string;
    port: number;
    database: string;
    user: string;
    password: string;
    ssl?: {
      enabled: boolean;
      ca?: string;
      key?: string;
      cert?: string;
    };
  };

  // Pool settings
  pool: {
    min: number;
    max: number;
    idleTimeout: number;
    acquireTimeout: number;
    maxWaitingClients: number;
  };

  // Feature flags
  features: {
    vectorOperations: boolean;
    attentionMechanisms: boolean;
    gnnLayers: boolean;
    hyperbolicEmbeddings: boolean;
    selfLearning: boolean;
  };

  // Learning settings
  learning: {
    enabled: boolean;
    queryHistorySize: number;
    patternUpdateInterval: number;
    indexTuningEnabled: boolean;
  };

  // Performance settings
  performance: {
    queryTimeout: number;
    cacheEnabled: boolean;
    cacheTTL: number;
    maxBatchSize: number;
  };
}

interface SQLFunctionExtension {
  // Register custom function
  registerFunction(definition: CustomFunctionDefinition): void;

  // Function definition
  interface CustomFunctionDefinition {
    name: string;
    args: ArgDefinition[];
    returns: ReturnType;
    implementation: string;  // SQL or PL/pgSQL
    volatile?: boolean;
    parallel?: 'safe' | 'restricted' | 'unsafe';
  }
}

interface AttentionExtension {
  // Register custom attention
  registerAttention(definition: CustomAttentionDefinition): void;

  interface CustomAttentionDefinition {
    name: string;
    compute: (query: Tensor, key: Tensor, value: Tensor, config: unknown) => Promise<Tensor>;
    validateConfig: (config: unknown) => boolean;
    estimateComplexity: (seqLen: number, dim: number) => ComplexityEstimate;
  }
}

interface GNNExtension {
  // Register custom layer
  registerLayer(definition: CustomLayerDefinition): void;

  interface CustomLayerDefinition {
    name: string;
    message: (source: Tensor, target: Tensor, edge?: Tensor) => Tensor;
    aggregate: (messages: Tensor, index: Tensor) => Tensor;
    update: (node: Tensor, aggregated: Tensor) => Tensor;
  }
}

interface LearningExtension {
  // Register custom optimizer
  registerOptimizer(definition: CustomOptimizerDefinition): void;

  // Register custom tuner
  registerTuner(definition: CustomTunerDefinition): void;

  // Register custom pattern detector
  registerPatternDetector(definition: CustomPatternDetectorDefinition): void;
}

// Quantization levels and memory savings
const QUANTIZATION_SAVINGS = {
  'float32': { bits: 32, ratio: 1.0 },
  'float16': { bits: 16, ratio: 0.5 },
  'int8':    { bits: 8,  ratio: 0.25 },
  'int4':    { bits: 4,  ratio: 0.125 },
};

// Recommended quantization by use case
const QUANTIZATION_RECOMMENDATIONS = {
  'similarity_search': 'int8',    // 4x memory reduction, <2% recall loss
  'clustering': 'float16',        // 2x memory reduction, minimal loss
  'exact_match': 'float32',       // No quantization
  'approximate_nn': 'int4',       // 8x memory reduction, ~5% recall loss
};

+------------------------------------------+
|           Application Server             |
|  +------------------------------------+  |
|  |      Claude-Flow MCP Server        |  |
|  |  +------------------------------+  |  |
|  |  |   RuVector Bridge Plugin     |  |  |
|  |  +------------------------------+  |  |
|  +------------------------------------+  |
+------------------------------------------+
                    |
                    | pg protocol
                    v
+------------------------------------------+
|        PostgreSQL + RuVector             |
|        (Single Instance)                 |
+------------------------------------------+

+------------------------------------------+
|           Load Balancer                  |
+------------------------------------------+
         |              |              |
         v              v              v
+------------+  +------------+  +------------+
|  MCP       |  |  MCP       |  |  MCP       |
|  Server 1  |  |  Server 2  |  |  Server 3  |
+------------+  +------------+  +------------+
         |              |              |
         +-------+------+-------+------+
                 |              |
                 v              v
         +------------+  +------------+
         |  Primary   |  |  Replica   |
         |  PostgreSQL|  |  PostgreSQL|
         |  + RuVector|  |  + RuVector|
         +------------+  +------------+

+------------------------------------------+
|           Global Load Balancer           |
+------------------------------------------+
         |                      |
         v                      v
+------------------+   +------------------+
|    Region A      |   |    Region B      |
| +-------------+  |   | +-------------+  |
| |  MCP Pool   |  |   | |  MCP Pool   |  |
| +-------------+  |   | +-------------+  |
|       |          |   |       |          |
|       v          |   |       v          |
| +-------------+  |   | +-------------+  |
| |  PG Cluster |  |   | |  PG Cluster |  |
| |  (Citus)    |  |   | |  (Citus)    |  |
| +-------------+  |   | +-------------+  |
+------------------+   +------------------+

// Structured log format
interface LogEntry {
  timestamp: string;
  level: 'debug' | 'info' | 'warn' | 'error';
  module: string;
  message: string;
  context: {
    queryId?: string;
    duration?: number;
    rowCount?: number;
    error?: string;
  };
}

-- Convert pgvector to ruvector
ALTER TABLE items
  ALTER COLUMN embedding TYPE ruvector
  USING embedding::ruvector;

-- Rebuild indexes
DROP INDEX IF EXISTS items_embedding_idx;
CREATE INDEX items_embedding_idx ON items
  USING ruvector_hnsw (embedding ruvector_cosine_ops)
  WITH (m = 16, ef_construction = 200);

// Migrate from AgentDB to PostgreSQL
async function migrate(agentDB: AgentDBBridge, pgBridge: RuVectorBridge) {
  const entries = await agentDB.listAll();

  for (const entry of entries) {
    await pgBridge.insert({
      id: entry.id,
      vector: entry.vector,
      metadata: entry.metadata,
    });
  }
}