@pentatonic-ai/openclaw-memory-plugin 0.4.7 → 0.4.9

package/index.js

@@ -243,183 +243,93 @@ export default {
     const config = api.config || {};
     const hosted = !!(config.tes_endpoint && config.tes_api_key);
     const baseUrl = config.memory_url || "http://localhost:3333";
+    const searchLimit = config.search_limit || 5;
+    const minScore = config.min_score || 0.3;
     const log = (msg) => process.stderr.write(`[pentatonic-memory] ${msg}\n`);
 
-    // --- Setup tool (always registered) ---
+    // Unified search/store that routes to local or hosted
+    const search = hosted
+      ? (query, limit, score) => hostedSearch(config, query, limit, score)
+      : (query, limit, score) => localSearch(baseUrl, query, limit, score);
 
-    api.registerTool({
-      name: "pentatonic_memory_setup",
-      description: `Guide the user through setting up Pentatonic Memory.
+    const store = hosted
+      ? (content, metadata) => hostedStore(config, content, metadata)
+      : (content, metadata) => localStore(baseUrl, content, metadata);
 
-Two modes:
-1. "local" — fully private, Docker-based (PostgreSQL + pgvector + Ollama). No cloud.
-2. "hosted" — Pentatonic TES cloud. Team-wide shared memory, analytics, higher-dimensional embeddings.
+    // --- Context engine: always registered, proxies to backend ---
+    // Methods return graceful empty results if backend is unavailable.
 
-Call this to get instructions for the user's chosen mode.`,
-      parameters: {
-        type: "object",
-        properties: {
-          mode: { type: "string", enum: ["local", "hosted"], description: "Which mode the user wants" },
-        },
-        required: ["mode"],
+    api.registerContextEngine("pentatonic-memory", () => ({
+      info: {
+        id: "pentatonic-memory",
+        name: `Pentatonic Memory (${hosted ? "Hosted" : "Local"})`,
+        ownsCompaction: false,
       },
-      async execute({ mode }) {
-        if (mode === "local") {
-          return `## Local Memory Setup
-
-Run in terminal:
-\`\`\`
-npx @pentatonic-ai/ai-agent-sdk memory
-\`\`\`
-
-This starts PostgreSQL + pgvector, Ollama, and the memory server via Docker.
-
-Then add to openclaw.json:
-\`\`\`json
-{
-  "plugins": {
-    "slots": { "contextEngine": "pentatonic-memory" },
-    "entries": {
-      "pentatonic-memory": {
-        "enabled": true,
-        "config": { "memory_url": "http://localhost:3333" }
-      }
-    }
-  }
-}
-\`\`\`
 
-Restart OpenClaw to activate.`;
+      async ingest({ sessionId, message }) {
+        if (!message?.content) return { ingested: false };
+        const role = message.role || message.type;
+        if (role !== "user" && role !== "assistant") return { ingested: false };
+        try {
+          await store(message.content, { session_id: sessionId, role });
+          return { ingested: true };
+        } catch {
+          return { ingested: false };
         }
-        return `## Hosted TES Setup
-
-Run in terminal:
-\`\`\`
-npx @pentatonic-ai/ai-agent-sdk init
-\`\`\`
-
-This creates a TES account and generates API credentials.
-
-Then add to openclaw.json:
-\`\`\`json
-{
-  "plugins": {
-    "slots": { "contextEngine": "pentatonic-memory" },
-    "entries": {
-      "pentatonic-memory": {
-        "enabled": true,
-        "config": {
-          "tes_endpoint": "https://your-company.api.pentatonic.com",
-          "tes_client_id": "your-company",
-          "tes_api_key": "tes_your-company_xxxxx"
+      },
+
+      async assemble({ sessionId, messages }) {
+        const lastUserMsg = [...messages].reverse().find((m) => m.role === "user" || m.type === "user");
+        if (!lastUserMsg?.content) return { messages, estimatedTokens: 0 };
+        try {
+          const results = await search(lastUserMsg.content, searchLimit, minScore);
+          if (!results.length) return { messages, estimatedTokens: 0 };
+          const memoryText = results
+            .map((m) => `- [${Math.round((m.similarity || 0) * 100)}%] ${m.content}`)
+            .join("\n");
+          const addition = `[Memory] Relevant context from past conversations:\n${memoryText}`;
+          return { messages, estimatedTokens: Math.ceil(addition.length / 4), systemPromptAddition: addition };
+        } catch {
+          return { messages, estimatedTokens: 0 };
         }
-      }
-    }
-  }
-}
-\`\`\`
+      },
+
+      async compact() { return { ok: true, compacted: false }; },
+      async afterTurn() {},
+    }));
 
-Restart OpenClaw to activate.`;
+    // --- Tools: agent-driven search and store ---
+
+    api.registerTool({
+      name: "memory_search",
+      description: "Search memories for relevant context. Use when you need to recall past conversations, decisions, or knowledge.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "What to search for" },
+          limit: { type: "number", description: "Max results (default 5)" },
+        },
+        required: ["query"],
+      },
+      async execute({ query, limit }) {
+        return formatResults(await search(query, limit || 5, 0.3));
       },
     });
 
-    // --- Mode-specific registration ---
-
-    if (hosted) {
-      log("Hosted mode — routing through TES");
-
-      api.registerContextEngine("pentatonic-memory", () =>
-        createHostedContextEngine(config, {
-          searchLimit: config.search_limit || 5,
-          minScore: config.min_score || 0.3,
-          logger: log,
-        })
-      );
-
-      api.registerTool({
-        name: "memory_search",
-        description: "Search memories for relevant context.",
-        parameters: {
-          type: "object",
-          properties: {
-            query: { type: "string", description: "What to search for" },
-            limit: { type: "number", description: "Max results (default 5)" },
-          },
-          required: ["query"],
-        },
-        async execute({ query, limit }) {
-          return formatResults(await hostedSearch(config, query, limit || 5, 0.3));
-        },
-      });
-
-      api.registerTool({
-        name: "memory_store",
-        description: "Explicitly store something important.",
-        parameters: {
-          type: "object",
-          properties: { content: { type: "string", description: "What to remember" } },
-          required: ["content"],
-        },
-        async execute({ content }) {
-          const result = await hostedStore(config, content, { source: "openclaw-tool" });
-          return result ? "Memory stored." : "Failed to store memory.";
-        },
-      });
-    } else {
-      // Local mode — HTTP to memory server
-      const isConfigured = config.memory_url || config.database_url;
-
-      if (isConfigured) {
-        log(`Local mode — ${baseUrl}`);
-
-        // Check if server is reachable on startup
-        localHealth(baseUrl).then((ok) => {
-          if (!ok) log(`Warning: memory server not reachable at ${baseUrl}. Is Docker running?`);
-        });
-
-        api.registerContextEngine("pentatonic-memory", () =>
-          createLocalContextEngine(baseUrl, {
-            searchLimit: config.search_limit || 5,
-            minScore: config.min_score || 0.3,
-            logger: log,
-          })
-        );
-
-        api.registerTool({
-          name: "memory_search",
-          description: "Search memories for relevant context.",
-          parameters: {
-            type: "object",
-            properties: {
-              query: { type: "string", description: "What to search for" },
-              limit: { type: "number", description: "Max results (default 5)" },
-            },
-            required: ["query"],
-          },
-          async execute({ query, limit }) {
-            return formatResults(await localSearch(baseUrl, query, limit || 5, 0.3));
-          },
-        });
-
-        api.registerTool({
-          name: "memory_store",
-          description: "Explicitly store something important.",
-          parameters: {
-            type: "object",
-            properties: { content: { type: "string", description: "What to remember" } },
-            required: ["content"],
-          },
-          async execute({ content }) {
-            const result = await localStore(baseUrl, content, { source: "openclaw-tool" });
-            return result ? `Stored: ${result.id}` : "Failed to store memory.";
-          },
-        });
-      } else {
-        log("No config — setup tool available. Tell OpenClaw: 'set up pentatonic memory'");
-      }
-    }
+    api.registerTool({
+      name: "memory_store",
+      description: "Explicitly store something important. Use for decisions, solutions, or facts worth remembering.",
+      parameters: {
+        type: "object",
+        properties: { content: { type: "string", description: "What to remember" } },
+        required: ["content"],
+      },
+      async execute({ content }) {
+        const result = await store(content, { source: "openclaw-tool" });
+        return result ? "Memory stored." : "Failed to store memory.";
+      },
+    });
 
-    const mode = hosted ? "hosted" : (config.memory_url || config.database_url) ? "local" : "unconfigured";
-    log(`Plugin registered (${mode})`);
+    log(`Plugin registered (${hosted ? "hosted" : "local"} — ${hosted ? config.tes_endpoint : baseUrl})`);
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pentatonic-ai/openclaw-memory-plugin",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "Pentatonic Memory plugin for OpenClaw — persistent, searchable memory with multi-signal retrieval and HyDE query expansion",
   "type": "module",
   "main": "index.js",