cozo-memory 1.0.0

package/dist/test-advanced-search.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function main() {
+    const memory = new index_1.MemoryServer();
+    // Wait for initialization
+    await memory.initPromise;
+    console.log("--- Adding Test Data ---");
+    const alice = await memory.createEntity({
+        name: "Alice",
+        type: "Person",
+        metadata: { role: "engineer", expertise: "TypeScript" }
+    });
+    const bob = await memory.createEntity({
+        name: "Bob",
+        type: "Person",
+        metadata: { role: "manager", expertise: "Agile" }
+    });
+    const projectX = await memory.createEntity({
+        name: "Project X",
+        type: "Project",
+        metadata: { status: "Active" }
+    });
+    // Use id instead of entity_id
+    await memory.createRelation({
+        from_id: alice.id,
+        to_id: projectX.id,
+        relation_type: "WORKS_ON",
+    });
+    await memory.createRelation({
+        from_id: bob.id,
+        to_id: projectX.id,
+        relation_type: "WORKS_ON",
+    });
+    await memory.addObservation({
+        entity_id: alice.id,
+        text: "Alice is a software engineer working on Project X.",
+    });
+    await memory.addObservation({
+        entity_id: bob.id,
+        text: "Bob is a project manager for Project X.",
+    });
+    console.log("Entities created:", { alice: alice.id, bob: bob.id, projectX: projectX.id });
+    console.log("\n--- Search 1: Simple Search for Alice ---");
+    // Use advancedSearch
+    const res1 = await memory.advancedSearch({
+        query: "Alice engineer",
+        limit: 5,
+    });
+    console.log("Results 1:", JSON.stringify(res1, null, 2));
+    console.log("\n--- Search 2: Filter by Type 'Person' ---");
+    const res2 = await memory.advancedSearch({
+        query: "engineer",
+        filters: {
+            entityTypes: ["Person"],
+        },
+    });
+    console.log("Results 2:", JSON.stringify(res2, null, 2));
+    console.log("\n--- Search 3: Filter by Metadata ---");
+    const res3 = await memory.advancedSearch({
+        query: "Alice",
+        filters: {
+            metadata: {
+                role: "engineer",
+            },
+        },
+    });
+    console.log("Results 3:", JSON.stringify(res3, null, 2));
+    console.log("\n--- Search 4: Graph Constraints (Relations) ---");
+    // Find people who work on Project X
+    const res4 = await memory.advancedSearch({
+        query: "Project X",
+        graphConstraints: {
+            requiredRelations: ["WORKS_ON"],
+            maxDepth: 1,
+        },
+    });
+    console.log("Results 4:", JSON.stringify(res4, null, 2));
+}
+main().catch((error) => {
+    console.log("Error in test:", error);
+});

package/dist/test-advanced-time.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const hybrid_search_1 = require("./hybrid-search");
+const embedding_service_1 = require("./embedding-service");
+const fs_1 = __importDefault(require("fs"));
+async function testAdvancedSearchTime() {
+    const dbPath = "test-advanced-time.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    const embeddingService = new embedding_service_1.EmbeddingService(); // Assuming it works with default or mock
+    // Setup schema
+    const EMBEDDING_DIM = 1024;
+    await db.run(`{:create entity {id: String, created_at: Validity => name: String, type: String, embedding: <F32; ${EMBEDDING_DIM}>, metadata: Json}}`);
+    await db.run(`{::hnsw create entity:semantic {dim: ${EMBEDDING_DIM}, m: 16, dtype: F32, fields: [embedding], distance: Cosine, ef_construction: 200}}`);
+    await db.run(`{:create entity_rank {entity_id: String => pagerank: Float}}`);
+    const hybridSearch = new hybrid_search_1.HybridSearch(db, embeddingService);
+    // Insert some data
+    const now = Date.now();
+    const vec = new Array(EMBEDDING_DIM).fill(0.1);
+    const data = [
+        ['id1', [now - 10000000, true], 'Old Entity', 'typeA', vec, {}],
+        ['id2', [now, true], 'New Entity', 'typeB', vec, {}]
+    ];
+    await db.run(`?[id, created_at, name, type, embedding, metadata] <- $data :put entity {id, created_at => name, type, embedding, metadata}`, { data });
+    await db.run(`?[entity_id, pagerank] <- [['id1', 0.5], ['id2', 0.5]] :put entity_rank {entity_id => pagerank}`);
+    console.log("--- Testing Advanced Search with Time Filter ---");
+    try {
+        const results = await hybridSearch.advancedSearch({
+            query: "test",
+            timeRangeHours: 1 // Only new entity should match
+        });
+        console.log("Results:", results.map(r => r.id));
+    }
+    catch (e) {
+        console.error("Advanced Search Error:", e.message || e);
+    }
+}
+testAdvancedSearchTime();

