@echoes-io/mcp-server 4.1.1 → 6.1.0

package/src/rag/database-sync.js

@@ -1,158 +0,0 @@
-/**
- * Database synchronization utilities for HybridRAG
- * Ensures timeline/arc/episode/chapter records exist before indexing
- */
-import { and, eq } from 'drizzle-orm';
-import { arcs, chapters, episodes, timelines } from '../database/schema.js';
-export class DatabaseSync {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    /**
-     * Ensure all required database records exist for chapters
-     */
-    async syncChapters(chapterRecords) {
-        const stats = { timelines: 0, arcs: 0, episodes: 0, chapters: 0 };
-        // Group by timeline, arc, episode for efficient processing
-        const timelineMap = new Map();
-        const arcMap = new Map();
-        const episodeMap = new Map();
-        for (const record of chapterRecords) {
-            // Timeline tracking
-            if (!timelineMap.has(record.timeline)) {
-                timelineMap.set(record.timeline, new Set());
-            }
-            // Arc tracking
-            const arcKey = `${record.timeline}:${record.arc}`;
-            if (!arcMap.has(arcKey)) {
-                arcMap.set(arcKey, new Set());
-                timelineMap.get(record.timeline)?.add(record.arc);
-            }
-            // Episode tracking
-            const episodeKey = `${record.timeline}:${record.arc}:${record.episode}`;
-            if (!episodeMap.has(episodeKey)) {
-                episodeMap.set(episodeKey, new Set());
-                arcMap.get(arcKey)?.add(record.episode.toString());
-            }
-        }
-        // 1. Ensure timelines exist
-        for (const timelineName of timelineMap.keys()) {
-            const existing = await this.db
-                .select()
-                .from(timelines)
-                .where(eq(timelines.name, timelineName))
-                .limit(1);
-            if (existing.length === 0) {
-                await this.db.insert(timelines).values({
-                    name: timelineName,
-                    description: `Auto-created timeline: ${timelineName}`,
-                });
-                stats.timelines++;
-            }
-        }
-        // 2. Ensure arcs exist
-        for (const [arcKey, _] of arcMap) {
-            const [timelineName, arcName] = arcKey.split(':');
-            const timelineRecord = await this.db
-                .select()
-                .from(timelines)
-                .where(eq(timelines.name, timelineName))
-                .limit(1);
-            if (timelineRecord.length === 0)
-                continue;
-            const existing = await this.db
-                .select()
-                .from(arcs)
-                .where(and(eq(arcs.timelineId, timelineRecord[0].id), eq(arcs.name, arcName)))
-                .limit(1);
-            if (existing.length === 0) {
-                await this.db.insert(arcs).values({
-                    timelineId: timelineRecord[0].id,
-                    name: arcName,
-                    slug: arcName.toLowerCase().replace(/\s+/g, '-'),
-                    order: stats.arcs + 1,
-                });
-                stats.arcs++;
-            }
-        }
-        // 3. Ensure episodes exist
-        for (const [episodeKey, _] of episodeMap) {
-            const [timelineName, arcName, episodeNum] = episodeKey.split(':');
-            const arcRecord = await this.db
-                .select({ id: arcs.id })
-                .from(arcs)
-                .innerJoin(timelines, eq(arcs.timelineId, timelines.id))
-                .where(and(eq(timelines.name, timelineName), eq(arcs.name, arcName)))
-                .limit(1);
-            if (arcRecord.length === 0)
-                continue;
-            const existing = await this.db
-                .select()
-                .from(episodes)
-                .where(and(eq(episodes.arcId, arcRecord[0].id), eq(episodes.number, parseInt(episodeNum, 10))))
-                .limit(1);
-            if (existing.length === 0) {
-                await this.db.insert(episodes).values({
-                    arcId: arcRecord[0].id,
-                    number: parseInt(episodeNum, 10),
-                    title: `Episode ${episodeNum}`,
-                    slug: `episode-${episodeNum}`,
-                });
-                stats.episodes++;
-            }
-        }
-        // 4. Ensure chapters exist
-        for (const record of chapterRecords) {
-            const episodeRecord = await this.db
-                .select({ id: episodes.id })
-                .from(episodes)
-                .innerJoin(arcs, eq(episodes.arcId, arcs.id))
-                .innerJoin(timelines, eq(arcs.timelineId, timelines.id))
-                .where(and(eq(timelines.name, record.timeline), eq(arcs.name, record.arc), eq(episodes.number, record.episode)))
-                .limit(1);
-            if (episodeRecord.length === 0)
-                continue;
-            const existing = await this.db
-                .select()
-                .from(chapters)
-                .where(and(eq(chapters.episodeId, episodeRecord[0].id), eq(chapters.number, record.chapter)))
-                .limit(1);
-            if (existing.length === 0) {
-                await this.db.insert(chapters).values({
-                    episodeId: episodeRecord[0].id,
-                    number: record.chapter,
-                    pov: record.pov,
-                    title: record.title || `Chapter ${record.chapter}`,
-                    summary: record.summary || '',
-                    location: record.location || '',
-                    filePath: record.filePath,
-                });
-                stats.chapters++;
-            }
-        }
-        return stats;
-    }
-    /**
-     * Get chapter ID from database for embedding insertion
-     */
-    async getChapterId(timeline, arc, episode, chapter) {
-        const result = await this.db
-            .select({ id: chapters.id })
-            .from(chapters)
-            .innerJoin(episodes, eq(chapters.episodeId, episodes.id))
-            .innerJoin(arcs, eq(episodes.arcId, arcs.id))
-            .innerJoin(timelines, eq(arcs.timelineId, timelines.id))
-            .where(and(eq(timelines.name, timeline), eq(arcs.name, arc), eq(episodes.number, episode), eq(chapters.number, chapter)))
-            .limit(1);
-        return result.length > 0 ? result[0].id : null;
-    }
-    /**
-     * Clean up orphaned embeddings
-     */
-    async cleanupEmbeddings() {
-        // This would require a more complex query to find orphaned embeddings
-        // For now, we'll implement a simple version
-        return 0;
-    }
-}

