@riligar/agents-memories 1.2.0 → 1.4.0

package/README.md

@@ -1,12 +1,12 @@
 # RiLiGar Agents Memories
 
-A high-performance, persistent memory system for AI agents, built on the **Model Context Protocol (MCP)**. RiLiGar transforms flat data into a **Relational Knowledge Graph** featuring **Resonance Intelligence** and **Semantic Bridging**.
+A high-performance, persistent memory system for AI agents, built on the **Model Context Protocol (MCP)**. RiLiGar transforms flat data into a **Relational Knowledge Graph** featuring **Resonance Intelligence** and the **Self-Improvement Protocol (SIP)**.
 
-Now evolved into a **Modular SDK**, RiLiGar can be used both as a standalone MCP server and as a core library for cognitive applications.
+Now evolved into a **Self-improving System**, RiLiGar can be used both as a standalone MCP server and as a core library for cognitive applications.
 
-## 🧠 Philosophy: The Cognitive Self
+## 🧠 Philosophy: The Cognitive Self & SIP
 
-RiLiGar focuses on **Relational Intelligence**. Memory is not just retrieval; it is an extension of the agent's identity. By transforming memories into a living graph, the agent understands how facts are interconnected across different domains, simulating a "working memory" that evolves with every interaction.
+RiLiGar focuses on **Relational Intelligence**. Memory is not just retrieval; it is an extension of the agent's identity. With the **Self-Improvement Protocol (SIP)**, the system transitions from passive storage to active learning. By capturing the **Rationale** of every decision, the agent can mine past patterns, audit its own architecture, and evolve its skills autonomously.
 
 ---
 
@@ -84,10 +84,10 @@ console.log(results)
 
 ## 🛠️ MCP Tools Reference
 
-- `save`: Stores content with automatic priority inference and **Semantic Magnet** auto-linking.
-- `search`: Relational semantic search (Score = 60% Similarity + 40% Recency).
+- `save`: Stores content with automatic priority inference. **REQUIRED**: Include **Rationale** to enable **Pattern Mining**.
+- `search`: Relational semantic search. Essential for **Pattern Mining** and avoiding past errors (SIP).
 - `bridge`: Manually links two memory paths (e.g., `Architecture` -> `Security`).
-- `inspect`: Generates a **Mermaid.js** graph of the memory topology.
+- `inspect`: Generates a **Mermaid.js** graph. Use for **Architecture Audit (SIP)**.
 - `list`: Shows all unique memory paths.
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@riligar/agents-memories",
-    "version": "1.2.0",
+    "version": "1.4.0",
     "description": "RiLiGar Agents Memories - A self-improving relational memory system for AI agents.",
     "module": "src/index.js",
     "main": "src/index.js",
@@ -25,7 +25,8 @@
     "scripts": {
         "dev": "bun --watch src/server/index.js",
         "start": "bun src/server/index.js",
-        "test": "bun src/test.js"
+        "test": "bun src/test.js",
+        "build:pdf": "bun scripts/generate-pdf.js"
     },
     "dependencies": {
         "@huggingface/transformers": "^4.0.1",
@@ -39,6 +40,7 @@
         "@semantic-release/github": "^12.0.6",
         "@semantic-release/npm": "^13.1.5",
         "@semantic-release/release-notes-generator": "^14.1.0",
+        "md-to-pdf": "^5.2.5",
         "semantic-release": "^25.0.3"
     }
 }

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: {} },
                 },
             ],