package/dist/test-embedding.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const embedding_service_1 = require("./embedding-service");
+async function main() {
+    console.log("Starting Embedding Test...");
+    const service = new embedding_service_1.EmbeddingService();
+    try {
+        console.log("Generating embedding for 'Hello World'...");
+        const vec = await service.embed("Hello World");
+        console.log("Embedding vector length:", vec.length);
+        // Check if all are 0
+        const isAllZero = vec.every(v => v === 0);
+        console.log("Is vector only zeros?", isAllZero);
+        if (!isAllZero) {
+            console.log("First 5 values:", vec.slice(0, 5));
+        }
+    }
+    catch (e) {
+        console.error("Error in test:", e);
+    }
+}
+main();

package/dist/test-filter-expr.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testFilterExpr() {
+    const dbPath = "test-filter.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    const EMBEDDING_DIM = 1536;
+    try {
+        console.log("Creating table (type as PK)...");
+        await db.run(`{:create test_entity {id: String, type: String => metadata: Json, embedding: <F32; ${EMBEDDING_DIM}>}}`);
+        console.log("Creating HNSW index...");
+        await db.run(`{::hnsw create test_entity:semantic {dim: ${EMBEDDING_DIM}, m: 16, dtype: F32, fields: [embedding], distance: Cosine, ef_construction: 200}}`);
+        const vec1 = new Array(EMBEDDING_DIM).fill(0.1);
+        const vec2 = new Array(EMBEDDING_DIM).fill(0.9);
+        console.log("Inserting data...");
+        const data = [
+            ['id1', 'typeA', { status: 'active' }, vec1],
+            ['id2', 'typeB', { status: 'inactive' }, vec2]
+        ];
+        await db.run(`
+            ?[id, type, metadata, embedding] <- $data
+            :put test_entity {id, type => metadata, embedding}
+        `, { data });
+        console.log("Data inserted.");
+        console.log("--- Test: Filter with type (requesting it) ---");
+        try {
+            const res = await db.run(`
+                ?[id, type] := ~test_entity:semantic{id, type | query: vec($vec1), k: 2, ef: 100, filter: type == 'typeA'}
+            `, { vec1 });
+            console.log("Results (type == 'typeA'):", res.rows);
+        }
+        catch (e) {
+            console.error("Error (type == 'typeA'):", e.message || e);
+        }
+        console.log("--- Test: Filter with parameter (type in output) ---");
+        try {
+            const res = await db.run(`
+                ?[id, type] := ~test_entity:semantic{id, type | query: vec($vec1), k: 2, ef: 100, filter: type == $allowed_type}
+            `, { vec1, allowed_type: 'typeA' });
+            console.log("Results (type == $allowed_type):", res.rows);
+        }
+        catch (e) {
+            console.error("Error (type == $allowed_type):", e.message || e);
+        }
+        console.log("Creating table (with Validity)...");
+        // Recreate with Validity to match actual schema
+        await db.run(`{:create test_entity_v {id: String, created_at: Validity => type: String, metadata: Json, embedding: <F32; ${EMBEDDING_DIM}>}}`);
+        await db.run(`{::hnsw create test_entity_v:semantic {dim: ${EMBEDDING_DIM}, m: 16, dtype: F32, fields: [embedding], distance: Cosine, ef_construction: 200}}`);
+        const now = Date.now();
+        const dataV = [
+            ['id1', [now - 1000000, true], 'typeA', { status: 'active' }, vec1],
+            ['id2', [now, true], 'typeB', { status: 'inactive' }, vec2]
+        ];
+        await db.run(`
+            ?[id, created_at, type, metadata, embedding] <- $dataV
+            :put test_entity_v {id, created_at => type, metadata, embedding}
+        `, { dataV });
+        console.log("--- Test: Filter with is_in ---");
+        try {
+            const allowed_types = ['typeA', 'typeC'];
+            const res = await db.run(`
+                ?[id, type] := ~test_entity_v:semantic{id, type | query: vec($vec1), k: 2, ef: 100, filter: is_in(type, $allowed_types)}
+            `, { vec1, allowed_types });
+            console.log("Results (is_in(type, ...)):", res.rows);
+        }
+        catch (e) {
+            console.error("Error (is_in):", e.message || e);
+        }
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+}
+testFilterExpr().then(() => console.log("Done."));

package/dist/test-fts.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function main() {
+    console.log("🚀 Starting FTS (Full-Text Search) Test...");
+    const memory = new index_1.MemoryServer();
+    console.log("Waiting for schema...");
+    await memory.initPromise;
+    console.log("--- Schema ready ---");
+    console.log("1. Creating Test Data...");
+    // createEntity returns { id, name, type, status } or { error }
+    const e1 = await memory.createEntity({ name: "Berlin", type: "City", metadata: { description: "Berlin" } });
+    const e2 = await memory.createEntity({ name: "Munich", type: "City", metadata: { description: "Munich" } });
+    console.log("Entity 1 created:", e1.id || e1.error);
+    console.log("Entity 2 created:", e2.id || e2.error);
+    if (e1.error || e2.error) {
+        console.error("Failed to create entities");
+        return;
+    }
+    console.log("Adding Observations...");
+    await memory.addObservation({
+        entity_id: e1.id,
+        text: "Berlin is the capital of Germany. There are many museums.",
+    });
+    await memory.addObservation({
+        entity_id: e2.id,
+        text: "Munich is famous for Oktoberfest and technology development.",
+    });
+    await memory.addObservation({
+        entity_id: e1.id,
+        text: "The software is in beta stage and runs stably.",
+    });
+    console.log("Data created.");
+    console.log("\n2. Testing FTS Search...");
+    console.log("\n--- Test 1: Search for 'Capital' ---");
+    const res1 = await memory.advancedSearch({ query: "Capital", limit: 5 });
+    console.log(`Found: ${res1.length} results`);
+    res1.forEach((r) => console.log(` - [${r.source}] ${r.text?.substring(0, 50)}... (Score: ${r.score.toFixed(4)})`));
+    console.log("\n--- Test 2: Stemming Test ('developed' should find 'development') ---");
+    // "developed" stem -> "develop", "development" stem -> "develop"
+    // Cozo uses tantivy, check language support. Defaults to English?
+    const res2 = await memory.advancedSearch({ query: "developed", limit: 5 });
+    console.log(`Found: ${res2.length} results`);
+    res2.forEach((r) => console.log(` - [${r.source}] ${r.text?.substring(0, 50)}... (Score: ${r.score.toFixed(4)})`));
+    console.log("\n--- Test 3: Multiple Keywords ('Beta stable') ---");
+    const res3 = await memory.advancedSearch({ query: "Beta stable", limit: 5 });
+    console.log(`Found: ${res3.length} results`);
+    res3.forEach((r) => console.log(` - [${r.source}] ${r.text?.substring(0, 50)}... (Score: ${r.score.toFixed(4)})`));
+    console.log("\n--- Test 4: Stopwords Test ('the that') ---");
+    const res4 = await memory.advancedSearch({ query: "the that", limit: 5 });
+    console.log(`Found: ${res4.length} results (should be low or 0 if only stopwords)`);
+}
+main().catch((error) => {
+    console.log("❌ Test failed:", error);
+    if (error.display)
+        console.error(error.display);
+});
+console.log("\n✅ FTS Test completed.");

package/dist/test-functions.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testFunctions() {
+    const dbPath = "test-funcs.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    try {
+        const res = await db.run(`::functions`);
+        console.log("Functions:", res.rows.map((r) => r[0]).sort());
+    }
+    catch (e) {
+        console.error("Error:", e.message || e);
+    }
+}
+testFunctions();

