@levalicious/server-memory 0.0.17 → 0.0.19

package/dist/server.js

@@ -953,7 +953,7 @@ export function createServer(memoryFilePath) {
                 sizes: ["any"]
             }
         ],
-        version: "0.0.17",
+        version: "0.0.19",
     }, {
         capabilities: {
             tools: {},
@@ -1276,7 +1276,7 @@ Use this to build chains of reasoning that persist in the graph. Each thought ca
                 },
                 {
                     name: "kb_load",
-                    description: `Load a plaintext document into the knowledge graph. Chunks the text into entities connected by a doubly-linked chain, runs sentence TextRank to identify the most important sentences, and creates an index entity that links directly to the chunks containing those sentences.
+                    description: `Load a plaintext document into the knowledge graph. Chunks the text into entities connected by a doubly-linked chain, runs sentence TextRank to identify the most important sentences, and creates an index entity per key phrase that links directly to the chunk containing that sentence.
 
 The file MUST be plaintext (.txt, .tex, .md, source code, etc.). For PDFs, use pdftotext first. For other binary formats, convert to text before calling this tool.`,
                     inputSchema: {

package/dist/src/kb_load.js

@@ -317,28 +317,18 @@ export function loadDocument(text, title, st, topK = 15) {
         seenChunks.add(chunk.id);
         highlights.push({ chunk, sentence, score });
     }
-    // 6. Build index observations (compressed sentence previews)
-    const indexId = `${title}__index`;
-    const indexObs = [];
-    let current = '';
-    for (const { sentence } of highlights) {
-        const preview = sentence.text.length > 60
-            ? sentence.text.slice(0, 57) + '...'
-            : sentence.text;
-        const candidate = current ? current + ' | ' + preview : preview;
-        if (candidate.length <= MAX_OBS_LENGTH) {
-            current = candidate;
-        }
-        else {
-            if (current)
-                indexObs.push(current);
-            if (indexObs.length >= MAX_OBS_PER_ENTITY)
-                break;
-            current = preview.length <= MAX_OBS_LENGTH ? preview : preview.slice(0, MAX_OBS_LENGTH);
-        }
+    // 6. Build index entities — one per highlighted phrase
+    //    Each DocumentIndex entity holds a single extracted key phrase as its
+    //    observation, and links to the chunk that contains it. This gives the
+    //    walker discrete semantic entry points into the document chain.
+    const indexEntities = [];
+    for (const { chunk, sentence } of highlights) {
+        const phrase = sentence.text.length <= MAX_OBS_LENGTH
+            ? sentence.text
+            : sentence.text.slice(0, MAX_OBS_LENGTH - 3) + '...';
+        const indexId = `${title}__idx_${indexEntities.length}`;
+        indexEntities.push({ id: indexId, phrase, chunk });
     }
-    if (current && indexObs.length < MAX_OBS_PER_ENTITY)
-        indexObs.push(current);
     // ─── Assemble entities ──────────────────────────────────────────
     const entities = [];
     const relations = [];
@@ -352,12 +342,17 @@ export function loadDocument(text, title, st, topK = 15) {
             observations: chunk.observations.map(o => o.text),
         });
     }
-    // Index entity
-    entities.push({
-        name: indexId,
-        entityType: 'DocumentIndex',
-        observations: indexObs,
-    });
+    // Index entities — one per key phrase
+    for (const idx of indexEntities) {
+        entities.push({
+            name: idx.id,
+            entityType: 'DocumentIndex',
+            observations: [idx.phrase],
+        });
+    }
+    // Index hub — empty structural node linking Document to index entries
+    const indexHubId = `${title}__index`;
+    entities.push({ name: indexHubId, entityType: 'DocumentIndex', observations: [] });
     // ─── Assemble relations ─────────────────────────────────────────
     // Document → chain endpoints
     if (chunks.length > 0) {
@@ -373,13 +368,18 @@ export function loadDocument(text, title, st, topK = 15) {
         relations.push({ from: chunks[i].id, to: chunks[i + 1].id, relationType: 'follows' });
         relations.push({ from: chunks[i + 1].id, to: chunks[i].id, relationType: 'preceded_by' });
     }
-    // Document → index
-    relations.push({ from: title, to: indexId, relationType: 'has_index' });
-    relations.push({ from: indexId, to: title, relationType: 'indexes' });
-    // Index → highlighted chunks
-    for (const { chunk } of highlights) {
-        relations.push({ from: indexId, to: chunk.id, relationType: 'highlights' });
-        relations.push({ from: chunk.id, to: indexId, relationType: 'highlighted_by' });
+    // Document → index hub
+    relations.push({ from: title, to: indexHubId, relationType: 'has_index' });
+    relations.push({ from: indexHubId, to: title, relationType: 'indexes' });
+    // Index hub → index entries
+    for (const idx of indexEntities) {
+        relations.push({ from: indexHubId, to: idx.id, relationType: 'contains' });
+        relations.push({ from: idx.id, to: indexHubId, relationType: 'contained_in' });
+    }
+    // Index entries → highlighted chunks
+    for (const idx of indexEntities) {
+        relations.push({ from: idx.id, to: idx.chunk.id, relationType: 'highlights' });
+        relations.push({ from: idx.chunk.id, to: idx.id, relationType: 'highlighted_by' });
     }
     return {
         entities,

package/dist/tests/memory-server.test.js

@@ -1068,10 +1068,17 @@ describe('MCP Memory Server E2E Tests', () => {
             const docResult = await callTool(client, 'open_nodes', { names: ['test-doc'] });
             expect(docResult.entities.items).toHaveLength(1);
             expect(docResult.entities.items[0].entityType).toBe('Document');
-            // Check index entity
-            const indexResult = await callTool(client, 'open_nodes', { names: ['test-doc__index'] });
-            expect(indexResult.entities.items).toHaveLength(1);
-            expect(indexResult.entities.items[0].entityType).toBe('DocumentIndex');
+            // Check index entities — one hub (0 observations) + entries (1 observation each)
+            const indexEntities = await callTool(client, 'get_entities_by_type', { entityType: 'DocumentIndex' });
+            expect(indexEntities.items.length).toBeGreaterThan(1);
+            const hub = indexEntities.items.filter(e => e.observations.length === 0);
+            const entries = indexEntities.items.filter(e => e.observations.length > 0);
+            expect(hub).toHaveLength(1);
+            expect(entries.length).toBeGreaterThan(0);
+            for (const entry of entries) {
+                expect(entry.observations.length).toBe(1);
+                expect(entry.observations[0].length).toBeLessThanOrEqual(140);
+            }
             // Check TextChunk entities exist via type query
             const chunks = await callTool(client, 'get_entities_by_type', { entityType: 'TextChunk' });
             expect(chunks.items.length).toBeGreaterThan(0);
@@ -1103,8 +1110,11 @@ describe('MCP Memory Server E2E Tests', () => {
             await fs.writeFile(docFile, sentences.join(' '));
             const result = await callTool(client, 'kb_load', { filePath: docFile });
             expect(result.stats.indexHighlights).toBeGreaterThan(0);
-            // Open the index and verify it has highlight relations
-            const indexResult = await callTool(client, 'open_nodes', { names: ['test-doc__index'] });
+            // Find index entities and verify they have highlight relations
+            const indexEntities = await callTool(client, 'get_entities_by_type', { entityType: 'DocumentIndex' });
+            expect(indexEntities.items.length).toBeGreaterThan(0);
+            const indexNames = indexEntities.items.map(e => e.name);
+            const indexResult = await callTool(client, 'open_nodes', { names: indexNames });
             const highlightRels = indexResult.relations.items.filter(r => r.relationType === 'highlights');
             expect(highlightRels.length).toBeGreaterThan(0);
         });
@@ -1123,7 +1133,7 @@ describe('MCP Memory Server E2E Tests', () => {
             await callTool(client, 'kb_load', { filePath: docFile });
             // Second load with different content but same title — Document entity
             // already exists with entityType 'Document' and no observations,
-            // so it gets silently skipped. But the index entity already exists
+            // so it gets silently skipped. But the index entities already exist
             // with different observations, so it should error.
             await fs.writeFile(docFile, 'Completely different content for dedup testing now.');
             await expect(callTool(client, 'kb_load', { filePath: docFile })).rejects.toThrow(/already exists/);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levalicious/server-memory",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "MCP server for enabling memory for Claude through a knowledge graph",
   "license": "MIT",
   "author": "Levalicious",