memorylake-openclaw 1.0.0 → 1.0.2-beta.1

package/docs/openclaw.mdx

@@ -54,7 +54,7 @@ The agent gets eight tools it can call during conversations:
 | `memory_forget` | Delete a memory by ID |
 | `document_search` | Search project documents for relevant paragraphs, tables, and figures |
 | `advanced_web_search` | Optional web search tool backed by the unified search API with plugin-level domain and locale constraints |
-| `open_data_search` | Optional search across open datasets — academic, clinical, drug, financial, economic, and more — routed to the appropriate proprietary data source based on the `dataset` field |
+| `open_data_search` | Search across open datasets — academic, clinical, drug, financial, economic, and more — routed to the appropriate proprietary data source based on the `dataset` field |
 
 <Note>`open_data_search` requires the project to have at least one open data industry configured in MemoryLake. The `dataset` parameter is required and validated against the project's subscribed datasets at call time. The agent is automatically informed of available datasets via context injection at the start of each session. Supported datasets: `research/academic`, `clinical/trials`, `drug/database`, `financial/markets`, `company/fundamentals`, `economic/data`, `patents/ip`.</Note>
 
@@ -86,7 +86,7 @@ openclaw memorylake stats
 | `webSearchCountry` | `string` | — | Optional ISO country code for localizing `advanced_web_search` |
 | `webSearchTimezone` | `string` | — | Optional IANA timezone for localizing `advanced_web_search` |
 
-<Note>`advanced_web_search` and `open_data_search` are registered as optional OpenClaw tools, so they must be explicitly allowed before an agent can call them.</Note>
+<Note>`advanced_web_search` is registered as an optional OpenClaw tool, so it must be explicitly allowed before an agent can call it.</Note>
 
 ## Key Features
 
@@ -98,7 +98,7 @@ openclaw memorylake stats
 
 ## Conclusion
 