package/dist/test-gpu-check.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const embedding_service_1 = require("./embedding-service");
+async function checkGpu() {
+    console.log("Starting Embedding Test...");
+    try {
+        const service = new embedding_service_1.EmbeddingService();
+        // Embedding a dummy text to trigger initialization
+        await service.embed("Test Embedding");
+        console.log("Embedding successfully completed.");
+    }
+    catch (error) {
+        console.error("Error during embedding:", error);
+    }
+}
+checkGpu();

package/dist/test-graph-algs-final.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function testNewGraphAlgorithms() {
+    const server = new index_1.MemoryServer('test_graph_algorithms');
+    console.log("--- Initialize test data ---");
+    // We build a network:
+    // A <-> B <-> C (B is bridge/betweenness)
+    // D -> E -> F -> D (Cycle for CC and HITS)
+    // G, H (Separate component)
+    const entities = [
+        { id: 'node_a', name: 'Node A', type: 'Test' },
+        { id: 'node_b', name: 'Node B (Bridge)', type: 'Test' },
+        { id: 'node_c', name: 'Node C', type: 'Test' },
+        { id: 'node_d', name: 'Node D', type: 'Test' },
+        { id: 'node_e', name: 'Node E', type: 'Test' },
+        { id: 'node_f', name: 'Node F', type: 'Test' },
+        { id: 'node_g', name: 'Node G', type: 'Test' },
+        { id: 'node_h', name: 'Node H', type: 'Test' }
+    ];
+    const relations = [
+        { from_id: 'node_a', to_id: 'node_b', action: 'create_relation', params: { from_id: 'node_a', to_id: 'node_b', relation_type: 'connects', strength: 0.8 } },
+        { from_id: 'node_b', to_id: 'node_c', action: 'create_relation', params: { from_id: 'node_b', to_id: 'node_c', relation_type: 'connects', strength: 0.9 } },
+        { from_id: 'node_d', to_id: 'node_e', action: 'create_relation', params: { from_id: 'node_d', to_id: 'node_e', relation_type: 'flow', strength: 1.0 } },
+        { from_id: 'node_e', to_id: 'node_f', action: 'create_relation', params: { from_id: 'node_e', to_id: 'node_f', relation_type: 'flow', strength: 1.0 } },
+        { from_id: 'node_f', to_id: 'node_d', action: 'create_relation', params: { from_id: 'node_f', to_id: 'node_d', relation_type: 'flow', strength: 1.0 } },
+        { from_id: 'node_g', to_id: 'node_h', action: 'create_relation', params: { from_id: 'node_g', to_id: 'node_h', relation_type: 'link', strength: 0.5 } }
+    ];
+    console.log("Creating entities...");
+    for (const ent of entities) {
+        await server.runTransaction({
+            operations: [{ action: 'create_entity', params: ent }]
+        });
+    }
+    console.log("Creating relationships...");
+    await server.runTransaction({
+        operations: relations.map(r => ({ action: 'create_relation', params: r.params }))
+    });
+    // Short pause for DB flush (SQLite is synchronous, but better safe than sorry)
+    await new Promise(resolve => setTimeout(resolve, 500));
+    // DEBUG: Check if data is present
+    console.log("Debug: Checking database content...");
+    const entitiesCount = await server.db.run(`?[count(e)] := *entity{id: e}`);
+    const relationsCount = await server.db.run(`?[count(f)] := *relationship{from_id: f, @ "NOW"}`);
+    console.log(`Debug: Entities in DB: ${entitiesCount.rows[0][0]}`);
+    console.log(`Debug: Relationships in DB: ${relationsCount.rows[0][0]}`);
+    if (relationsCount.rows[0][0] === 0) {
+        console.log("Trying alternative query without @ NOW...");
+        const relationsCountNoNow = await server.db.run(`?[count(f)] := *relationship{from_id: f}`);
+        console.log(`Debug: Relationships in DB (without NOW): ${relationsCountNoNow.rows[0][0]}`);
+    }
+    console.log("\n--- Test: Betweenness Centrality ---");
+    const betweenness = await server.recomputeBetweennessCentrality();
+    console.log("Betweenness Results:", JSON.stringify(betweenness.sort((a, b) => b.centrality - a.centrality), null, 2));
+    console.log("\n--- Test: Connected Components ---");
+    const components = await server.recomputeConnectedComponents();
+    console.log("Connected Components:", JSON.stringify(components, null, 2));
+    console.log("\n--- Test: Shortest Path (A -> C) ---");
+    const path = await server.computeShortestPath({ start_entity: 'node_a', end_entity: 'node_c' });
+    console.log("Shortest Path A->C:", JSON.stringify(path, null, 2));
+    console.log("\n--- Test: HITS (Hubs & Authorities) ---");
+    const hits = await server.recomputeHITS();
+    console.log("HITS Results:", JSON.stringify(hits, null, 2));
+    console.log("\n--- Test: PageRank ---");
+    const pagerank = await server.recomputePageRank();
+    console.log("PageRank Results (Top 5):", JSON.stringify(pagerank.sort((a, b) => b.pagerank - a.pagerank).slice(0, 5), null, 2));
+    console.log("\n--- Test: MCP Tool 'analyze_graph' ---");
+    // We simulate MCP calls via server methods, since FastMCP tools are encapsulated internally
+    console.log("Testing analyze_graph with action 'betweenness'...");
+    const resB = await server.recomputeBetweennessCentrality();
+    console.log("Result (Top 5):", JSON.stringify(resB.sort((a, b) => b.centrality - a.centrality).slice(0, 5), null, 2));
+    console.log("Testing analyze_graph with action 'shortest_path' (node_a to node_c)...");
+    const resP = await server.computeShortestPath({ start_entity: 'node_a', end_entity: 'node_c' });
+    console.log("Result:", JSON.stringify(resP, null, 2));
+}
+testNewGraphAlgorithms().catch(console.error);

