overai 1.4.0

package/dist/knowledge/graph-rag.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * Graph RAG - Graph-based Retrieval Augmented Generation
+ * Inspired by mastra's graph-rag module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphRAG = exports.GraphStore = void 0;
+exports.createGraphRAG = createGraphRAG;
+/**
+ * In-memory Graph Store for Graph RAG
+ */
+class GraphStore {
+    constructor() {
+        this.nodes = new Map();
+        this.edges = new Map();
+        this.adjacencyList = new Map();
+        this.reverseAdjacencyList = new Map();
+    }
+    /**
+     * Add a node to the graph
+     */
+    addNode(node) {
+        this.nodes.set(node.id, node);
+        if (!this.adjacencyList.has(node.id)) {
+            this.adjacencyList.set(node.id, new Set());
+        }
+        if (!this.reverseAdjacencyList.has(node.id)) {
+            this.reverseAdjacencyList.set(node.id, new Set());
+        }
+    }
+    /**
+     * Add an edge to the graph
+     */
+    addEdge(edge) {
+        this.edges.set(edge.id, edge);
+        // Update adjacency lists
+        if (!this.adjacencyList.has(edge.source)) {
+            this.adjacencyList.set(edge.source, new Set());
+        }
+        this.adjacencyList.get(edge.source).add(edge.target);
+        if (!this.reverseAdjacencyList.has(edge.target)) {
+            this.reverseAdjacencyList.set(edge.target, new Set());
+        }
+        this.reverseAdjacencyList.get(edge.target).add(edge.source);
+    }
+    /**
+     * Get a node by ID
+     */
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    /**
+     * Get all nodes
+     */
+    getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    /**
+     * Get neighbors of a node
+     */
+    getNeighbors(nodeId, direction = 'both') {
+        const neighborIds = new Set();
+        if (direction === 'outgoing' || direction === 'both') {
+            const outgoing = this.adjacencyList.get(nodeId);
+            if (outgoing) {
+                outgoing.forEach(id => neighborIds.add(id));
+            }
+        }
+        if (direction === 'incoming' || direction === 'both') {
+            const incoming = this.reverseAdjacencyList.get(nodeId);
+            if (incoming) {
+                incoming.forEach(id => neighborIds.add(id));
+            }
+        }
+        return Array.from(neighborIds)
+            .map(id => this.nodes.get(id))
+            .filter((n) => n !== undefined);
+    }
+    /**
+     * Get edges between two nodes
+     */
+    getEdgesBetween(sourceId, targetId) {
+        return Array.from(this.edges.values()).filter(e => (e.source === sourceId && e.target === targetId) ||
+            (e.source === targetId && e.target === sourceId));
+    }
+    /**
+     * Find paths between two nodes using BFS
+     */
+    findPaths(startId, endId, maxDepth = 3) {
+        const paths = [];
+        const queue = [
+            { path: [startId], visited: new Set([startId]) }
+        ];
+        while (queue.length > 0) {
+            const { path, visited } = queue.shift();
+            const currentId = path[path.length - 1];
+            if (currentId === endId) {
+                paths.push(path.map(id => this.nodes.get(id)).filter(n => n));
+                continue;
+            }
+            if (path.length >= maxDepth) {
+                continue;
+            }
+            const neighbors = this.adjacencyList.get(currentId) || new Set();
+            for (const neighborId of neighbors) {
+                if (!visited.has(neighborId)) {
+                    const newVisited = new Set(visited);
+                    newVisited.add(neighborId);
+                    queue.push({ path: [...path, neighborId], visited: newVisited });
+                }
+            }
+        }
+        return paths;
+    }
+    /**
+     * Get subgraph around a node
+     */
+    getSubgraph(nodeId, depth = 2) {
+        const visitedNodes = new Set();
+        const resultEdges = [];
+        const queue = [{ id: nodeId, currentDepth: 0 }];
+        while (queue.length > 0) {
+            const { id, currentDepth } = queue.shift();
+            if (visitedNodes.has(id) || currentDepth > depth) {
+                continue;
+            }
+            visitedNodes.add(id);
+            if (currentDepth < depth) {
+                const neighbors = this.getNeighbors(id);
+                for (const neighbor of neighbors) {
+                    if (!visitedNodes.has(neighbor.id)) {
+                        queue.push({ id: neighbor.id, currentDepth: currentDepth + 1 });
+                        // Add edges
+                        const edges = this.getEdgesBetween(id, neighbor.id);
+                        resultEdges.push(...edges);
+                    }
+                }
+            }
+        }
+        const resultNodes = Array.from(visitedNodes)
+            .map(id => this.nodes.get(id))
+            .filter((n) => n !== undefined);
+        return { nodes: resultNodes, edges: resultEdges };
+    }
+    /**
+     * Clear the graph
+     */
+    clear() {
+        this.nodes.clear();
+        this.edges.clear();
+        this.adjacencyList.clear();
+        this.reverseAdjacencyList.clear();
+    }
+    /**
+     * Get graph statistics
+     */
+    getStats() {
+        return {
+            nodeCount: this.nodes.size,
+            edgeCount: this.edges.size
+        };
+    }
+}
+exports.GraphStore = GraphStore;
+/**
+ * Graph RAG - Combines graph traversal with vector similarity
+ */
+class GraphRAG {
+    constructor(config = {}) {
+        this.graphStore = new GraphStore();
+        this.embedFn = config.embedFn;
+    }
+    /**
+     * Add a document as a node
+     */
+    async addDocument(doc) {
+        const embedding = this.embedFn ? await this.embedFn(doc.content) : undefined;
+        this.graphStore.addNode({
+            id: doc.id,
+            type: doc.type || 'document',
+            content: doc.content,
+            metadata: doc.metadata,
+            embedding
+        });
+    }
+    /**
+     * Add a relationship between documents
+     */
+    addRelationship(sourceId, targetId, type, weight) {
+        this.graphStore.addEdge({
+            id: `${sourceId}-${type}-${targetId}`,
+            source: sourceId,
+            target: targetId,
+            type,
+            weight
+        });
+    }
+    /**
+     * Query the graph with a natural language query
+     */
+    async query(query, config = {}) {
+        const { maxDepth = 2, maxNodes = 10, minScore = 0, includeEdges = true } = config;
+        // Get all nodes and score them
+        const allNodes = this.graphStore.getAllNodes();
+        let scoredNodes;
+        if (this.embedFn) {
+            // Use embedding similarity
+            const queryEmbedding = await this.embedFn(query);
+            scoredNodes = allNodes
+                .filter(n => n.embedding)
+                .map(node => ({
+                node,
+                score: this.cosineSimilarity(queryEmbedding, node.embedding)
+            }));
+        }
+        else {
+            // Use keyword matching
+            const queryTerms = query.toLowerCase().split(/\s+/);
+            scoredNodes = allNodes.map(node => {
+                const content = node.content.toLowerCase();
+                let score = 0;
+                for (const term of queryTerms) {
+                    if (content.includes(term))
+                        score += 1;
+                }
+                return { node, score: score / queryTerms.length };
+            });
+        }
+        // Filter and sort by score
+        scoredNodes = scoredNodes
+            .filter(s => s.score >= minScore)
+            .sort((a, b) => b.score - a.score);
+        // Get top nodes and expand graph
+        const topNodes = scoredNodes.slice(0, Math.min(3, maxNodes));
+        const resultNodes = [];
+        const resultEdges = [];
+        const seenNodeIds = new Set();
+        for (const { node } of topNodes) {
+            const subgraph = this.graphStore.getSubgraph(node.id, maxDepth);
+            for (const n of subgraph.nodes) {
+                if (!seenNodeIds.has(n.id) && resultNodes.length < maxNodes) {
+                    seenNodeIds.add(n.id);
+                    resultNodes.push(n);
+                }
+            }
+            if (includeEdges) {
+                resultEdges.push(...subgraph.edges);
+            }
+        }
+        // Find paths between top nodes
+        const paths = [];
+        if (topNodes.length >= 2) {
+            for (let i = 0; i < topNodes.length - 1; i++) {
+                const foundPaths = this.graphStore.findPaths(topNodes[i].node.id, topNodes[i + 1].node.id, maxDepth);
+                paths.push(...foundPaths.slice(0, 3));
+            }
+        }
+        return {
+            nodes: resultNodes,
+            edges: resultEdges,
+            paths,
+            score: topNodes.length > 0 ? topNodes[0].score : 0
+        };
+    }
+    /**
+     * Get context string from query results
+     */
+    getContext(result) {
+        const nodeContents = result.nodes.map(n => n.content);
+        return nodeContents.join('\n\n---\n\n');
+    }
+    /**
+     * Get the underlying graph store
+     */
+    getGraphStore() {
+        return this.graphStore;
+    }
+    cosineSimilarity(a, b) {
+        const dot = a.reduce((sum, x, i) => sum + x * b[i], 0);
+        const normA = Math.sqrt(a.reduce((sum, x) => sum + x * x, 0));
+        const normB = Math.sqrt(b.reduce((sum, x) => sum + x * x, 0));
+        return dot / (normA * normB);
+    }
+}
+exports.GraphRAG = GraphRAG;
+// Factory function
+function createGraphRAG(config) {
+    return new GraphRAG(config);
+}