package/src/rag/embeddings.d.ts

@@ -1,74 +0,0 @@
-/**
- * Embedding providers for GraphRAG
- * Supports BGE-Base-v1.5, E5-Small-v2, and future models
- */
-export interface EmbeddingProvider {
-    name: string;
-    dimension: number;
-    embed(texts: string[]): Promise<number[][]>;
-    embedSingle(text: string): Promise<number[]>;
-}
-export interface EmbeddingConfig {
-    provider: 'bge-base' | 'e5-small' | 'gemini';
-    batchSize?: number;
-    maxTokens?: number;
-}
-/**
- * BGE-Base-v1.5 Embedding Provider
- * Fast, accurate, 384-dimensional embeddings
- */
-export declare class BGEBaseEmbedding implements EmbeddingProvider {
-    name: string;
-    dimension: number;
-    private batchSize;
-    private maxTokens;
-    constructor(config?: {
-        batchSize?: number;
-        maxTokens?: number;
-    });
-    embed(texts: string[]): Promise<number[][]>;
-    embedSingle(text: string): Promise<number[]>;
-    private generateContentAwareEmbedding;
-}
-/**
- * E5-Small-v2 Embedding Provider
- * Lightweight, fast, 384-dimensional embeddings for testing
- */
-export declare class E5SmallEmbedding implements EmbeddingProvider {
-    name: string;
-    dimension: number;
-    private batchSize;
-    constructor(config?: {
-        batchSize?: number;
-    });
-    embed(texts: string[]): Promise<number[][]>;
-    embedSingle(text: string): Promise<number[]>;
-    private generateContentAwareEmbedding;
-}
-/**
- * Gemini Embedding Provider
- * State-of-the-art, requires API key
- */
-export declare class GeminiEmbedding implements EmbeddingProvider {
-    name: string;
-    dimension: number;
-    constructor(apiKey: string);
-    embed(_texts: string[]): Promise<number[][]>;
-    embedSingle(text: string): Promise<number[]>;
-}
-/**
- * Factory function to create embedding providers
- */
-export declare function createEmbeddingProvider(config: EmbeddingConfig): EmbeddingProvider;
-/**
- * Calculate cosine similarity between two vectors
- */
-export declare function cosineSimilarity(a: number[], b: number[]): number;
-/**
- * Normalize embedding vector to unit length
- */
-export declare function normalizeEmbedding(embedding: number[]): number[];
-/**
- * Split array into batches of specified size
- */
-export declare function batchArray<T>(array: T[], batchSize: number): T[][];