package/dist/test-graph-filters.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const hybrid_search_1 = require("./hybrid-search");
+const embedding_service_1 = require("./embedding-service");
+const fs_1 = __importDefault(require("fs"));
+async function testGraphRagFilters() {
+    const dbPath = "test-graph-filters.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    const embeddingService = new embedding_service_1.EmbeddingService();
+    const hybridSearch = new hybrid_search_1.HybridSearch(db, embeddingService);
+    try {
+        const EMBEDDING_DIM = 1024;
+        // Create schema
+        await db.run(`
+            {:create entity {id: String, created_at: Validity => name: String, type: String, embedding: <F32; ${EMBEDDING_DIM}>, metadata: Json}}
+            {:create relationship {from_id: String, to_id: String, relation_type: String => metadata: Json}}
+            {:create search_cache {query_hash: String => results: Json, options: Json, created_at: Int, embedding: <F32; ${EMBEDDING_DIM}>}}
+            {:create entity_rank {entity_id: String => pagerank: Float}}
+        `);
+        // Create HNSW index
+        await db.run(`::hnsw create entity:semantic {fields: [embedding], dim: ${EMBEDDING_DIM}, m: 16, ef_construction: 200, distance: Cosine}`);
+        // Test data (Office scenario)
+        // id1: Person (Developer), id2: Person (Manager), id3: Project (AI)
+        // id1 -> id3 (works_on), id2 -> id1 (manages)
+        const now = Date.now();
+        const vec1 = new Array(EMBEDDING_DIM).fill(0).map((_, i) => i === 0 ? 1 : 0);
+        const vec2 = new Array(EMBEDDING_DIM).fill(0).map((_, i) => i === 1 ? 1 : 0);
+        const vec3 = new Array(EMBEDDING_DIM).fill(0).map((_, i) => i === 2 ? 1 : 0);
+        console.log("Inserting entities...");
+        await db.run(`
+            ?[id, created_at, name, type, embedding, metadata] <- [
+                ['id1', 'ASSERT', 'Alice', 'Person', $v1, $m1],
+                ['id2', 'ASSERT', 'Bob', 'Person', $v2, $m2],
+                ['id3', 'ASSERT', 'Project X', 'Project', $v3, $m3]
+            ]
+            :put entity {id, created_at => name, type, embedding, metadata}
+        `, {
+            v1: vec1, v2: vec2, v3: vec3,
+            m1: { role: 'Developer' },
+            m2: { role: 'Manager' },
+            m3: { status: 'active' }
+        });
+        console.log("Entities inserted.");
+        console.log("Inserting relationships...");
+        await db.run(`
+            ?[from_id, to_id, relation_type, metadata] <- [
+                ['id2', 'id1', 'manages', {}],
+                ['id1', 'id3', 'works_on', {}]
+            ]
+            :put relationship {from_id, to_id, relation_type => metadata}
+        `);
+        console.log("Relationships inserted.");
+        console.log("\n--- Testing Graph-RAG: No Filters (Query 'Alice') ---");
+        // Should find Alice and via graph Bob (Manager) and Project X
+        let results = await hybridSearch.graphRag({ query: "Alice", limit: 5 });
+        console.log("Found:", results.map(r => `${r.id} (${r.name}, score: ${r.score.toFixed(4)})`));
+        console.log("\n--- Testing Graph-RAG: Filter Type 'Project' ---");
+        // Should only find Project X (as seed or via expansion, but here as seed)
+        // If we search for Alice but only allow Projects, Alice will not be found as seed.
+        // If Project X is similar enough to Alice, it will be found as seed.
+        results = await hybridSearch.graphRag({
+            query: "Project",
+            filters: { entityTypes: ['Project'] }
+        });
+        console.log("Found:", results.map(r => `${r.id} (${r.name})`));
+        console.log("\n--- Testing Graph-RAG: Filter Metadata role='Developer' ---");
+        // Alice should be seed, Bob and Project X via expansion
+        results = await hybridSearch.graphRag({
+            query: "Alice",
+            filters: { metadata: { role: 'Developer' } }
+        });
+        console.log("Found:", results.map(r => `${r.id} (${r.name})`));
+    }
+    catch (e) {
+        console.error("Test failed:", e.message || e);
+    }
+}
+testGraphRagFilters();

