🌊 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
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
Checkpoint: File edits
rUve2b79c955cd3
diff --git a/docs/ruvector-postgres/examples/attention-ops.sql b/docs/ruvector-postgres/examples/attention-ops.sqlnew file mode 100644index 0000000000..28219d1291--- /dev/null+++ b/docs/ruvector-postgres/examples/attention-ops.sql@@ -0,0 +1,499 @@+-- RuVector PostgreSQL Attention Operations+-- Optimized for Claude-Flow V3 Neural Features+--+-- Implements attention mechanisms in SQL for:+-- - Self-attention (query = key = value)+-- - Multi-head attention+-- - Cross-attention+-- - Flash attention patterns++-- ============================================+-- 1. ATTENTION SCORE COMPUTATION+-- ============================================++-- Basic attention score: softmax(Q * K^T / sqrt(d_k)) * V+-- Using cosine similarity as a proxy for dot product attention++CREATE OR REPLACE FUNCTION claude_flow.attention_scores(+ query_embedding vector(384),+ limit_count INT DEFAULT 10,+ temperature FLOAT DEFAULT 1.0+)+RETURNS TABLE (+ id UUID,+ content TEXT,+ raw_score FLOAT,+ attention_weight FLOAT,+ metadata JSONB+) AS $$+DECLARE+ softmax_sum FLOAT;+BEGIN+ -- Calculate softmax denominator+ SELECT SUM(EXP((1 - (embedding <=> query_embedding)) / temperature))+ INTO softmax_sum+ FROM claude_flow.embeddings+ WHERE embedding IS NOT NULL;++ RETURN QUERY+ SELECT+ e.id,+ e.content,+ (1 - (e.embedding <=> query_embedding))::FLOAT AS r_score,+ (EXP((1 - (e.embedding <=> query_embedding)) / temperature) / NULLIF(softmax_sum, 0))::FLOAT AS a_weight,+ e.metadata+ FROM claude_flow.embeddings e+ WHERE e.embedding IS NOT NULL+ ORDER BY a_weight DESC+ LIMIT limit_count;+END;+$$ LANGUAGE plpgsql STABLE;+++-- ============================================+-- 2. SELF-ATTENTION LAYER+-- ============================================++-- Self-attention: each embedding attends to all others+CREATE OR REPLACE FUNCTION claude_flow.self_attention(+ source_ids UUID[],+ head_count INT DEFAULT 4,+ temperature FLOAT DEFAULT 1.0+)+RETURNS TABLE (+ source_id UUID,+ attended_id UUID,+ head_idx INT,+ attention_score FLOAT,+ source_content TEXT,+ attended_content TEXT+) AS $$+BEGIN+ RETURN QUERY+ WITH source_embeddings AS (+ SELECT id, content, embedding+ FROM claude_flow.embeddings+ WHERE id = ANY(source_ids)+ AND embedding IS NOT NULL+ ),+ all_pairs AS (+ SELECT+ s.id AS s_id,+ s.content AS s_content,+ s.embedding AS s_emb,+ t.id AS t_id,+ t.content AS t_content,+ t.embedding AS t_emb,+ h.head_idx AS h_idx+ FROM source_embeddings s+ CROSS JOIN claude_flow.embeddings t+ CROSS JOIN generate_series(1, head_count) AS h(head_idx)+ WHERE t.embedding IS NOT NULL+ ),+ raw_scores AS (+ SELECT+ ap.s_id,+ ap.s_content,+ ap.t_id,+ ap.t_content,+ ap.h_idx,+ (1 - (ap.s_emb <=> ap.t_emb))::FLOAT AS score+ FROM all_pairs ap+ ),+ softmax_scores AS (+ SELECT+ rs.s_id,+ rs.s_content,+ rs.t_id,+ rs.t_content,+ rs.h_idx,+ rs.score,+ EXP(rs.score / temperature) /+ SUM(EXP(rs.score / temperature)) OVER (PARTITION BY rs.s_id, rs.h_idx) AS attn_score+ FROM raw_scores rs+ )+ SELECT+ ss.s_id,+ ss.t_id,+ ss.h_idx,+ ss.attn_score::FLOAT,+ ss.s_content,+ ss.t_content+ FROM softmax_scores ss+ WHERE ss.attn_score > 0.01 -- Filter low attention+ ORDER BY ss.s_id, ss.h_idx, ss.attn_score DESC;+END;+$$ LANGUAGE plpgsql STABLE;+++-- ============================================+-- 3. CROSS-ATTENTION+-- ============================================++-- Cross-attention between two sets of embeddings+CREATE OR REPLACE FUNCTION claude_flow.cross_attention(+ query_ids UUID[],+ key_value_filter JSONB DEFAULT NULL,+ temperature FLOAT DEFAULT 1.0+)+RETURNS TABLE (+ query_id UUID,+ key_id UUID,+ attention_weight FLOAT,+ query_content TEXT,+ key_content TEXT,+ key_metadata JSONB+) AS $$+BEGIN+ RETURN QUERY+ WITH queries AS (+ SELECT id, content, embedding+ FROM claude_flow.embeddings+ WHERE id = ANY(query_ids)+ AND embedding IS NOT NULL+ ),+ keys AS (+ SELECT id, content, embedding, metadata+ FROM claude_flow.embeddings+ WHERE embedding IS NOT NULL+ AND (key_value_filter IS NULL OR metadata @> key_value_filter)+ AND id != ALL(query_ids)+ ),+ raw_attention AS (+ SELECT+ q.id AS q_id,+ q.content AS q_content,+ k.id AS k_id,+ k.content AS k_content,+ k.metadata AS k_meta,+ (1 - (q.embedding <=> k.embedding))::FLOAT AS score+ FROM queries q+ CROSS JOIN keys k+ ),+ softmax_attention AS (+ SELECT+ ra.*,+ EXP(ra.score / temperature) /+ SUM(EXP(ra.score / temperature)) OVER (PARTITION BY ra.q_id) AS attn_weight+ FROM raw_attention ra+ )+ SELECT+ sa.q_id,+ sa.k_id,+ sa.attn_weight::FLOAT,+ sa.q_content,+ sa.k_content,+ sa.k_meta+ FROM softmax_attention sa+ WHERE sa.attn_weight > 0.01+ ORDER BY sa.q_id, sa.attn_weight DESC;+END;+$$ LANGUAGE plpgsql STABLE;+++-- ============================================+-- 4. MULTI-HEAD ATTENTION AGGREGATION+-- ============================================++-- Aggregate multi-head attention outputs+CREATE OR REPLACE FUNCTION claude_flow.multihead_attention_aggregate(+ query_embedding vector(384),+ num_heads INT DEFAULT 8,+ head_dim INT DEFAULT 48, -- 384 / 8+ limit_count INT DEFAULT 10+)+RETURNS TABLE (+ id UUID,+ content TEXT,+ aggregated_attention FLOAT,+ head_attentions FLOAT[],+ metadata JSONB+) AS $$+BEGIN+ RETURN QUERY+ WITH per_head_attention AS (+ SELECT+ e.id,+ e.content,+ e.metadata,+ h.head_idx,+ -- Simulate head projection by using different parts of the embedding+ (1 - (+ subvector(e.embedding, (h.head_idx - 1) * head_dim + 1, head_dim) <=>+ subvector(query_embedding, (h.head_idx - 1) * head_dim + 1, head_dim)+ ))::FLOAT AS head_score+ FROM claude_flow.embeddings e+ CROSS JOIN generate_series(1, num_heads) AS h(head_idx)+ WHERE e.embedding IS NOT NULL+ ),+ aggregated AS (+ SELECT+ pha.id,+ pha.content,+ pha.metadata,+ AVG(pha.head_score)::FLOAT AS avg_attention,+ array_agg(pha.head_score ORDER BY pha.head_idx) AS head_scores+ FROM per_head_attention pha+ GROUP BY pha.id, pha.content, pha.metadata+ )+ SELECT+ a.id,+ a.content,+ a.avg_attention,+ a.head_scores,+ a.metadata+ FROM aggregated a+ ORDER BY a.avg_attention DESC+ LIMIT limit_count;+END;+$$ LANGUAGE plpgsql STABLE;+++-- ============================================+-- 5. FLASH ATTENTION PATTERN (Block-wise)+-- ============================================++-- Simulates Flash Attention by processing in blocks+-- Reduces memory usage for large-scale attention++CREATE OR REPLACE FUNCTION claude_flow.flash_attention_search(+ query_embedding vector(384),+ block_size INT DEFAULT 64,+ limit_count INT DEFAULT 10+)+RETURNS TABLE (+ id UUID,+ content TEXT,+ attention_score FLOAT,+ block_id INT,+ metadata JSONB+) AS $$+BEGIN+ RETURN QUERY+ WITH numbered_embeddings AS (+ SELECT+ e.id,+ e.content,+ e.embedding,+ e.metadata,+ ROW_NUMBER() OVER (ORDER BY e.created_at) AS row_num+ FROM claude_flow.embeddings e+ WHERE e.embedding IS NOT NULL+ ),+ blocked AS (+ SELECT+ ne.*,+ ((ne.row_num - 1) / block_size + 1)::INT AS blk_id+ FROM numbered_embeddings ne+ ),+ block_max AS (+ -- Find max score per block (for numerical stability)+ SELECT+ b.blk_id,+ MAX(1 - (b.embedding <=> query_embedding))::FLOAT AS max_score+ FROM blocked b+ GROUP BY b.blk_id+ ),+ block_attention AS (+ SELECT+ b.id,+ b.content,+ b.embedding,+ b.metadata,+ b.blk_id,+ (1 - (b.embedding <=> query_embedding))::FLOAT AS raw_score,+ bm.max_score,+ EXP((1 - (b.embedding <=> query_embedding)) - bm.max_score) AS stable_exp+ FROM blocked b+ JOIN block_max bm ON b.blk_id = bm.blk_id+ ),+ block_sums AS (+ SELECT+ blk_id,+ SUM(stable_exp) AS sum_exp+ FROM block_attention+ GROUP BY blk_id+ ),+ final_attention AS (+ SELECT+ ba.id,+ ba.content,+ ba.metadata,+ ba.blk_id,+ (ba.stable_exp / NULLIF(bs.sum_exp, 0))::FLOAT AS attn_score+ FROM block_attention ba+ JOIN block_sums bs ON ba.blk_id = bs.blk_id+ )+ SELECT+ fa.id,+ fa.content,+ fa.attn_score,+ fa.blk_id,+ fa.metadata+ FROM final_attention fa+ ORDER BY fa.attn_score DESC+ LIMIT limit_count;+END;+$$ LANGUAGE plpgsql STABLE;+++-- ============================================+-- 6. ATTENTION-WEIGHTED RETRIEVAL+-- ============================================++-- Use attention to weight context retrieval for RAG+CREATE OR REPLACE FUNCTION claude_flow.attention_weighted_retrieve(+ query_embedding vector(384),+ context_window INT DEFAULT 5,+ attention_threshold FLOAT DEFAULT 0.1+)+RETURNS TABLE (+ context_text TEXT,+ total_attention FLOAT,+ contributing_ids UUID[]+) AS $$+BEGIN+ RETURN QUERY+ WITH attention_scores AS (+ SELECT+ e.id,+ e.content,+ (1 - (e.embedding <=> query_embedding))::FLOAT AS score+ FROM claude_flow.embeddings e+ WHERE e.embedding IS NOT NULL+ ),+ softmax_attention AS (+ SELECT+ a.id,+ a.content,+ a.score,+ (a.score / NULLIF(SUM(a.score) OVER (), 0))::FLOAT AS attention_weight+ FROM attention_scores a+ ),+ filtered AS (+ SELECT *+ FROM softmax_attention sa+ WHERE sa.attention_weight >= attention_threshold+ ORDER BY sa.attention_weight DESC+ LIMIT context_window+ )+ SELECT+ string_agg(f.content, E'\n\n' ORDER BY f.attention_weight DESC) AS ctx_text,+ SUM(f.attention_weight)::FLOAT AS total_attn,+ array_agg(f.id ORDER BY f.attention_weight DESC) AS contrib_ids+ FROM filtered f;+END;+$$ LANGUAGE plpgsql STABLE;+++-- ============================================+-- 7. CAUSAL ATTENTION MASK+-- ============================================++-- Attention with causal masking (only attend to earlier items)+CREATE OR REPLACE FUNCTION claude_flow.causal_attention(+ source_ids UUID[],+ temperature FLOAT DEFAULT 1.0+)+RETURNS TABLE (+ source_id UUID,+ attended_id UUID,+ attention_score FLOAT,+ source_created TIMESTAMPTZ,+ attended_created TIMESTAMPTZ+) AS $$+BEGIN+ RETURN QUERY+ WITH sources AS (+ SELECT id, content, embedding, created_at+ FROM claude_flow.embeddings+ WHERE id = ANY(source_ids)+ AND embedding IS NOT NULL+ ),+ causal_pairs AS (+ SELECT+ s.id AS s_id,+ s.embedding AS s_emb,+ s.created_at AS s_created,+ t.id AS t_id,+ t.embedding AS t_emb,+ t.created_at AS t_created,+ (1 - (s.embedding <=> t.embedding))::FLOAT AS score+ FROM sources s+ JOIN claude_flow.embeddings t ON t.created_at <= s.created_at -- Causal mask+ WHERE t.embedding IS NOT NULL+ ),+ softmax_scores AS (+ SELECT+ cp.*,+ EXP(cp.score / temperature) /+ SUM(EXP(cp.score / temperature)) OVER (PARTITION BY cp.s_id) AS attn+ FROM causal_pairs cp+ )+ SELECT+ ss.s_id,+ ss.t_id,+ ss.attn::FLOAT,+ ss.s_created,+ ss.t_created+ FROM softmax_scores ss+ WHERE ss.attn > 0.01+ ORDER BY ss.s_id, ss.attn DESC;+END;+$$ LANGUAGE plpgsql STABLE;+++-- ============================================+-- 8. ATTENTION VISUALIZATION HELPER+-- ============================================++-- Generate attention matrix for visualization+CREATE OR REPLACE FUNCTION claude_flow.attention_matrix(+ embedding_ids UUID[],+ temperature FLOAT DEFAULT 1.0+)+RETURNS TABLE (+ row_id UUID,+ col_id UUID,+ row_idx INT,+ col_idx INT,+ attention_value FLOAT+) AS $$+BEGIN+ RETURN QUERY+ WITH indexed AS (+ SELECT+ e.id,+ e.embedding,+ ROW_NUMBER() OVER (ORDER BY array_position(embedding_ids, e.id)) AS idx+ FROM claude_flow.embeddings e+ WHERE e.id = ANY(embedding_ids)+ AND e.embedding IS NOT NULL+ ),+ pairs AS (+ SELECT+ i1.id AS r_id,+ i1.idx AS r_idx,+ i2.id AS c_id,+ i2.idx AS c_idx,+ (1 - (i1.embedding <=> i2.embedding))::FLOAT AS score+ FROM indexed i1+ CROSS JOIN indexed i2+ ),+ softmax AS (+ SELECT+ p.*,+ EXP(p.score / temperature) /+ SUM(EXP(p.score / temperature)) OVER (PARTITION BY p.r_id) AS attn+ FROM pairs p+ )+ SELECT+ s.r_id,+ s.c_id,+ s.r_idx::INT,+ s.c_idx::INT,+ s.attn::FLOAT+ FROM softmax s+ ORDER BY s.r_idx, s.c_idx;+END;+$$ LANGUAGE plpgsql STABLE;