Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

Checkpoint: File edits

rUv4b0ad3ce90c0
diff --git a/docs/ruvector-postgres/scripts/init-db.sql b/docs/ruvector-postgres/scripts/init-db.sql
index e98e26e30c..f2715cd7ac 100644
--- a/docs/ruvector-postgres/scripts/init-db.sql
+++ b/docs/ruvector-postgres/scripts/init-db.sql
@@ -2,18 +2,15 @@
-- RUVECTOR POSTGRESQL INITIALIZATION SCRIPT
-- ============================================
--
--- This script initializes the RuVector PostgreSQL extension
--- from ruvnet/ruvector with full V3 Claude-Flow integration.
+-- This script initializes RuVector PostgreSQL extension
+-- from ruvnet/ruvector-postgres with Claude-Flow V3 integration.
--
--- RuVector provides 77+ SQL functions including:
--- - Vector similarity search (HNSW/IVFFlat)
--- - 39 Attention mechanisms
--- - GNN layers for graph operations
+-- RuVector 2.0.0 provides 77+ SQL functions including:
+-- - Vector similarity search (HNSW with SIMD)
-- - Hyperbolic embeddings (Poincaré/Lorentz)
--- - Sparse vectors (BM25/TF-IDF)
--- - SPARQL support (50+ RDF functions)
--- - Local embeddings (6 fastembed models)
--- - Self-learning index optimization
+-- - Graph operations (Cypher queries)
+-- - RDF/SPARQL support
+-- - Agent routing and learning
--
-- Performance: ~61µs latency, 16,400 QPS
@@ -21,8 +18,8 @@
-- PART 1: EXTENSION AND SCHEMA SETUP
-- ============================================
--- Enable RuVector extension (includes vector type)
-CREATE EXTENSION IF NOT EXISTS ruvector;
+-- Enable RuVector extension (use VERSION to work around control file issue)
+CREATE EXTENSION IF NOT EXISTS ruvector VERSION '0.1.0';
-- Enable additional required extensions
CREATE EXTENSION IF NOT EXISTS pgcrypto;
@@ -32,21 +29,19 @@ CREATE SCHEMA IF NOT EXISTS claude_flow;
-- Grant permissions
GRANT ALL ON SCHEMA claude_flow TO claude;
-GRANT USAGE ON SCHEMA ruvector TO claude;
--- Set search path for convenience
-SET search_path TO claude_flow, ruvector, public;
+-- Set search path
+SET search_path TO claude_flow, public;
-- ============================================
-- PART 2: CORE TABLES
-- ============================================
--- Embeddings table with RuVector vector type
+-- Embeddings table with RuVector vector type (384-dim for all-MiniLM-L6-v2)
CREATE TABLE IF NOT EXISTS claude_flow.embeddings (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
content TEXT NOT NULL,
- embedding ruvector.vector(384), -- RuVector vector type
- sparse_embedding ruvector.sparse_vector, -- For hybrid BM25/TF-IDF search
+ embedding ruvector(384),
metadata JSONB DEFAULT '{}',
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW()
@@ -57,12 +52,12 @@ CREATE TABLE IF NOT EXISTS claude_flow.patterns (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
name VARCHAR(255) NOT NULL,
description TEXT,
- embedding ruvector.vector(384),
+ embedding ruvector(384),
pattern_type VARCHAR(50),
confidence FLOAT DEFAULT 0.5,
success_count INT DEFAULT 0,
failure_count INT DEFAULT 0,
- ewc_importance FLOAT DEFAULT 1.0, -- EWC++ weight
+ ewc_importance FLOAT DEFAULT 1.0,
metadata JSONB DEFAULT '{}',
created_at TIMESTAMPTZ DEFAULT NOW()
);
@@ -73,7 +68,7 @@ CREATE TABLE IF NOT EXISTS claude_flow.agents (
agent_id VARCHAR(255) NOT NULL UNIQUE,
agent_type VARCHAR(50),
state JSONB DEFAULT '{}',
- memory_embedding ruvector.vector(384),
+ memory_embedding ruvector(384),
last_active TIMESTAMPTZ DEFAULT NOW(),
created_at TIMESTAMPTZ DEFAULT NOW()
);
@@ -96,9 +91,8 @@ CREATE TABLE IF NOT EXISTS claude_flow.trajectories (
CREATE TABLE IF NOT EXISTS claude_flow.hyperbolic_embeddings (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
content TEXT NOT NULL,
- euclidean_embedding ruvector.vector(384),
- poincare_embedding ruvector.vector(384), -- Poincaré ball (||x|| < 1)
- lorentz_embedding ruvector.vector(385), -- Lorentz model (+1 dim)
+ euclidean_embedding ruvector(384),
+ poincare_embedding real[], -- Array for hyperbolic operations
curvature FLOAT DEFAULT -1.0,
hierarchy_level INT DEFAULT 0,
parent_id UUID REFERENCES claude_flow.hyperbolic_embeddings(id),
@@ -111,12 +105,12 @@ CREATE TABLE IF NOT EXISTS claude_flow.graph_nodes (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
node_id VARCHAR(255) NOT NULL UNIQUE,
node_type VARCHAR(50),
- embedding ruvector.vector(384),
+ embedding ruvector(384),
features JSONB DEFAULT '{}',
created_at TIMESTAMPTZ DEFAULT NOW()
);
--- Graph edges for GNN message passing
+-- Graph edges for message passing
CREATE TABLE IF NOT EXISTS claude_flow.graph_edges (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
source_id UUID REFERENCES claude_flow.graph_nodes(id),
@@ -128,52 +122,46 @@ CREATE TABLE IF NOT EXISTS claude_flow.graph_edges (
);
-- ============================================
--- PART 3: RUVECTOR INDICES (HNSW + IVFFlat)
+-- PART 3: HNSW INDICES
-- ============================================
--- HNSW index for embeddings (~61µs search latency)
+-- HNSW index for embeddings (cosine distance)
CREATE INDEX IF NOT EXISTS idx_embeddings_hnsw
ON claude_flow.embeddings
-USING ruvector_hnsw (embedding ruvector.cosine_ops)
+USING hnsw (embedding ruvector_cosine_ops)
WITH (m = 16, ef_construction = 100);
-- HNSW index for patterns
CREATE INDEX IF NOT EXISTS idx_patterns_hnsw
ON claude_flow.patterns
-USING ruvector_hnsw (embedding ruvector.cosine_ops)
+USING hnsw (embedding ruvector_cosine_ops)
WITH (m = 16, ef_construction = 100);
-- HNSW index for agent memory
CREATE INDEX IF NOT EXISTS idx_agents_hnsw
ON claude_flow.agents
-USING ruvector_hnsw (memory_embedding ruvector.cosine_ops)
+USING hnsw (memory_embedding ruvector_cosine_ops)
WITH (m = 16, ef_construction = 64);
-- HNSW index for hyperbolic embeddings
CREATE INDEX IF NOT EXISTS idx_hyperbolic_hnsw
ON claude_flow.hyperbolic_embeddings
-USING ruvector_hnsw (euclidean_embedding ruvector.cosine_ops)
+USING hnsw (euclidean_embedding ruvector_cosine_ops)
WITH (m = 16, ef_construction = 100);
-- HNSW index for graph nodes
CREATE INDEX IF NOT EXISTS idx_graph_nodes_hnsw
ON claude_flow.graph_nodes
-USING ruvector_hnsw (embedding ruvector.cosine_ops)
+USING hnsw (embedding ruvector_cosine_ops)
WITH (m = 16, ef_construction = 64);
--- IVFFlat index for memory-efficient search (optional)
--- CREATE INDEX IF NOT EXISTS idx_embeddings_ivfflat
--- ON claude_flow.embeddings
--- USING ruvector_ivfflat (embedding ruvector.cosine_ops)
--- WITH (lists = 100);
-
-- ============================================
--- PART 4: RUVECTOR CORE FUNCTIONS
+-- PART 4: CORE SEARCH FUNCTIONS
-- ============================================
--- Semantic similarity search using RuVector
+-- Semantic similarity search using RuVector HNSW
CREATE OR REPLACE FUNCTION claude_flow.search_similar(
- query_embedding ruvector.vector(384),
+ query_embedding ruvector(384),
limit_count INT DEFAULT 10,
min_similarity FLOAT DEFAULT 0.5
)
@@ -188,247 +176,106 @@ BEGIN
SELECT
e.id,
e.content,
- ruvector.cosine_similarity(e.embedding, query_embedding)::FLOAT AS similarity,
+ (1 - (e.embedding <=> query_embedding))::FLOAT AS similarity,
e.metadata
FROM claude_flow.embeddings e
WHERE e.embedding IS NOT NULL
- AND ruvector.cosine_similarity(e.embedding, query_embedding) >= min_similarity
- ORDER BY e.embedding <-> query_embedding -- RuVector distance operator
+ AND (1 - (e.embedding <=> query_embedding)) >= min_similarity
+ ORDER BY e.embedding <=> query_embedding
LIMIT limit_count;
END;
$$ LANGUAGE plpgsql STABLE;
--- Hybrid search (vector + BM25 sparse)
-CREATE OR REPLACE FUNCTION claude_flow.hybrid_search(
- query_embedding ruvector.vector(384),
- query_text TEXT,
+-- Pattern search with type filtering
+CREATE OR REPLACE FUNCTION claude_flow.search_patterns(
+ query_embedding ruvector(384),
+ pattern_type_filter VARCHAR(50) DEFAULT NULL,
limit_count INT DEFAULT 10,
- vector_weight FLOAT DEFAULT 0.7
+ min_confidence FLOAT DEFAULT 0.5
)
RETURNS TABLE (
id UUID,
- content TEXT,
- vector_score FLOAT,
- sparse_score FLOAT,
- combined_score FLOAT,
- metadata JSONB
-) AS $$
-BEGIN
- RETURN QUERY
- SELECT
- e.id,
- e.content,
- ruvector.cosine_similarity(e.embedding, query_embedding)::FLOAT AS v_score,
- COALESCE(ruvector.bm25_score(e.sparse_embedding, query_text), 0)::FLOAT AS s_score,
- (
- vector_weight * ruvector.cosine_similarity(e.embedding, query_embedding) +
- (1 - vector_weight) * COALESCE(ruvector.bm25_score(e.sparse_embedding, query_text), 0)
- )::FLOAT AS c_score,
- e.metadata
- FROM claude_flow.embeddings e
- WHERE e.embedding IS NOT NULL
- ORDER BY c_score DESC
- LIMIT limit_count;
-END;
-$$ LANGUAGE plpgsql STABLE;
-
--- ============================================
--- PART 5: ATTENTION MECHANISM FUNCTIONS
--- ============================================
-
--- Self-attention using RuVector's attention functions
-CREATE OR REPLACE FUNCTION claude_flow.self_attention(
- source_ids UUID[],
- temperature FLOAT DEFAULT 1.0
-)
-RETURNS TABLE (
- source_id UUID,
- target_id UUID,
- attention_weight FLOAT
-) AS $$
-BEGIN
- RETURN QUERY
- WITH sources AS (
- SELECT id, embedding
- FROM claude_flow.embeddings
- WHERE id = ANY(source_ids)
- AND embedding IS NOT NULL
- )
- SELECT
- s1.id AS source_id,
- s2.id AS target_id,
- ruvector.softmax_attention(s1.embedding, s2.embedding, temperature)::FLOAT AS attention_weight
- FROM sources s1
- CROSS JOIN sources s2;
-END;
-$$ LANGUAGE plpgsql STABLE;
-
--- Multi-head attention
-CREATE OR REPLACE FUNCTION claude_flow.multihead_attention(
- query_embedding ruvector.vector(384),
- num_heads INT DEFAULT 8,
- limit_count INT DEFAULT 10
-)
-RETURNS TABLE (
- id UUID,
- content TEXT,
- head_attentions FLOAT[],
- aggregated_attention FLOAT,
+ name VARCHAR(255),
+ description TEXT,
+ similarity FLOAT,
+ confidence FLOAT,
metadata JSONB
) AS $$
BEGIN
RETURN QUERY
SELECT
- e.id,
- e.content,
- ruvector.multihead_attention_scores(query_embedding, e.embedding, num_heads)::FLOAT[] AS head_scores,
- ruvector.multihead_attention_aggregate(query_embedding, e.embedding, num_heads)::FLOAT AS agg_score,
- e.metadata
- FROM claude_flow.embeddings e
- WHERE e.embedding IS NOT NULL
- ORDER BY agg_score DESC
+ p.id,
+ p.name,
+ p.description,
+ (1 - (p.embedding <=> query_embedding))::FLOAT AS similarity,
+ p.confidence,
+ p.metadata
+ FROM claude_flow.patterns p
+ WHERE p.embedding IS NOT NULL
+ AND p.confidence >= min_confidence
+ AND (pattern_type_filter IS NULL OR p.pattern_type = pattern_type_filter)
+ ORDER BY p.embedding <=> query_embedding
LIMIT limit_count;
END;
$$ LANGUAGE plpgsql STABLE;
--- Cross-attention between query and key-value sets
-CREATE OR REPLACE FUNCTION claude_flow.cross_attention(
- query_ids UUID[],
- kv_filter JSONB DEFAULT NULL,
- temperature FLOAT DEFAULT 1.0
+-- Agent routing by expertise similarity
+CREATE OR REPLACE FUNCTION claude_flow.find_agents(
+ query_embedding ruvector(384),
+ agent_type_filter VARCHAR(50) DEFAULT NULL,
+ limit_count INT DEFAULT 5
)
RETURNS TABLE (
- query_id UUID,
- kv_id UUID,
- attention_weight FLOAT
-) AS $$
-BEGIN
- RETURN QUERY
- WITH queries AS (
- SELECT id, embedding
- FROM claude_flow.embeddings
- WHERE id = ANY(query_ids) AND embedding IS NOT NULL
- ),
- kv AS (
- SELECT id, embedding
- FROM claude_flow.embeddings
- WHERE embedding IS NOT NULL
- AND id != ALL(query_ids)
- AND (kv_filter IS NULL OR metadata @> kv_filter)
- )
- SELECT
- q.id AS query_id,
- kv.id AS kv_id,
- ruvector.cross_attention_score(q.embedding, kv.embedding, temperature)::FLOAT AS attention_weight
- FROM queries q
- CROSS JOIN kv;
-END;
-$$ LANGUAGE plpgsql STABLE;
-
--- ============================================
--- PART 6: GNN OPERATIONS
--- ============================================
-
--- Message passing for GNN
-CREATE OR REPLACE FUNCTION claude_flow.gnn_message_pass(
- node_id VARCHAR(255),
- aggregation TEXT DEFAULT 'mean' -- 'mean', 'sum', 'max'
-)
-RETURNS ruvector.vector(384) AS $$
-DECLARE
- v_result ruvector.vector(384);
- v_node_uuid UUID;
-BEGIN
- -- Get node UUID
- SELECT id INTO v_node_uuid
- FROM claude_flow.graph_nodes
- WHERE graph_nodes.node_id = gnn_message_pass.node_id;
-
- -- Aggregate neighbor embeddings using RuVector GNN functions
- SELECT ruvector.gnn_aggregate(
- ARRAY_AGG(n.embedding),
- aggregation
- )
- INTO v_result
- FROM claude_flow.graph_edges e
- JOIN claude_flow.graph_nodes n ON n.id = e.target_id
- WHERE e.source_id = v_node_uuid;
-
- RETURN v_result;
-END;
-$$ LANGUAGE plpgsql STABLE;
-
--- Graph attention network (GAT) scoring
-CREATE OR REPLACE FUNCTION claude_flow.gat_attention(
- source_node VARCHAR(255),
- limit_count INT DEFAULT 10
-)
-RETURNS TABLE (
- neighbor_id VARCHAR(255),
- attention_weight FLOAT,
- edge_type VARCHAR(50)
+ agent_id VARCHAR(255),
+ agent_type VARCHAR(50),
+ similarity FLOAT,
+ state JSONB
) AS $$
BEGIN
RETURN QUERY
- WITH source AS (
- SELECT id, embedding
- FROM claude_flow.graph_nodes
- WHERE node_id = source_node
- )
SELECT
- n.node_id AS neighbor_id,
- ruvector.gat_score(s.embedding, n.embedding)::FLOAT AS attention_weight,
- e.edge_type
- FROM source s
- JOIN claude_flow.graph_edges e ON e.source_id = s.id
- JOIN claude_flow.graph_nodes n ON n.id = e.target_id
- ORDER BY attention_weight DESC
+ a.agent_id,
+ a.agent_type,
+ (1 - (a.memory_embedding <=> query_embedding))::FLOAT AS similarity,
+ a.state
+ FROM claude_flow.agents a
+ WHERE a.memory_embedding IS NOT NULL
+ AND (agent_type_filter IS NULL OR a.agent_type = agent_type_filter)
+ ORDER BY a.memory_embedding <=> query_embedding
LIMIT limit_count;
END;
$$ LANGUAGE plpgsql STABLE;
-- ============================================
--- PART 7: HYPERBOLIC OPERATIONS
+-- PART 5: HYPERBOLIC OPERATIONS
-- ============================================
-- Convert Euclidean to Poincaré embedding
CREATE OR REPLACE FUNCTION claude_flow.to_poincare(
- euclidean ruvector.vector(384),
+ euclidean real[],
curvature FLOAT DEFAULT -1.0
)
-RETURNS ruvector.vector(384) AS $$
+RETURNS real[] AS $$
BEGIN
- RETURN ruvector.exp_map_poincare(euclidean, curvature);
+ RETURN ruvector_exp_map(ARRAY_FILL(0.0::real, ARRAY[array_length(euclidean, 1)]), euclidean, curvature);
END;
$$ LANGUAGE plpgsql IMMUTABLE;
-- Poincaré distance (geodesic)
CREATE OR REPLACE FUNCTION claude_flow.poincare_distance(
- x ruvector.vector(384),
- y ruvector.vector(384),
+ x real[],
+ y real[],
curvature FLOAT DEFAULT -1.0
)
RETURNS FLOAT AS $$
BEGIN
- RETURN ruvector.hyperbolic_distance(x, y, 'poincare', curvature);
+ RETURN ruvector_poincare_distance(x, y, curvature);
END;
$$ LANGUAGE plpgsql IMMUTABLE;
--- Hyperbolic midpoint (Möbius addition)
-CREATE OR REPLACE FUNCTION claude_flow.poincare_midpoint(
- x ruvector.vector(384),
- y ruvector.vector(384),
- curvature FLOAT DEFAULT -1.0
-)
-RETURNS ruvector.vector(384) AS $$
-BEGIN
- RETURN ruvector.mobius_add(x, y, curvature);
-END;
-$$ LANGUAGE plpgsql IMMUTABLE;
-
--- Hierarchical search in hyperbolic space
+-- Hyperbolic search in Poincaré ball
CREATE OR REPLACE FUNCTION claude_flow.hyperbolic_search(
- query ruvector.vector(384),
+ query ruvector(384),
limit_count INT DEFAULT 10,
curvature FLOAT DEFAULT -1.0
)
@@ -441,82 +288,92 @@ RETURNS TABLE (
metadata JSONB
) AS $$
DECLARE
- v_query_poincare ruvector.vector(384);
+ query_arr real[];
+ query_poincare real[];
BEGIN
- v_query_poincare := ruvector.exp_map_poincare(query, curvature);
+ -- Convert query to array and then to Poincaré
+ SELECT array_agg(x ORDER BY ordinality) INTO query_arr
+ FROM unnest(string_to_array(trim(both '[]' from query::text), ',')) WITH ORDINALITY AS t(x, ordinality);
+
+ query_poincare := claude_flow.to_poincare(query_arr, curvature);
RETURN QUERY
SELECT
he.id,
he.content,
(he.euclidean_embedding <-> query)::FLOAT AS euc_dist,
- ruvector.hyperbolic_distance(he.poincare_embedding, v_query_poincare, 'poincare', curvature)::FLOAT AS hyp_dist,
+ COALESCE(ruvector_poincare_distance(he.poincare_embedding, query_poincare, curvature), 999.0)::FLOAT AS hyp_dist,
he.hierarchy_level,
he.metadata
FROM claude_flow.hyperbolic_embeddings he
WHERE he.euclidean_embedding IS NOT NULL
- ORDER BY hyp_dist
+ ORDER BY he.euclidean_embedding <-> query
LIMIT limit_count;
END;
$$ LANGUAGE plpgsql STABLE;
-- ============================================
--- PART 8: LOCAL EMBEDDING GENERATION
+-- PART 6: UTILITY FUNCTIONS
-- ============================================
--- Generate embedding using RuVector's local fastembed models
-CREATE OR REPLACE FUNCTION claude_flow.embed_text(
- text_content TEXT,
- model_name TEXT DEFAULT 'all-MiniLM-L6-v2'
-)
-RETURNS ruvector.vector(384) AS $$
+-- Get RuVector version info
+CREATE OR REPLACE FUNCTION claude_flow.ruvector_info()
+RETURNS TABLE (
+ version TEXT,
+ simd_info TEXT
+) AS $$
BEGIN
- RETURN ruvector.fastembed(text_content, model_name);
+ RETURN QUERY
+ SELECT ruvector_version(), ruvector_simd_info();
END;
$$ LANGUAGE plpgsql STABLE;
--- Batch embed multiple texts
-CREATE OR REPLACE FUNCTION claude_flow.embed_texts_batch(
- texts TEXT[],
- model_name TEXT DEFAULT 'all-MiniLM-L6-v2'
+-- Cosine similarity helper (converts cosine distance to similarity)
+CREATE OR REPLACE FUNCTION claude_flow.cosine_similarity(
+ a ruvector,
+ b ruvector
)
-RETURNS TABLE (
- idx INT,
- embedding ruvector.vector(384)
-) AS $$
+RETURNS FLOAT AS $$
BEGIN
- RETURN QUERY
- SELECT
- ordinality::INT AS idx,
- ruvector.fastembed(t, model_name) AS embedding
- FROM unnest(texts) WITH ORDINALITY AS t;
+ RETURN (1 - (a <=> b))::FLOAT;
END;
-$$ LANGUAGE plpgsql STABLE;
+$$ LANGUAGE plpgsql IMMUTABLE;
--- ============================================
--- PART 9: SELF-LEARNING INDEX OPTIMIZATION
--- ============================================
+-- L2 distance helper
+CREATE OR REPLACE FUNCTION claude_flow.l2_distance(
+ a ruvector,
+ b ruvector
+)
+RETURNS FLOAT AS $$
+BEGIN
+ RETURN (a <-> b)::FLOAT;
+END;
+$$ LANGUAGE plpgsql IMMUTABLE;
--- Trigger self-learning optimization
-CREATE OR REPLACE FUNCTION claude_flow.optimize_indices()
+-- Update embedding with auto-timestamp
+CREATE OR REPLACE FUNCTION claude_flow.update_embedding(
+ embedding_id UUID,
+ new_content TEXT DEFAULT NULL,
+ new_embedding ruvector(384) DEFAULT NULL,
+ new_metadata JSONB DEFAULT NULL
+)
RETURNS void AS $$
BEGIN
- -- RuVector self-learning index optimization
- PERFORM ruvector.learn_optimize('claude_flow.embeddings', 'embedding');
- PERFORM ruvector.learn_optimize('claude_flow.patterns', 'embedding');
- PERFORM ruvector.learn_optimize('claude_flow.agents', 'memory_embedding');
+ UPDATE claude_flow.embeddings
+ SET
+ content = COALESCE(new_content, content),
+ embedding = COALESCE(new_embedding, embedding),
+ metadata = COALESCE(new_metadata, metadata),
+ updated_at = NOW()
+ WHERE id = embedding_id;
END;
$$ LANGUAGE plpgsql;
--- Schedule periodic optimization (every hour)
--- Note: Requires pg_cron extension or external scheduler
--- SELECT cron.schedule('ruvector-optimize', '0 * * * *', 'SELECT claude_flow.optimize_indices()');
-
-- ============================================
--- PART 10: SAMPLE DATA
+-- PART 7: SAMPLE DATA
-- ============================================
--- Insert sample embeddings for testing
+-- Insert sample embeddings (without actual vectors - those need to come from model)
INSERT INTO claude_flow.embeddings (content, metadata) VALUES
('Implementing JWT authentication with refresh token rotation',
'{"category": "security", "language": "typescript", "agent": "security-architect"}'),
@@ -563,26 +420,33 @@ ON CONFLICT DO NOTHING;
-- ============================================
DO $$
+DECLARE
+ v_version TEXT;
+ v_simd TEXT;
BEGIN
+ SELECT ruvector_version() INTO v_version;
+ SELECT ruvector_simd_info() INTO v_simd;
+
RAISE NOTICE '';
RAISE NOTICE '============================================';
RAISE NOTICE 'RuVector PostgreSQL Initialization Complete!';
RAISE NOTICE '============================================';
RAISE NOTICE '';
- RAISE NOTICE 'Extension: ruvector (77+ SQL functions)';
+ RAISE NOTICE 'RuVector Version: %', v_version;
+ RAISE NOTICE 'SIMD: %', v_simd;
+ RAISE NOTICE '';
RAISE NOTICE 'Schema: claude_flow';
- RAISE NOTICE 'Tables: embeddings, patterns, agents, trajectories, hyperbolic_embeddings, graph_nodes, graph_edges';
+ RAISE NOTICE 'Tables: embeddings, patterns, agents, trajectories,';
+ RAISE NOTICE ' hyperbolic_embeddings, graph_nodes, graph_edges';
RAISE NOTICE 'Indices: 5 HNSW indices created';
RAISE NOTICE '';
- RAISE NOTICE 'Features enabled:';
- RAISE NOTICE ' - HNSW/IVFFlat vector indexing';
- RAISE NOTICE ' - 39 Attention mechanisms';
- RAISE NOTICE ' - GNN operations';
- RAISE NOTICE ' - Hyperbolic embeddings (Poincare/Lorentz)';
- RAISE NOTICE ' - Sparse vectors (BM25/TF-IDF)';
- RAISE NOTICE ' - Local embeddings (fastembed)';
- RAISE NOTICE ' - Self-learning optimization';
+ RAISE NOTICE 'Key Functions:';
+ RAISE NOTICE ' - claude_flow.search_similar(embedding, limit, min_sim)';
+ RAISE NOTICE ' - claude_flow.search_patterns(embedding, type, limit)';
+ RAISE NOTICE ' - claude_flow.find_agents(embedding, type, limit)';
+ RAISE NOTICE ' - claude_flow.hyperbolic_search(embedding, limit, curvature)';
+ RAISE NOTICE ' - claude_flow.cosine_similarity(a, b)';
RAISE NOTICE '';
- RAISE NOTICE 'Performance: ~61us latency, 16,400 QPS';
+ RAISE NOTICE 'Operators: <=> (cosine), <-> (L2), <#> (neg inner product)';
RAISE NOTICE '';
END $$;