package/dist/test-graph-rag.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const path_1 = __importDefault(require("path"));
+const serverPath = path_1.default.join(__dirname, "../dist/index.js");
+async function runTest() {
+    const transport = new stdio_js_1.StdioClientTransport({
+        command: "node",
+        args: [serverPath],
+        env: { ...process.env, NODE_ENV: "development" }
+    });
+    const client = new index_js_1.Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
+    try {
+        console.log("Connecting to MCP server for Graph-RAG Test...");
+        await client.connect(transport);
+        console.log("Connected!");
+        console.log("1. Create test data (Graph)...");
+        // Entities
+        const projectXRes = await client.callTool({
+            name: "mutate_memory",
+            arguments: {
+                action: "create_entity",
+                name: "Project-X",
+                type: "Project",
+                metadata: { priority: "high" }
+            }
+        });
+        const projectXId = JSON.parse(projectXRes.content[0].text).id;
+        const bobRes = await client.callTool({
+            name: "mutate_memory",
+            arguments: {
+                action: "create_entity",
+                name: "Bob",
+                type: "Person",
+                metadata: { role: "Manager" }
+            }
+        });
+        const bobId = JSON.parse(bobRes.content[0].text).id;
+        const aliceRes = await client.callTool({
+            name: "mutate_memory",
+            arguments: {
+                action: "create_entity",
+                name: "Alice",
+                type: "Person",
+                metadata: { role: "Developer" }
+            }
+        });
+        const aliceId = JSON.parse(aliceRes.content[0].text).id;
+        console.log(`IDs created: Project-X=${projectXId}, Bob=${bobId}, Alice=${aliceId}`);
+        // Relationships
+        await client.callTool({
+            name: "mutate_memory",
+            arguments: {
+                action: "create_relation",
+                from_id: aliceId,
+                to_id: projectXId,
+                relation_type: "works_on"
+            }
+        });
+        await client.callTool({
+            name: "mutate_memory",
+            arguments: {
+                action: "create_relation",
+                from_id: bobId,
+                to_id: projectXId,
+                relation_type: "manages"
+            }
+        });
+        // Observations
+        await client.callTool({
+            name: "mutate_memory",
+            arguments: {
+                action: "add_observation",
+                entity_id: aliceId,
+                text: "Alice works on the frontend architecture of Project-X."
+            }
+        });
+        await client.callTool({
+            name: "mutate_memory",
+            arguments: {
+                action: "add_observation",
+                entity_id: projectXId,
+                text: "Project-X is a new e-commerce platform."
+            }
+        });
+        console.log("2. Execute 'graph_rag' tool call...");
+        console.log("Query: 'Who works on Project-X?'");
+        const result = await client.callTool({
+            name: "query_memory",
+            arguments: {
+                action: "graph_rag",
+                query: "Project-X architecture",
+                limit: 5,
+                max_depth: 2
+            }
+        });
+        console.log("\n--- Graph-RAG Result ---");
+        console.log(JSON.stringify(result, null, 2));
+        if (result && result.content) {
+            const content = JSON.parse(result.content[0].text);
+            console.log(`\nFound entries: ${content.length}`);
+            const names = content.map((r) => r.name);
+            console.log("Found entities:", [...new Set(names)]);
+            if (names.some((n) => n.includes("Alice") || n === "Alice") && names.includes("Project-X")) {
+                console.log("\n✅ Test SUCCESSFUL: Alice and Project-X were found via graph expansion.");
+            }
+            else {
+                console.log("\n❌ Test FAILED: Expected entities not fully in result.");
+                console.log("Sought entities: Alice, Project-X");
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error testing:", error);
+    }
+    finally {
+        process.exit(0);
+    }
+}
+runTest();