-The `memorylake-openclaw` plugin gives OpenClaw agents persistent memory with minimal setup. Your agents can remember user preferences, facts, and context across sessions automatically — and optionally search across a wide range of open datasets when deeper external knowledge is needed.
+The `memorylake-openclaw` plugin gives OpenClaw agents persistent memory with minimal setup. Your agents can remember user preferences, facts, and context across sessions automatically — and search across a wide range of open datasets when deeper external knowledge is needed.
 
 {/*<CardGroup cols={2}>
   <Card title="MemoryLake" icon="brain" href="https://app.memorylake.ai">

package/index.ts

@@ -4,7 +4,7 @@
  * Long-term memory via MemoryLake platform.
  *
  * Features:
- * - 8 tools: memory_search, memory_list, memory_store, memory_get, memory_forget, document_search, advanced_web_search, open_data_search
+ * - 9 tools: memory_search, memory_list, memory_store, memory_get, memory_forget, document_search, document_download, advanced_web_search, open_data_search
  * - Auto-recall: injects relevant memories and document excerpts before each agent turn
  * - Auto-capture: stores key facts scoped to the current session after each agent turn
  * - CLI: openclaw memorylake search, openclaw memorylake stats
@@ -293,6 +293,7 @@ interface MemoryLakeProvider {
   getAll(options: ListOptions): Promise<MemoryItem[]>;
   delete(memoryId: string): Promise<void>;
   searchDocuments(query: string, topN: number): Promise<DocumentSearchResponse>;
+  getDocumentDownloadUrl(documentId: string): Promise<string>;
   searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse>;
   searchOpenData(query: string, options: OpenDataSearchOptions): Promise<OpenDataSearchResponse>;
   getProject(): Promise<ProjectInfo>;
@@ -418,6 +419,24 @@ class PlatformProvider implements MemoryLakeProvider {
     };
   }
 
+  async getDocumentDownloadUrl(documentId: string): Promise<string> {
+    const downloadPath = `openapi/memorylake/api/v1/projects/${this.projectId}/documents/${documentId}/download`;
+    const resp = await this.http.get(downloadPath, {
+      followRedirect: false,
+      responseType: "text" as any,
+      throwHttpErrors: false,
+    });
+    if (resp.statusCode === 303 || resp.statusCode === 302) {
+      const location = resp.headers.location;
+      if (!location) throw new Error("Download redirect missing Location header");
+      return location;
+    }
+    if (resp.statusCode === 404) {
+      throw new Error(`Document not found: ${documentId}`);
+    }
+    throw new Error(`Unexpected download response status: ${resp.statusCode}`);
+  }
+
   async searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse> {
     const domain = options.domain != null ? normalizeWebSearchDomain(options.domain) : "web";
     const body: Record<string, unknown> = {
@@ -569,11 +588,12 @@ function buildDocumentContext(
 
   for (const result of results) {
     const source = result.document_name ?? result.source_document?.file_name ?? "unknown";
+    const docId = result.document_id ?? "unknown";
     const highlight = result.highlight;
 
     if (result.type === "table") {
       const title = result.title || "Untitled Table";
-      parts.push(`### Table: ${title} (from ${source})`);
+      parts.push(`### Table: ${title} (from ${source}, doc_id: ${docId})`);
       if (result.footnote) parts.push(`Note: ${result.footnote}`);
 
       for (const innerTable of highlight?.inner_tables ?? []) {
@@ -587,14 +607,14 @@ function buildDocumentContext(
         if (chunk.text) parts.push(chunk.text.slice(0, maxChunkLength));
       }
     } else if (result.type === "paragraph") {
-      parts.push(`### Paragraph (from ${source}):`);
+      parts.push(`### Paragraph (from ${source}, doc_id: ${docId}):`);
       for (const chunk of highlight?.chunks ?? []) {
         if (chunk.text) parts.push(chunk.text.slice(0, maxChunkLength));
       }
     } else if (result.type === "figure") {
       const figure = highlight?.figure;
       if (figure) {
-        parts.push(`### Figure (from ${source}):`);
+        parts.push(`### Figure (from ${source}, doc_id: ${docId}):`);
         if (figure.caption) parts.push(`Caption: ${figure.caption}`);
         const text = figure.text || figure.summary_text || "";
         if (text) parts.push(text);
@@ -820,6 +840,62 @@ const memoryPlugin = {
     // Cache project industries per session — fetched once, reused on subsequent prompts
     const sessionIndustriesCache = new Map<string, OpenDataIndustry[]>();
 
+    // ========================================================================
+    // System Prompt: Memory Section (injected into every system prompt)
+    // ========================================================================
+    api.registerMemoryPromptSection((params) => {
+      const lines: string[] = [
+        "## Memory (MANDATORY — MemoryLake)",
+        "",
+        "You have access to MemoryLake, a long-term memory system that stores the user's preferences, history, personal context, and uploaded documents across sessions.",
+        "",
+      ];
+
+      if (params.availableTools.has("memory_search")) {
+        lines.push(
+          "### memory_search — MUST be called BEFORE every response",
+          "",
+          "**RULE: Your FIRST action for EVERY user message MUST be calling `memory_search`.** No exceptions.",
+          "",
+          "This tool searches BOTH memories AND documents in one call. It returns personal context (preferences, history, decisions) and relevant document excerpts (uploaded files, tables, figures).",
+          "",
+          "This applies to ALL types of questions, not just questions about memory or recall:",
+          "- Greetings -> search for who the user is",
+          "- Recommendations (books, activities, food) -> search for preferences and interests",
+          "- Advice (what to wear, what to eat) -> search for habits, location, preferences",
+          "- Tasks (write an email, self-introduction) -> search for user name, role, background",
+          "- Document questions -> search for relevant uploaded document content",
+          "- General chat -> search for recent context and ongoing topics",
+          "",
+          "Derive a broad query from the user's message. For example:",
+          "- User asks for a book recommendation -> search: reading preferences favorite books",
+          "- User asks about weekend plans -> search: hobbies interests weekend activities",
+          "- User says hello -> search: user name background recent context",
+          "",
+          "**If you respond without calling memory_search first, your response is WRONG.**",
+          "",
+        );
+      }
+
+      if (params.availableTools.has("memory_list")) {
+        lines.push(
+          "### memory_list",
+          "- When the user asks what you remember or wants to see all stored memories, call `memory_list`.",
+          "",
+        );
+      }
+
+      if (params.availableTools.has("memory_forget")) {
+        lines.push(
+          "### memory_forget",
+          "- When the user explicitly asks to delete or forget a specific memory, call `memory_forget` with the memory ID.",
+          "",
+        );
+      }
+
+      return lines;
+    });
+
     api.logger.info(
       `memorylake-openclaw: registered (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture}, autoUpload: ${cfg.autoUpload})`,
     );
@@ -858,7 +934,7 @@ const memoryPlugin = {
         name: "memory_search",
         label: "Memory Search",
         description:
-          "Search through long-term memories stored in MemoryLake. Use when you need context about user preferences, past decisions, or previously discussed topics.",
+          "MANDATORY: Search through long-term memories AND uploaded documents stored in MemoryLake. You MUST call this tool at the start of every conversation to recall the user's context, preferences, past decisions, previously discussed topics, and relevant document content. Always search before answering.",
         parameters: Type.Object({
           query: Type.String({ description: "Search query" }),
           limit: Type.Optional(
@@ -893,54 +969,65 @@ const memoryPlugin = {
             scope?: "session" | "long-term" | "all";
           };
 
-          try {
-            const results = await effectiveProvider.search(
+          const [memoryResult, docResult] = await Promise.allSettled([
+            effectiveProvider.search(
               query,
               buildSearchOptions(effectiveCfg, userId, limit),
-            );
+            ),
+            effectiveProvider.searchDocuments(query, effectiveCfg.topK),
+          ]);
 
-            if (!results || results.length === 0) {
-              return {
-                content: [
-                  { type: "text", text: "No relevant memories found." },
-                ],
-                details: { count: 0 },
-              };
-            }
+          const sections: string[] = [];
+          let memoryCount = 0;
+          let docCount = 0;
+          let sanitizedMemories: { id: string; content: string; created_at: string }[] = [];
 
+          if (memoryResult.status === "fulfilled" && memoryResult.value.length > 0) {
+            const results = memoryResult.value;
+            memoryCount = results.length;
             const text = results
-              .map(
-                (r, i) =>
-                  `${i + 1}. ${r.content} (id: ${r.id})`,
-              )
+              .map((r, i) => `${i + 1}. ${r.content} (id: ${r.id})`)
               .join("\n");
-
-            const sanitized = results.map((r) => ({
+            sections.push(`## Memories\nFound ${results.length} memories:\n\n${text}`);
+            sanitizedMemories = results.map((r) => ({
               id: r.id,
               content: r.content,
               created_at: r.created_at,
             }));
+          } else if (memoryResult.status === "rejected") {
+            sections.push(`## Memories\nMemory search failed: ${String(memoryResult.reason)}`);
+          }
 
+          if (docResult.status === "fulfilled" && docResult.value.results.length > 0) {
+            docCount = docResult.value.results.length;
+            const context = buildDocumentContext(docResult.value.results);
+            sections.push(`## Documents\nFound ${docCount} document results:\n\n${context}`);
+          } else if (docResult.status === "rejected") {
+            sections.push(`## Documents\nDocument search failed: ${String(docResult.reason)}`);
+          }
+
+          if (memoryCount === 0 && docCount === 0) {
             return {
               content: [
-                {
-                  type: "text",
-                  text: `Found ${results.length} memories:\n\n${text}`,
-                },
-              ],
-              details: { count: results.length, memories: sanitized },
-            };
-          } catch (err) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Memory search failed: ${String(err)}`,
-                },
+                { type: "text", text: "No relevant memories or documents found." },
               ],
-              details: { error: String(err) },
+              details: { count: 0 },
             };
           }
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: sections.join("\n\n"),
+              },
+            ],
+            details: {
+              memoryCount,
+              documentCount: docCount,
+              memories: sanitizedMemories,
+            },
+          };
         },
       }),
       { name: "memory_search" },
@@ -1233,6 +1320,55 @@ const memoryPlugin = {
       { name: "document_search" },
     );
 
+    api.registerTool(
+      (ctx) => ({
+        name: "document_download",
+        label: "Document Download",
+        description:
+          "Download a document (image, PDF, etc.) from MemoryLake and send it to the user. Returns a temporary download URL. Use document_search first to find the document_id.",
+        parameters: Type.Object({
+          documentId: Type.String({
+            description:
+              "The document ID to download (from document_search results or document listing)",
+          }),
+        }),
+        async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
+          const { documentId } = params as { documentId: string };
+
+          try {
+            const downloadUrl =
+              await effectiveProvider.getDocumentDownloadUrl(documentId);
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Document ${documentId} is ready. Tell the user you are sending the file now.\nMEDIA: ${downloadUrl}`,
+                },
+              ],
+              details: {
+                media: { mediaUrl: downloadUrl },
+                documentId,
+              },
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Document download failed: ${String(err)}`,
+                },
+              ],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "document_download" },
+    );
+
     api.registerTool(
       (ctx) => ({
         name: "advanced_web_search",
@@ -1506,7 +1642,6 @@ const memoryPlugin = {
           }
         },
       }),
-      { optional: true },
     );
 
     // ========================================================================
@@ -1811,7 +1946,9 @@ const memoryPlugin = {
     }
 
     // ------------------------------------------------------------------
-    // Auto-recall: inject relevant memories and documents before prompt build
+    // Auto-recall: inject system-level memory instructions and open data
+    // categories before prompt build.  Memory content is NOT pre-fetched;
+    // the model is instructed to call memory_search itself.
     // ------------------------------------------------------------------
     if (cfg.autoRecall) {
       api.on("before_prompt_build", async (event, ctx) => {
@@ -1826,18 +1963,6 @@ const memoryPlugin = {
 
         const sessionId = (ctx as any)?.sessionId ?? undefined;
 
-        // LLM-rewrite FIRST — short prompts like "它呢？" can become meaningful
-        // search queries when the LLM has conversation history context.
-        const searchQuery = await rewriteQueryForSearch(event.prompt, event.messages, ctx);
-
-        // Only skip if the rewritten result is still too short
-        if (searchQuery.length < 5) {
-          api.logger.info(
-            `memorylake-openclaw: skipping auto-recall, rewritten query too short (${searchQuery.length} chars)`,
-          );
-          return;
-        }
-
         // Fetch industries once per session, then cache
         let industries: OpenDataIndustry[] | undefined;
         if (sessionId && sessionIndustriesCache.has(sessionId)) {
@@ -1854,82 +1979,42 @@ const memoryPlugin = {
           }
         }
 
-        const [memoryResult, docResult] = await Promise.allSettled([
-          effectiveProvider.search(searchQuery, buildSearchOptions(effectiveCfg)),
-          effectiveProvider.searchDocuments(searchQuery, effectiveCfg.topK),
-        ]);
-
-        const contextParts: string[] = [];
-
-        if (memoryResult.status === "fulfilled" && memoryResult.value.length > 0) {
-          const memories = memoryResult.value;
-          const memoryContext = memories
-            .map((r) => `- ${r.content}`)
-            .join("\n");
-          contextParts.push(
-            `<relevant-memories>\nThe following memories may be relevant to this conversation:\n${memoryContext}\n</relevant-memories>`,
-          );
-          api.logger.info(
-            `memorylake-openclaw: injecting ${memories.length} memories into context`,
-          );
-
-          // Fetch conflict details for memories flagged with unresolved conflicts
-          const conflictedIds = memories
-            .filter((m) => m.has_unresolved_conflict)
-            .map((m) => m.id);
-          if (conflictedIds.length > 0) {
-            try {
-              const conflicts = await effectiveProvider.listConflicts(conflictedIds, effectiveCfg.userId);
-              if (conflicts.length > 0) {
-                const conflictContext = buildConflictContext(conflicts);
-                contextParts.push(
-                  `<memory-conflicts>\nThe following conflicts exist among the recalled memories. ` +
-                  `Consider these contradictions when using the above memories.\n` +
-                  `If you have not already informed the user about these conflicts in this conversation, briefly mention that some recalled memories contain contradictions and note which points are uncertain. Do not repeat this notice if you have already done so.\n` +
-                  `${conflictContext}\n</memory-conflicts>`,
-                );
-                api.logger.info(
-                  `memorylake-openclaw: injecting ${conflicts.length} memory conflicts into context`,
-                );
-              }
-            } catch (err) {
-              api.logger.warn(`memorylake-openclaw: conflict fetch failed: ${String(err)}`);
-            }
-          }
-        } else if (memoryResult.status === "rejected") {
-          api.logger.warn(`memorylake-openclaw: memory recall failed: ${String(memoryResult.reason)}`);
-        }
-
-        if (docResult.status === "fulfilled" && docResult.value.results.length > 0) {
-          const docContext = buildDocumentContext(docResult.value.results);
-          contextParts.push(
-            `<relevant-documents>\nThe following document excerpts may be relevant to this conversation:\n${docContext}\n</relevant-documents>`,
-          );
-          api.logger.info(
-            `memorylake-openclaw: injecting ${docResult.value.results.length} document results into context`,
-          );
-        } else if (docResult.status === "rejected") {
-          api.logger.warn(`memorylake-openclaw: document search failed: ${String(docResult.reason)}`);
-        }
-
-        const result: { prependContext?: string; appendSystemContext?: string } = {};
-
-        if (contextParts.length > 0) {
-          result.prependContext = contextParts.join("\n\n");
-        }
-
+        const result: { prependSystemContext?: string; appendSystemContext?: string } = {};
+
+        const memoryDirectiveParts: string[] = [
+          `<memory-instructions>`,
+          `You have access to the user's long-term memory AND documents via MemoryLake (memory_search tool).`,
+          `The memory_search tool searches both memories and uploaded documents in a single call.`,
+          ``,
+          `MANDATORY PROCEDURE for EVERY user message:`,
+          `1. Read the user's message.`,
+          `2. Call memory_search with a query derived from the message — this step is NOT optional.`,
+          `3. Use the search results (memories + documents) to personalize your response.`,
+          `4. Respond to the user.`,
+          ``,
+          `This applies to ALL messages — greetings, recommendations, advice, casual chat, tasks, questions.`,
+          `The user's preferences, history, name, hobbies, context, and documents are stored in MemoryLake.`,
+          `A response without memory_search is INCORRECT because it ignores personalized context.`,
+          `</memory-instructions>`,
+        ];
+        result.prependSystemContext = memoryDirectiveParts.join("\n");
+
+        const appendParts: string[] = [];
         if (industries && industries.length > 0) {
           const categoryList = industries
             .map((ind) => `- ${ind.id}: ${ind.name}${ind.description ? ` — ${ind.description}` : ""}`)
             .join("\n");
-          result.appendSystemContext =
-            `<open-data-categories>\nThis project has access to the following open data categories via the open_data_search tool:\n${categoryList}\nWhen the user's question relates to any of these categories, use the open_data_search tool to retrieve relevant data.\n</open-data-categories>`;
+          appendParts.push(
+            `<open-data-categories>\nThis project has access to the following open data categories via the open_data_search tool:\n${categoryList}\nWhen the user's question relates to any of these categories, use the open_data_search tool to retrieve relevant data.\n</open-data-categories>`,
+          );
           api.logger.info(
             `memorylake-openclaw: injecting ${industries.length} open data categories into system context`,
           );
         }
 
-        if (!result.prependContext && !result.appendSystemContext) return;
+        if (appendParts.length > 0) {
+          result.appendSystemContext = appendParts.join("\n\n");
+        }
 
         return result;
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorylake-openclaw",
-  "version": "1.0.0",
+  "version": "1.0.2-beta.1",
   "type": "module",
   "description": "MemoryLake memory backend for OpenClaw",
   "license": "MIT",