package/dist/knowledge/index.d.ts

@@ -0,0 +1,24 @@
+export interface Knowledge {
+    id: string;
+    type: string;
+    content: any;
+    metadata: Record<string, any>;
+}
+export interface KnowledgeBase {
+    addKnowledge(knowledge: Knowledge): void;
+    getKnowledge(id: string): Knowledge | undefined;
+    searchKnowledge(query: string): Knowledge[];
+    updateKnowledge(id: string, knowledge: Partial<Knowledge>): boolean;
+    deleteKnowledge(id: string): boolean;
+}
+export declare class BaseKnowledgeBase implements KnowledgeBase {
+    private knowledge;
+    constructor();
+    addKnowledge(knowledge: Knowledge): void;
+    getKnowledge(id: string): Knowledge | undefined;
+    searchKnowledge(query: string): Knowledge[];
+    updateKnowledge(id: string, update: Partial<Knowledge>): boolean;
+    deleteKnowledge(id: string): boolean;
+}
+export * from './reranker';
+export * from './graph-rag';

package/dist/knowledge/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseKnowledgeBase = void 0;
+class BaseKnowledgeBase {
+    constructor() {
+        this.knowledge = new Map();
+    }
+    addKnowledge(knowledge) {
+        this.knowledge.set(knowledge.id, knowledge);
+    }
+    getKnowledge(id) {
+        return this.knowledge.get(id);
+    }
+    searchKnowledge(query) {
+        // Basic implementation - should be enhanced with proper search logic
+        return Array.from(this.knowledge.values()).filter(k => JSON.stringify(k).toLowerCase().includes(query.toLowerCase()));
+    }
+    updateKnowledge(id, update) {
+        const existing = this.knowledge.get(id);
+        if (!existing)
+            return false;
+        this.knowledge.set(id, { ...existing, ...update });
+        return true;
+    }
+    deleteKnowledge(id) {
+        return this.knowledge.delete(id);
+    }
+}
+exports.BaseKnowledgeBase = BaseKnowledgeBase;
+// Export Reranker
+__exportStar(require("./reranker"), exports);
+// Export Graph RAG
+__exportStar(require("./graph-rag"), exports);

