@riligar/agents-memories 1.3.0 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@riligar/agents-memories",
-    "version": "1.3.0",
+    "version": "1.4.1",
     "description": "RiLiGar Agents Memories - A self-improving relational memory system for AI agents.",
     "module": "src/index.js",
     "main": "src/index.js",

package/src/core/logic.js

@@ -19,7 +19,7 @@ export async function getEmbedding(text) {
 export async function inferPriority(db, vector) {
     const result = await db.execute({
         sql: `SELECT priority, vector_distance_cos(embedding, ?) as distance FROM memories ORDER BY distance ASC LIMIT 5`,
-        args: [vector.buffer],
+        args: [Buffer.from(vector.buffer)],
     })
     if (result.rows.length === 0) return 5
     let weightedSum = 0,
@@ -39,7 +39,7 @@ export async function inferPriority(db, vector) {
 export async function propagateRipple(db, vector, manualPriority) {
     const result = await db.execute({
         sql: `SELECT id, priority, vector_distance_cos(embedding, ?) as distance FROM memories ORDER BY distance ASC LIMIT 5`,
-        args: [vector.buffer],
+        args: [Buffer.from(vector.buffer)],
     })
     for (const row of result.rows) {
         const similarity = 1 - row.distance
@@ -56,7 +56,7 @@ export async function propagateRipple(db, vector, manualPriority) {
 export async function findClosestNeighbor(db, vector) {
     const result = await db.execute({
         sql: `SELECT id, path, vector_distance_cos(embedding, ?) as distance FROM memories ORDER BY distance ASC LIMIT 1`,
-        args: [vector.buffer],
+        args: [Buffer.from(vector.buffer)],
     })
     return result.rows[0] || null
 }

package/src/sdk/memory-system.js

@@ -42,7 +42,7 @@ export class MemorySystem {
 
       const insertRes = await this.db.execute({
         sql: `INSERT INTO memories (content, path, embedding, owner_id, priority) VALUES (?, ?, ?, ?, ?) RETURNING id`,
-        args: [mem.content, path, vector.buffer, ownerId, finalPriority],
+        args: [mem.content, path, Buffer.from(vector.buffer), ownerId, finalPriority],
       })
       const newId = insertRes.rows[0].id
 
@@ -67,7 +67,7 @@ export class MemorySystem {
   async search(args) {
     const vector = await getEmbedding(args.query)
     let sql = `SELECT id, content, path, priority, created_at, vector_distance_cos(embedding, ?) as distance FROM memories`
-    const queryArgs = [vector.buffer], filters = []
+    const queryArgs = [Buffer.from(vector.buffer)], filters = []
     
     if (args.path_filter) {
       filters.push(`path LIKE ?`)

package/src/server/mcp-server.js

@@ -21,64 +21,65 @@ export function createMcpServer(memorySystem) {
             tools: [
                 {
                     name: 'save',
-                    description: 'Saves info with Resonance and Auto-Bridging. SIP Note: Capture the Rationale (the "Why") to enable Pattern Mining.',
+                    description: 'Primary "CAPTURE" tool for the RiLiGar Self-Improvement Protocol (SIP). Saves information into the Relational Knowledge Graph using Resonance Intelligence and Auto-Bridging. IMPORTANT: Always include the "Rationale" (the "Why") within the content to enable future Pattern Mining. Supports batch saving via arrays.',
                     inputSchema: {
                         type: 'object',
                         properties: {
                             content: {
+                                description: 'The information to persist. For architectural decisions, include the technical Rationale.',
                                 oneOf: [
                                     { type: 'string' }, 
                                     { type: 'array', items: { anyOf: [
                                         { type: 'string' }, 
                                         { type: 'object', properties: { 
-                                            content: { type: 'string' }, 
-                                            path: { type: 'string' }, 
-                                            owner_id: { type: 'string' }, 
-                                            priority: { type: 'integer' } 
+                                            content: { type: 'string', description: 'The main data/lesson/decision text.' }, 
+                                            path: { type: 'string', description: 'Dot-notation path (e.g., Project.Architecture.Storage).' }, 
+                                            owner_id: { type: 'string', description: 'Agent/User identity for ownership.' }, 
+                                            priority: { type: 'integer', description: 'Base priority (0-10) for Resonance rippling.' } 
                                         }, required: ['content'] }
                                     ] } }
                                 ],
                             },
-                            path: { type: 'string' },
-                            owner_id: { type: 'string' },
-                            priority: { type: 'integer' },
+                            path: { type: 'string', description: 'Hierarchical path (e.g., Self.Ethics.Protocol or Patterns.SOTA.Elysia).' },
+                            owner_id: { type: 'string', description: 'Identity string of the memory owner.' },
+                            priority: { type: 'integer', description: 'Initial importance; triggers priority adjustment in semantic neighbors.' },
                         },
                         required: ['content'],
                     },
                 },
                 {
                     name: 'bridge',
-                    description: 'Manually connects two memory paths.',
+                    description: 'Establish explicit "Relational Intelligence" by connecting two disparate memory paths. Use this to document logical dependencies (depends_on), hierarchies (part_of), or implementation requirements that semantic similarity might not immediately detect.',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            source_path: { type: 'string' },
-                            target_path: { type: 'string' },
-                            relation: { type: 'string', default: 'related_to' },
+                            source_path: { type: 'string', description: 'The origin path of the relationship.' },
+                            target_path: { type: 'string', description: 'The destination path of the relationship.' },
+                            relation: { type: 'string', default: 'related_to', description: 'The type of connection: depends_on, part_of, implements, conflicts_with, etc.' },
                         },
                         required: ['source_path', 'target_path'],
                     },
                 },
                 {
                     name: 'search',
-                    description: 'Semantic search with Relational Awareness. Use for Pattern Mining and Error Avoidance (SIP).',
+                    description: 'Execute "Reflexive Cognition". Performs a Relational Semantic Search across memories. Agents MUST use this proactively before complex tasks to find past "Lessons Learned", "Rationales", or "Errors" related to the current context. Results are ranked by Similarity (60%) and Recency (40%).',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            query: { type: 'string' },
-                            path_filter: { type: 'string' },
+                            query: { type: 'string', description: 'Semantic search query (e.g., "how we optimized sidebar storage").' },
+                            path_filter: { type: 'string', description: 'Filter by path prefix (e.g., "Project.Architecture").' },
                         },
                         required: ['query'],
                     },
                 },
                 {
                     name: 'inspect',
-                    description: 'Visualizes the Knowledge Graph in Mermaid.js syntax. Use for Architecture Audit (SIP).',
+                    description: 'Visualize the Relational Knowledge Graph in Mermaid.js syntax. Critical for the "Self-Critique" phase of SIP. Use it to audit system architecture, browse cognitive connections, and ensure no architectural drift has occurred.',
                     inputSchema: { type: 'object', properties: {} },
                 },
                 {
                     name: 'list',
-                    description: 'Lists all memory paths.',
+                    description: 'List all unique memory paths (namespace discovery). Use this to explore the hierarchy and understand the available knowledge domains before performing targeted searches or saves.',
                     inputSchema: { type: 'object', properties: {} },
                 },
             ],