cozo-memory 1.0.7 → 1.0.8

package/dist/index.js

@@ -361,6 +361,124 @@ class MemoryServer {
         }
         return result.rows.map((r) => ({ entity_id: String(r[0]), community_id: String(r[1]) }));
     }
+    async summarizeCommunities(args) {
+        await this.initPromise;
+        const minSize = Math.max(2, Math.floor(args?.min_community_size ?? 3));
+        const model = args?.model ?? "demyagent-4b-i1:Q6_K";
+        console.error("[GraphRAG] Recomputing communities before summarization...");
+        const commResult = await this.recomputeCommunities();
+        if (commResult.length === 0) {
+            return { status: "no_data", generated_summaries: 0 };
+        }
+        // Group entities by community
+        const byCommunity = new Map();
+        for (const row of commResult) {
+            const arr = byCommunity.get(row.community_id) ?? [];
+            arr.push(row.entity_id);
+            byCommunity.set(row.community_id, arr);
+        }
+        let generatedSummaries = 0;
+        const results = [];
+        for (const [communityId, entityIds] of byCommunity.entries()) {
+            if (entityIds.length < minSize)
+                continue;
+            console.error(`[GraphRAG] Summarizing community ${communityId} with ${entityIds.length} members...`);
+            // Fetch details for all entities in this community
+            const entityInfos = [];
+            for (const eId of entityIds) {
+                try {
+                    // get entity
+                    const entRes = await this.db.run('?[name, type] := *entity{id: $id, name, type, @ "NOW"}', { id: eId });
+                    if (entRes.rows.length > 0) {
+                        const name = entRes.rows[0][0];
+                        const type = entRes.rows[0][1];
+                        // get top observations for this entity
+                        const obsRes = await this.db.run('?[text, created_at] := *observation{entity_id: $id, text, created_at, @ "NOW"} :limit 3', { id: eId });
+                        const obs = obsRes.rows.map((r) => r[0]);
+                        entityInfos.push(`- ${name} (${type})` + (obs.length > 0 ? `\n  Notes: ${obs.join("; ")}` : ""));
+                    }
+                }
+                catch (e) {
+                    console.warn(`[GraphRAG] Error fetching info for ${eId}: ${e.message}`);
+                }
+            }
+            if (entityInfos.length === 0)
+                continue;
+            const systemPrompt = "You are an expert analyst. Summarize the following community of related entities into a single, cohesive 'Community Report'. Identify the overarching themes, topics, and connections between these entities. Respond ONLY with the finalized summary text.";
+            const userPrompt = `Community Size: ${entityIds.length}\n\nMembers & Notes:\n${entityInfos.join("\n")}`;
+            let summaryText = "";
+            try {
+                const ollamaMod = await import("ollama");
+                const ollamaClient = ollamaMod?.default ?? ollamaMod;
+                const response = await ollamaClient.chat({
+                    model,
+                    messages: [
+                        { role: "system", content: systemPrompt },
+                        { role: "user", content: userPrompt },
+                    ],
+                });
+                summaryText = response?.message?.content?.trim?.() ?? "";
+            }
+            catch (e) {
+                console.warn(`[GraphRAG] Ollama error for community ${communityId}: ${e.message}`);
+            }
+            if (!summaryText || summaryText === "") {
+                console.warn(`[GraphRAG] Could not generate summary for community ${communityId}, skipping.`);
+                continue;
+            }
+            // Create new CommunitySummary entity
+            const nowIso = new Date().toISOString();
+            const summaryName = `Community Summary ${communityId.slice(0, 8)} (${nowIso.slice(0, 10)})`;
+            const sumEntity = await this.createEntity({
+                name: summaryName,
+                type: "CommunitySummary",
+                metadata: {
+                    graphrag: {
+                        kind: "community_summary",
+                        community_id: communityId,
+                        member_count: entityIds.length,
+                        member_ids: entityIds,
+                        model,
+                        summarized_at: nowIso
+                    }
+                }
+            });
+            const summaryEntityId = sumEntity?.id;
+            if (summaryEntityId) {
+                await this.addObservation({
+                    entity_id: summaryEntityId,
+                    text: summaryText,
+                    metadata: {
+                        graphrag: {
+                            kind: "community_summary",
+                            community_id: communityId,
+                        }
+                    }
+                });
+                // Link the summary to all members
+                for (const memberId of entityIds) {
+                    await this.createRelation({
+                        from_id: summaryEntityId,
+                        to_id: memberId,
+                        relation_type: "summary_of",
+                        strength: 1.0,
+                        metadata: { community_id: communityId }
+                    });
+                }
+                generatedSummaries++;
+                results.push({
+                    community_id: communityId,
+                    summary_entity_id: summaryEntityId,
+                    member_count: entityIds.length
+                });
+            }
+        }
+        return {
+            status: "completed",
+            generated_summaries: generatedSummaries,
+            results
+        };
+    }
     async recomputeBetweennessCentrality() {
         await this.initPromise;
         const edgeCheckRes = await this.db.run(`?[from_id] := *relationship{from_id, @ "NOW"} :limit 1`);
@@ -1482,6 +1600,7 @@ ids[id] <- $ids
     async reflectMemory(args) {
         await this.initPromise;
         const model = args.model ?? "demyagent-4b-i1:Q6_K";
+        const mode = args.mode ?? "summary";
         const targetEntityId = args.entity_id;
         let entitiesToReflect = [];
         if (targetEntityId) {
@@ -1504,47 +1623,114 @@ ids[id] <- $ids
         }
         const results = [];
         for (const entity of entitiesToReflect) {
-            const obsRes = await this.db.run('?[text, ts] := *observation{entity_id: $id, text, created_at, @ "NOW"}, ts = to_int(created_at) :order ts', {
-                id: entity.id,
-            });
-            if (obsRes.rows.length < 2) {
-                results.push({ entity_id: entity.id, status: "skipped", reason: "Too few observations for reflection" });
-                continue;
-            }
-            const observations = obsRes.rows.map((r) => `- [${new Date(Number(r[1]) / 1000).toISOString()}] ${r[0]}`);
-            const systemPrompt = `You are an analytical memory module. Analyze the following observations about an entity. 
+            if (mode === "summary") {
+                const obsRes = await this.db.run('?[text, ts] := *observation{entity_id: $id, text, created_at, @ "NOW"}, ts = to_int(created_at) :order ts', {
+                    id: entity.id,
+                });
+                if (obsRes.rows.length < 2) {
+                    results.push({ entity_id: entity.id, status: "skipped", reason: "Too few observations for reflection" });
+                    continue;
+                }
+                const observations = obsRes.rows.map((r) => `- [${new Date(Number(r[1]) / 1000).toISOString()}] ${r[0]}`);
+                const systemPrompt = `You are an analytical memory module. Analyze the following observations about an entity. 
 Look for contradictions, temporal developments, behavioral patterns, or deeper insights. 
 Formulate a concise reflection (max. 3-4 sentences) that helps the user understand the current state or evolution.
 If there are contradictory statements, name them explicitly.
 If no special patterns are recognizable, answer with "No new insights".`;
-            const userPrompt = `Entity: ${entity.name} (${entity.type})\n\nObservations:\n${observations.join("\n")}`;
-            let reflectionText;
-            try {
-                const ollamaMod = await import("ollama");
-                const ollamaClient = ollamaMod?.default ?? ollamaMod;
-                const response = await ollamaClient.chat({
-                    model,
-                    messages: [
-                        { role: "system", content: systemPrompt },
-                        { role: "user", content: userPrompt },
-                    ],
-                });
-                reflectionText = response?.message?.content?.trim?.() ?? "";
-            }
-            catch (e) {
-                console.error(`[Reflect] Ollama error for ${entity.name}:`, e);
-                reflectionText = "";
-            }
-            if (reflectionText && reflectionText !== "No new insights" && !reflectionText.includes("No new insights")) {
-                await this.addObservation({
-                    entity_id: entity.id,
-                    text: `Reflexive insight: ${reflectionText}`,
-                    metadata: { kind: "reflection", model, generated_at: Date.now() },
-                });
-                results.push({ entity_id: entity.id, status: "reflected", insight: reflectionText });
-            }
-            else {
-                results.push({ entity_id: entity.id, status: "no_insight_found" });
+                const userPrompt = `Entity: ${entity.name} (${entity.type})\n\nObservations:\n${observations.join("\n")}`;
+                let reflectionText;
+                try {
+                    const ollamaMod = await import("ollama");
+                    const ollamaClient = ollamaMod?.default ?? ollamaMod;
+                    const response = await ollamaClient.chat({
+                        model,
+                        messages: [
+                            { role: "system", content: systemPrompt },
+                            { role: "user", content: userPrompt },
+                        ],
+                    });
+                    reflectionText = response?.message?.content?.trim?.() ?? "";
+                }
+                catch (e) {
+                    console.error(`[Reflect] Ollama error for ${entity.name}:`, e);
+                    reflectionText = "";
+                }
+                if (reflectionText && reflectionText !== "No new insights" && !reflectionText.includes("No new insights")) {
+                    await this.addObservation({
+                        entity_id: entity.id,
+                        text: `Reflexive insight: ${reflectionText}`,
+                        metadata: { kind: "reflection", model, generated_at: Date.now() },
+                    });
+                    results.push({ entity_id: entity.id, status: "reflected", insight: reflectionText });
+                }
+                else {
+                    results.push({ entity_id: entity.id, status: "no_insight_found" });
+                }
+            }
+            else if (mode === "discovery") {
+                // Discovery Mode: Find and validate new relationships
+                const candidates = await this.inferenceEngine.getRefinementCandidates(entity.id);
+                const discoveryResults = [];
+                const suggestions = [];
+                for (const candidate of candidates) {
+                    // Check if relationship already exists
+                    const existing = await this.db.run(`
+            ?[count(from_id)] := *relationship{from_id, to_id, relation_type, @ "NOW"},
+              from_id = $from, to_id = $to, relation_type = $rel
+          `, { from: candidate.from_id, to: candidate.to_id, rel: candidate.relation_type });
+                    if (Number(existing.rows[0][0]) > 0)
+                        continue;
+                    // Load target entity details for context
+                    const targetRes = await this.db.run('?[name, type] := *entity{id, name, type, @ "NOW"}, id = $id', { id: candidate.to_id });
+                    const targetName = String(targetRes.rows[0][0]);
+                    const targetType = String(targetRes.rows[0][1]);
+                    const validatePrompt = `You are a Knowledge Graph specialized AI. Evaluate if the following suggested relationship is logically sound based on the reason provided.
+Source Entity: ${entity.name} (${entity.type})
+Target Entity: ${targetName} (${targetType})
+Suggested Relationship: ${candidate.relation_type}
+Reason: ${candidate.reason}
+
+Respond with a JSON object:
+{
+  "confidence": <0.0 to 1.0>,
+  "reasoning": "<short explanation>",
+  "verdict": "create" | "suggest" | "reject"
+}
+Assign "create" if confidence > 0.8, "suggest" if confidence > 0.5, else "reject".`;
+                    try {
+                        const ollamaMod = await import("ollama");
+                        const ollamaClient = ollamaMod?.default ?? ollamaMod;
+                        const response = await ollamaClient.chat({
+                            model,
+                            messages: [{ role: "user", content: validatePrompt }],
+                            format: "json"
+                        });
+                        const validation = JSON.parse(response?.message?.content ?? "{}");
+                        if (validation.verdict === "create" && validation.confidence > 0.8) {
+                            await this.createRelation({
+                                from_id: candidate.from_id,
+                                to_id: candidate.to_id,
+                                relation_type: candidate.relation_type,
+                                strength: validation.confidence,
+                                metadata: { source: "reflection", reasoning: validation.reasoning, model }
+                            });
+                            discoveryResults.push({ target: targetName, type: candidate.relation_type, status: "created" });
+                        }
+                        else if (validation.verdict === "suggest" || validation.confidence > 0.5) {
+                            suggestions.push({
+                                from_id: candidate.from_id,
+                                to_id: candidate.to_id,
+                                relation_type: candidate.relation_type,
+                                confidence: validation.confidence,
+                                reason: validation.reasoning
+                            });
+                        }
+                    }
+                    catch (e) {
+                        console.error(`[Discovery] Validation failed for ${targetName}:`, e);
+                    }
+                }
+                results.push({ entity_id: entity.id, status: "discovery_completed", created: discoveryResults, suggestions });
             }
         }
         return { status: "completed", results };
@@ -2501,12 +2687,17 @@ Validation: Invalid syntax or missing columns in inference rules will result in
                 max_depth: zod_1.z.number().min(1).max(5).optional().default(3).describe("Maximum walking depth"),
                 limit: zod_1.z.number().optional().default(5).describe("Number of results"),
             }),
+            zod_1.z.object({
+                action: zod_1.z.literal("agentic_search"),
+                query: zod_1.z.string().describe("Context query for agentic routing"),
+                limit: zod_1.z.number().optional().default(10).describe("Maximum number of results"),
+            }),
         ]);
         const QueryMemoryParameters = zod_1.z.object({
             action: zod_1.z
-                .enum(["search", "advancedSearch", "context", "entity_details", "history", "graph_rag", "graph_walking"])
+                .enum(["search", "advancedSearch", "context", "entity_details", "history", "graph_rag", "graph_walking", "agentic_search"])
                 .describe("Action (determines which fields are required)"),
-            query: zod_1.z.string().optional().describe("Required for search/advancedSearch/context/graph_rag/graph_walking"),
+            query: zod_1.z.string().optional().describe("Required for search/advancedSearch/context/graph_rag/graph_walking/agentic_search"),
             limit: zod_1.z.number().optional().describe("Only for search/advancedSearch/graph_rag/graph_walking"),
             filters: zod_1.z.any().optional().describe("Only for advancedSearch"),
             graphConstraints: zod_1.z.any().optional().describe("Only for advancedSearch"),
@@ -2534,8 +2725,9 @@ Supported actions:
 - 'history': Retrieve historical evolution of an entity. Params: { entity_id: string }.
 - 'graph_rag': Graph-based reasoning (Hybrid RAG). Finds semantic vector seeds first, then expands via graph traversals. Ideal for multi-hop reasoning. Params: { query: string, max_depth?: number, limit?: number }.
 - 'graph_walking': Recursive semantic graph search. Starts at vector seeds or an entity and follows relationships to other semantically relevant entities. Params: { query: string, start_entity_id?: string, max_depth?: number, limit?: number }.
+- 'agentic_search': Auto-Routing Search. Uses local LLM to analyze intent and routes the query automatically to the best strategy (Vector, Graph, or Community Summaries). Params: { query: string, limit?: number }.
 
-Notes: 'context' is ideal for exploratory questions. 'search' and 'advancedSearch' are better for targeted fact retrieval.`,
+Notes: 'agentic_search' is the most powerful and adaptable, 'context' is ideal for exploratory questions. 'search' and 'advancedSearch' are better for targeted fact retrieval.`,
             parameters: QueryMemoryParameters,
             execute: async (args) => {
                 await this.initPromise;
@@ -2689,6 +2881,16 @@ Notes: 'context' is ideal for exploratory questions. 'search' and 'advancedSearc
                     };
                     return JSON.stringify(context);
                 }
+                if (input.action === "agentic_search") {
+                    if (!input.query || input.query.trim().length === 0) {
+                        return JSON.stringify({ error: "Search query must not be empty." });
+                    }
+                    const results = await this.hybridSearch.agenticRetrieve({
+                        query: input.query,
+                        limit: input.limit,
+                    });
+                    return JSON.stringify(results);
+                }
                 if (input.action === "graph_rag") {
                     if (!input.query || input.query.trim().length === 0) {
                         return JSON.stringify({ error: "Search query must not be empty." });
@@ -3165,15 +3367,21 @@ Supported actions:
                 action: zod_1.z.literal("reflect"),
                 entity_id: zod_1.z.string().optional().describe("Optional entity ID for targeted reflection"),
                 model: zod_1.z.string().optional().default("demyagent-4b-i1:Q6_K"),
+                mode: zod_1.z.enum(["summary", "discovery"]).optional().default("summary").describe("Reflection mode: 'summary' for insights, 'discovery' for new links"),
             }),
             zod_1.z.object({
                 action: zod_1.z.literal("clear_memory"),
                 confirm: zod_1.z.boolean().describe("Must be true to confirm deletion"),
             }),
+            zod_1.z.object({
+                action: zod_1.z.literal("summarize_communities"),
+                model: zod_1.z.string().optional().default("demyagent-4b-i1:Q6_K"),
+                min_community_size: zod_1.z.number().min(2).max(100).optional().default(3),
+            }),
         ]);
         const ManageSystemParameters = zod_1.z.object({
             action: zod_1.z
-                .enum(["health", "metrics", "export_memory", "import_memory", "snapshot_create", "snapshot_list", "snapshot_diff", "cleanup", "reflect", "clear_memory"])
+                .enum(["health", "metrics", "export_memory", "import_memory", "snapshot_create", "snapshot_list", "snapshot_diff", "cleanup", "reflect", "clear_memory", "summarize_communities"])
                 .describe("Action (determines which fields are required)"),
             format: zod_1.z.enum(["json", "markdown", "obsidian"]).optional().describe("Export format (for export_memory)"),
             includeMetadata: zod_1.z.boolean().optional().describe("Include metadata (for export_memory)"),
@@ -3192,8 +3400,10 @@ Supported actions:
             older_than_days: zod_1.z.number().optional().describe("Optional for cleanup"),
             max_observations: zod_1.z.number().optional().describe("Optional for cleanup"),
             min_entity_degree: zod_1.z.number().optional().describe("Optional for cleanup"),
-            model: zod_1.z.string().optional().describe("Optional for cleanup/reflect"),
+            model: zod_1.z.string().optional().describe("Optional for cleanup/reflect/summarize_communities"),
             entity_id: zod_1.z.string().optional().describe("Optional for reflect"),
+            min_community_size: zod_1.z.number().optional().describe("Optional for summarize_communities"),
+            mode: zod_1.z.enum(["summary", "discovery"]).optional().describe("Optional for reflect"),
         });
         this.mcp.addTool({
             name: "manage_system",
@@ -3217,7 +3427,8 @@ Supported actions:
   * With confirm=false: Dry-Run (shows candidates).
   * With confirm=true: Merges old/isolated fragments using LLM (Executive Summary) and removes noise.
 - 'reflect': Reflection service. Analyzes memory for contradictions and insights. Params: { entity_id?: string, model?: string }.
-- 'clear_memory': Resets the entire database. Params: { confirm: boolean (must be true) }.`,
+- 'clear_memory': Resets the entire database. Params: { confirm: boolean (must be true) }.
+- 'summarize_communities': Hierarchical GraphRAG. Generates summaries for entity clusters. Params: { model?: string, min_community_size?: number }.`,
             parameters: ManageSystemParameters,
             execute: async (args) => {
                 await this.initPromise;
@@ -3410,6 +3621,7 @@ Supported actions:
                         const result = await this.reflectMemory({
                             entity_id: input.entity_id,
                             model: input.model,
+                            mode: input.mode,
                         });
                         return JSON.stringify(result);
                     }
@@ -3417,6 +3629,18 @@ Supported actions:
                         return JSON.stringify({ error: error.message || "Error during reflection" });
                     }
                 }
+                if (input.action === "summarize_communities") {
+                    try {
+                        const result = await this.summarizeCommunities({
+                            model: input.model,
+                            min_community_size: input.min_community_size,
+                        });
+                        return JSON.stringify(result);
+                    }
+                    catch (error) {
+                        return JSON.stringify({ error: error.message || "Error during summarize_communities" });
+                    }
+                }
                 if (input.action === "clear_memory") {
                     if (!input.confirm) {
                         return JSON.stringify({ error: "Deletion not confirmed. Set 'confirm' to true." });

package/dist/inference-engine.js

@@ -28,6 +28,13 @@ class InferenceEngine {
         results.push(...custom);
         return results;
     }
+    /**
+     * Aggregates potential links from all strategies for the "discovery" mode of reflection.
+     */
+    async getRefinementCandidates(entityId) {
+        // This is essentially the same as inferRelations but explicitly for refinement
+        return this.inferRelations(entityId);
+    }
     async inferImplicitRelations(entityId) {
         const expertise = await this.findTransitiveExpertise(entityId);
         const custom = await this.applyCustomRules(entityId);

package/dist/make-old.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const uuid_1 = require("uuid");
+async function run() {
+    const server = new index_1.MemoryServer();
+    await server.initPromise;
+    console.log("Directly inserting old entity and observations via CozoDB...");
+    const fortyDaysAgo = Math.floor(Date.now() - 40 * 24 * 60 * 60 * 1000) * 1000;
+    const entityId = (0, uuid_1.v4)();
+    const name = "Very Old Project";
+    const type = "Project";
+    const metadata = { purpose: "testing janitor" };
+    const zeroVec = new Array(1024).fill(0);
+    try {
+        await server.db.run(`
+      ?[id, name, type, embedding, name_embedding, metadata, created_at] <- [[$id, $name, $type, $embedding, $name_embedding, $metadata, [$fortyDaysAgo, true]]]
+      :insert entity {id, name, type, embedding, name_embedding, metadata, created_at}
+    `, {
+            id: entityId,
+            name,
+            type,
+            embedding: zeroVec,
+            name_embedding: zeroVec,
+            metadata,
+            fortyDaysAgo
+        });
+        console.log("Old entity inserted: " + entityId);
+        const obsTexts = [
+            "This is a really old architecture note.",
+            "We decided to use subversion for version control.",
+            "The server is a physical machine in the basement.",
+            "We wrote our own ORM from scratch.",
+            "Deployment takes 3 days and a lot of manual steps."
+        ];
+        for (const text of obsTexts) {
+            const obsId = (0, uuid_1.v4)();
+            await server.db.run(`
+        ?[id, entity_id, text, embedding, metadata, created_at] <- [[$id, $entity_id, $text, $embedding, $metadata, [$fortyDaysAgo, true]]]
+        :insert observation {id, entity_id, text, embedding, metadata, created_at}
+      `, {
+                id: obsId,
+                entity_id: entityId,
+                text,
+                embedding: zeroVec,
+                metadata: {},
+                fortyDaysAgo
+            });
+            console.log("Old observation inserted: " + obsId);
+        }
+        console.log("Successfully inserted old data!");
+    }
+    catch (e) {
+        console.error("DB error:", e.message);
+    }
+    process.exit(0);
+}
+run().catch(console.error);

package/dist/test-agentic-retrieval.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function run() {
+    const server = new index_1.MemoryServer();
+    await server.initPromise;
+    console.log("Testing Agentic Retrieval Routing Logic...");
+    // Expose the protected hybridSearch for testing (TypeScript hack)
+    const hybridSearch = server.hybridSearch;
+    const queries = [
+        { text: "Welches Datenbank-System nutzt das Backend Project B?", expected: ["vector_search", "hybrid"] },
+        { text: "Wer arbeitet alles mit ReactJS oder was nutzt ReactJS?", expected: ["graph_walk", "hybrid"] },
+        { text: "Wie ist der generelle Status aller Frontend-Projekte?", expected: ["community_summary"] }
+    ];
+    for (const q of queries) {
+        console.log(`\n\n--- Query: "${q.text}" ---`);
+        console.log(`Expected Route: ${q.expected.join(" or ")}`);
+        const results = await hybridSearch.agenticRetrieve({ query: q.text, limit: 1 });
+        if (results.length > 0) {
+            console.log(`-> LLM Routed to:  ${results[0].metadata?.agentic_routing}`);
+        }
+        else {
+            console.log(`\nNo results found. LLM might have routed to an empty strategy.`);
+        }
+    }
+    process.exit(0);
+}
+run().catch(console.error);

package/dist/test-discovery.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../src/index");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+async function runTest() {
+    const testDbPath = path_1.default.resolve(__dirname, "discovery_test.cozo");
+    // Cleanup previous test DB
+    if (fs_1.default.existsSync(testDbPath + ".db"))
+        fs_1.default.unlinkSync(testDbPath + ".db");
+    const server = new index_1.MemoryServer(testDbPath);
+    await server.initPromise;
+    console.log("1. Creating test entities...");
+    const aliceRes = await server.createEntity({
+        name: "Alice",
+        type: "Person",
+        metadata: { role: "Developer" }
+    });
+    const aliceId = aliceRes.id;
+    const phoenixRes = await server.createEntity({
+        name: "Project Phoenix",
+        type: "Project",
+        metadata: { status: "active" }
+    });
+    const phoenixId = phoenixRes.id;
+    console.log("2. Adding overlapping observations...");
+    await server.addObservation({
+        entity_id: aliceId,
+        text: "Alice is currently focusing all her time on Project Phoenix."
+    });
+    console.log("3. Running reflection in 'discovery' mode...");
+    // We specify the model to ensure it uses one that supports JSON mode if possible
+    const reflectRes = await server.reflectMemory({
+        entity_id: aliceId,
+        mode: "discovery"
+    });
+    console.log("Result:", JSON.stringify(reflectRes, null, 2));
+    console.log("4. Verifying relationship creation...");
+    const relationsRes = await server.db.run(`
+    ?[to_name, rel_type] := *relationship{from_id, to_id, relation_type: rel_type, @ "NOW"},
+      from_id = $alice,
+      *entity{id: to_id, name: to_name, @ "NOW"}
+  `, { alice: aliceId });
+    console.log("Relationships from Alice:", relationsRes.rows);
+    // Cleanup
+    if (fs_1.default.existsSync(testDbPath + ".db"))
+        fs_1.default.unlinkSync(testDbPath + ".db");
+    process.exit(0);
+}
+runTest().catch(console.error);

package/dist/test-graphrag.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function run() {
+    const server = new index_1.MemoryServer();
+    await server.initPromise;
+    console.log("Setting up Test Clusters for GraphRAG Community Summaries...");
+    // Cluster 1: Frontend
+    const fe1 = await server.createEntity({ name: "ReactJS", type: "technology", metadata: {} });
+    const fe2 = await server.createEntity({ name: "Redux", type: "technology", metadata: {} });
+    const fe3 = await server.createEntity({ name: "Frontend Project A", type: "project", metadata: {} });
+    await server.addObservation({ entity_id: fe1.id, text: "ReactJS is used for building UIs." });
+    await server.addObservation({ entity_id: fe2.id, text: "Redux is used for state management in React." });
+    await server.addObservation({ entity_id: fe3.id, text: "Project A is a heavy frontend SPA using React and Redux." });
+    await server.createRelation({ from_id: fe3.id, to_id: fe1.id, relation_type: "uses", strength: 1.0 });
+    await server.createRelation({ from_id: fe3.id, to_id: fe2.id, relation_type: "uses", strength: 1.0 });
+    await server.createRelation({ from_id: fe1.id, to_id: fe2.id, relation_type: "integrates_with", strength: 1.0 });
+    console.log("Created Frontend Cluster");
+    // Cluster 2: Backend
+    const be1 = await server.createEntity({ name: "PostgreSQL", type: "database", metadata: {} });
+    const be2 = await server.createEntity({ name: "CozoDB", type: "database", metadata: {} });
+    const be3 = await server.createEntity({ name: "Backend Project B", type: "project", metadata: {} });
+    await server.addObservation({ entity_id: be1.id, text: "PostgreSQL is a robust relational database." });
+    await server.addObservation({ entity_id: be2.id, text: "CozoDB is a graph database with Datalog." });
+    await server.addObservation({ entity_id: be3.id, text: "Project B relies heavily on complex queries across PG and CozoDB." });
+    await server.createRelation({ from_id: be3.id, to_id: be1.id, relation_type: "uses", strength: 1.0 });
+    await server.createRelation({ from_id: be3.id, to_id: be2.id, relation_type: "uses", strength: 1.0 });
+    await server.createRelation({ from_id: be1.id, to_id: be2.id, relation_type: "migrating_to", strength: 1.0 });
+    console.log("Created Backend Cluster");
+    console.log("Initiating Community Summarization...");
+    const result = await server.summarizeCommunities({ min_community_size: 3 });
+    console.log("Community Summarization Result:", JSON.stringify(result, null, 2));
+    process.exit(0);
+}
+run().catch(console.error);