package/dist/knowledge/knowledge.js

@@ -0,0 +1 @@
+"use strict";

package/dist/knowledge/rag.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Knowledge Base (RAG) - Retrieval Augmented Generation
+ */
+export interface Document {
+    id: string;
+    content: string;
+    metadata?: Record<string, any>;
+    embedding?: number[];
+}
+export interface SearchResult {
+    document: Document;
+    score: number;
+}
+export interface EmbeddingProvider {
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+export interface KnowledgeBaseConfig {
+    embeddingProvider?: EmbeddingProvider;
+    similarityThreshold?: number;
+    maxResults?: number;
+}
+/**
+ * Simple in-memory vector store for RAG
+ */
+export declare class KnowledgeBase {
+    private documents;
+    private embeddingProvider?;
+    private similarityThreshold;
+    private maxResults;
+    constructor(config?: KnowledgeBaseConfig);
+    /**
+     * Add a document to the knowledge base
+     */
+    add(doc: Omit<Document, 'embedding'>): Promise<Document>;
+    /**
+     * Add multiple documents
+     */
+    addBatch(docs: Array<Omit<Document, 'embedding'>>): Promise<Document[]>;
+    /**
+     * Get a document by ID
+     */
+    get(id: string): Document | undefined;
+    /**
+     * Delete a document
+     */
+    delete(id: string): boolean;
+    /**
+     * Search for similar documents
+     */
+    search(query: string, limit?: number): Promise<SearchResult[]>;
+    /**
+     * Simple text-based search fallback
+     */
+    private textSearch;
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    private cosineSimilarity;
+    /**
+     * Get all documents
+     */
+    list(): Document[];
+    /**
+     * Clear all documents
+     */
+    clear(): void;
+    /**
+     * Get document count
+     */
+    get size(): number;
+    /**
+     * Build context from search results for RAG
+     */
+    buildContext(results: SearchResult[]): string;
+}
+/**
+ * Create a knowledge base
+ */
+export declare function createKnowledgeBase(config?: KnowledgeBaseConfig): KnowledgeBase;

package/dist/knowledge/rag.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Knowledge Base (RAG) - Retrieval Augmented Generation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeBase = void 0;
+exports.createKnowledgeBase = createKnowledgeBase;
+/**
+ * Simple in-memory vector store for RAG
+ */
+class KnowledgeBase {
+    constructor(config = {}) {
+        this.documents = new Map();
+        this.embeddingProvider = config.embeddingProvider;
+        this.similarityThreshold = config.similarityThreshold ?? 0.7;
+        this.maxResults = config.maxResults ?? 5;
+    }
+    /**
+     * Add a document to the knowledge base
+     */
+    async add(doc) {
+        const document = { ...doc };
+        if (this.embeddingProvider) {
+            document.embedding = await this.embeddingProvider.embed(doc.content);
+        }
+        this.documents.set(doc.id, document);
+        return document;
+    }
+    /**
+     * Add multiple documents
+     */
+    async addBatch(docs) {
+        if (this.embeddingProvider && docs.length > 0) {
+            const embeddings = await this.embeddingProvider.embedBatch(docs.map(d => d.content));
+            return Promise.all(docs.map(async (doc, i) => {
+                const document = { ...doc, embedding: embeddings[i] };
+                this.documents.set(doc.id, document);
+                return document;
+            }));
+        }
+        return Promise.all(docs.map(doc => this.add(doc)));
+    }
+    /**
+     * Get a document by ID
+     */
+    get(id) {
+        return this.documents.get(id);
+    }
+    /**
+     * Delete a document
+     */
+    delete(id) {
+        return this.documents.delete(id);
+    }
+    /**
+     * Search for similar documents
+     */
+    async search(query, limit) {
+        const maxResults = limit ?? this.maxResults;
+        if (!this.embeddingProvider) {
+            // Fallback to simple text matching
+            return this.textSearch(query, maxResults);
+        }
+        const queryEmbedding = await this.embeddingProvider.embed(query);
+        const results = [];
+        for (const doc of this.documents.values()) {
+            if (doc.embedding) {
+                const score = this.cosineSimilarity(queryEmbedding, doc.embedding);
+                if (score >= this.similarityThreshold) {
+                    results.push({ document: doc, score });
+                }
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, maxResults);
+    }
+    /**
+     * Simple text-based search fallback
+     */
+    textSearch(query, limit) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const doc of this.documents.values()) {
+            const contentLower = doc.content.toLowerCase();
+            if (contentLower.includes(queryLower)) {
+                const score = queryLower.length / contentLower.length;
+                results.push({ document: doc, score: Math.min(score * 10, 1) });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    /**
+     * Get all documents
+     */
+    list() {
+        return Array.from(this.documents.values());
+    }
+    /**
+     * Clear all documents
+     */
+    clear() {
+        this.documents.clear();
+    }
+    /**
+     * Get document count
+     */
+    get size() {
+        return this.documents.size;
+    }
+    /**
+     * Build context from search results for RAG
+     */
+    buildContext(results) {
+        if (results.length === 0)
+            return '';
+        return results
+            .map((r, i) => `[${i + 1}] ${r.document.content}`)
+            .join('\n\n');
+    }
+}
+exports.KnowledgeBase = KnowledgeBase;
+/**
+ * Create a knowledge base
+ */
+function createKnowledgeBase(config) {
+    return new KnowledgeBase(config);
+}

package/dist/knowledge/reranker.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Reranker - Rerank search results for improved relevance
+ * Inspired by mastra's rerank module
+ */
+export interface RerankResult {
+    id: string;
+    score: number;
+    content: string;
+    metadata?: Record<string, any>;
+    originalRank: number;
+    newRank: number;
+}
+export interface RerankConfig {
+    model?: string;
+    topK?: number;
+    threshold?: number;
+}
+/**
+ * Abstract base class for rerankers
+ */
+export declare abstract class BaseReranker {
+    readonly name: string;
+    constructor(name: string);
+    abstract rerank(query: string, documents: Array<{
+        id: string;
+        content: string;
+        metadata?: Record<string, any>;
+    }>, config?: RerankConfig): Promise<RerankResult[]>;
+}
+/**
+ * Cohere Reranker - Uses Cohere's rerank API
+ */
+export declare class CohereReranker extends BaseReranker {
+    private apiKey;
+    private model;
+    constructor(config?: {
+        apiKey?: string;
+        model?: string;
+    });
+    rerank(query: string, documents: Array<{
+        id: string;
+        content: string;
+        metadata?: Record<string, any>;
+    }>, config?: RerankConfig): Promise<RerankResult[]>;
+}
+/**
+ * Cross-Encoder Reranker - Uses sentence similarity for reranking
+ * This is a simple implementation using cosine similarity
+ */
+export declare class CrossEncoderReranker extends BaseReranker {
+    private embedFn?;
+    constructor(config?: {
+        embedFn?: (texts: string[]) => Promise<number[][]>;
+    });
+    rerank(query: string, documents: Array<{
+        id: string;
+        content: string;
+        metadata?: Record<string, any>;
+    }>, config?: RerankConfig): Promise<RerankResult[]>;
+    private keywordRerank;
+    private cosineSimilarity;
+}
+/**
+ * LLM Reranker - Uses an LLM to score relevance
+ */
+export declare class LLMReranker extends BaseReranker {
+    private generateFn;
+    constructor(config: {
+        generateFn: (prompt: string) => Promise<string>;
+    });
+    rerank(query: string, documents: Array<{
+        id: string;
+        content: string;
+        metadata?: Record<string, any>;
+    }>, config?: RerankConfig): Promise<RerankResult[]>;
+}
+export declare function createCohereReranker(config?: {
+    apiKey?: string;
+    model?: string;
+}): CohereReranker;
+export declare function createCrossEncoderReranker(config?: {
+    embedFn?: (texts: string[]) => Promise<number[][]>;
+}): CrossEncoderReranker;
+export declare function createLLMReranker(config: {
+    generateFn: (prompt: string) => Promise<string>;
+}): LLMReranker;