package/src/rag/embeddings.js

@@ -1,164 +0,0 @@
-/**
- * Embedding providers for GraphRAG
- * Supports BGE-Base-v1.5, E5-Small-v2, and future models
- */
-/**
- * BGE-Base-v1.5 Embedding Provider
- * Fast, accurate, 384-dimensional embeddings
- */
-export class BGEBaseEmbedding {
-    name = 'bge-base-en-v1.5';
-    dimension = 384;
-    batchSize;
-    maxTokens;
-    constructor(config = {}) {
-        this.batchSize = config.batchSize || 32;
-        this.maxTokens = config.maxTokens || 512;
-    }
-    async embed(texts) {
-        // Create content-aware mock embeddings for more realistic similarity
-        return texts.map((text, index) => this.generateContentAwareEmbedding(text, index));
-    }
-    async embedSingle(text) {
-        return this.generateContentAwareEmbedding(text, 0);
-    }
-    generateContentAwareEmbedding(text, index) {
-        // Create embeddings based on text content for more realistic similarity
-        const words = text.toLowerCase().match(/\b\w+\b/g) || [];
-        const wordSet = new Set(words);
-        // Use text characteristics to create different embeddings
-        const textLength = text.length;
-        const uniqueWords = wordSet.size;
-        const avgWordLength = words.reduce((sum, word) => sum + word.length, 0) / words.length || 1;
-        // Create embedding with some structure based on content
-        const embedding = Array.from({ length: this.dimension }, (_, i) => {
-            // Base pattern from text characteristics
-            const base = Math.sin((textLength + i) * 0.01) * 0.2;
-            // Add word-based variation
-            const wordInfluence = Math.cos((uniqueWords + i) * 0.02) * 0.2;
-            // Add length-based variation
-            const lengthInfluence = Math.sin((avgWordLength + i) * 0.03) * 0.2;
-            // Add index-based variation to ensure uniqueness
-            const indexInfluence = Math.cos((index + i) * 0.05) * 0.3;
-            // Random noise (reduced)
-            const noise = (Math.random() - 0.5) * 0.1;
-            return base + wordInfluence + lengthInfluence + indexInfluence + noise;
-        });
-        // Normalize to unit vector
-        const norm = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
-        return embedding.map((val) => val / norm);
-    }
-}
-/**
- * E5-Small-v2 Embedding Provider
- * Lightweight, fast, 384-dimensional embeddings for testing
- */
-export class E5SmallEmbedding {
-    name = 'e5-small-v2';
-    dimension = 384;
-    batchSize;
-    constructor(config = {}) {
-        this.batchSize = config.batchSize || 64;
-    }
-    async embed(texts) {
-        return texts.map((text, index) => this.generateContentAwareEmbedding(text, index));
-    }
-    async embedSingle(text) {
-        return this.generateContentAwareEmbedding(text, 0);
-    }
-    generateContentAwareEmbedding(text, index) {
-        const words = text.toLowerCase().match(/\b\w+\b/g) || [];
-        const wordSet = new Set(words);
-        const textLength = text.length;
-        const uniqueWords = wordSet.size;
-        const avgWordLength = words.reduce((sum, word) => sum + word.length, 0) / words.length || 1;
-        const embedding = Array.from({ length: this.dimension }, (_, i) => {
-            const base = Math.sin((textLength + i) * 0.01) * 0.2;
-            const wordInfluence = Math.cos((uniqueWords + i) * 0.02) * 0.2;
-            const lengthInfluence = Math.sin((avgWordLength + i) * 0.03) * 0.2;
-            const indexInfluence = Math.cos((index + i) * 0.05) * 0.3;
-            const noise = (Math.random() - 0.5) * 0.1;
-            return base + wordInfluence + lengthInfluence + indexInfluence + noise;
-        });
-        const norm = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
-        return embedding.map((val) => val / norm);
-    }
-}
-/**
- * Gemini Embedding Provider
- * State-of-the-art, requires API key
- */
-export class GeminiEmbedding {
-    name = 'gemini-embedding';
-    dimension = 768; // Gemini embedding dimension
-    constructor(apiKey) {
-        // Store API key for future implementation
-        void apiKey;
-    }
-    async embed(_texts) {
-        // TODO: Implement Gemini API integration
-        throw new Error('Gemini embedding not yet implemented');
-    }
-    async embedSingle(text) {
-        const results = await this.embed([text]);
-        return results[0];
-    }
-}
-/**
- * Factory function to create embedding providers
- */
-export function createEmbeddingProvider(config) {
-    switch (config.provider) {
-        case 'bge-base':
-            return new BGEBaseEmbedding({
-                batchSize: config.batchSize,
-                maxTokens: config.maxTokens,
-            });
-        case 'e5-small':
-            return new E5SmallEmbedding({
-                batchSize: config.batchSize,
-            });
-        case 'gemini': {
-            const apiKey = process.env.ECHOES_GEMINI_API_KEY;
-            if (!apiKey) {
-                throw new Error('ECHOES_GEMINI_API_KEY environment variable required for Gemini provider');
-            }
-            return new GeminiEmbedding(apiKey);
-        }
-        default:
-            throw new Error(`Unknown embedding provider: ${config.provider}`);
-    }
-}
-/**
- * Calculate cosine similarity between two vectors
- */
-export function 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];
-    }
-    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-}
-/**
- * Normalize embedding vector to unit length
- */
-export function normalizeEmbedding(embedding) {
-    const norm = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
-    return embedding.map((val) => val / norm);
-}
-/**
- * Split array into batches of specified size
- */
-export function batchArray(array, batchSize) {
-    const batches = [];
-    for (let i = 0; i < array.length; i += batchSize) {
-        batches.push(array.slice(i, i + batchSize));
-    }
-    return batches;
-}

package/src/rag/graph-rag.d.ts

@@ -1,69 +0,0 @@
-/**
- * GraphRAG implementation for Echoes storytelling platform
- * Based on Mastra.ai GraphRAG with adaptations for chapter relationships
- */
-export type SupportedEdgeType = 'semantic' | 'character' | 'temporal' | 'location';
-export interface GraphNode {
-    id: string;
-    content: string;
-    embedding?: number[];
-    metadata: {
-        chapterId: string;
-        arc: string;
-        episode: number;
-        chapter: number;
-        pov: string;
-        characters: string[];
-        location?: string;
-        [key: string]: unknown;
-    };
-}
-export interface RankedNode extends GraphNode {
-    score: number;
-}
-export interface GraphEdge {
-    source: string;
-    target: string;
-    weight: number;
-    type: SupportedEdgeType;
-}
-export interface GraphChunk {
-    text: string;
-    metadata: GraphNode['metadata'];
-}
-export interface GraphEmbedding {
-    vector: number[];
-}
-export declare class GraphRAG {
-    private nodes;
-    private edges;
-    private dimension;
-    private threshold;
-    constructor(dimension?: number, threshold?: number);
-    addNode(node: GraphNode): void;
-    addEdge(edge: GraphEdge): void;
-    getNodes(): GraphNode[];
-    getEdges(): GraphEdge[];
-    getEdgesByType(type: SupportedEdgeType): GraphEdge[];
-    clear(): void;
-    updateNodeContent(id: string, newContent: string): void;
-    private getNeighbors;
-    private cosineSimilarity;
-    createGraph(chunks: GraphChunk[], embeddings: GraphEmbedding[]): void;
-    private createSemanticEdges;
-    private createCharacterEdges;
-    private createTemporalEdges;
-    private createLocationEdges;
-    private selectWeightedNeighbor;
-    private randomWalkWithRestart;
-    query({ query, topK, randomWalkSteps, restartProb, characters, allCharacters, arc, pov, }: {
-        query: number[];
-        topK?: number;
-        randomWalkSteps?: number;
-        restartProb?: number;
-        characters?: string[];
-        allCharacters?: boolean;
-        arc?: string;
-        pov?: string;
-    }): RankedNode[];
-}