openclaw-memory-alibaba-mysql 0.1.9 → 0.2.0

package/categories.ts

@@ -20,9 +20,32 @@ export type UserMemoryCategory =
   | typeof USER_MEMORY_PREFERENCE
   | typeof USER_MEMORY_DECISION;
 
-/** Full context (conversation audit / per-message) */
+/** Full context (conversation audit). Legacy single category. */
 export const FULL_CONTEXT_MEMORY = "full_context_memory" as const;
 
+/** Full context by source (user / assistant / system / tool / tool_result / others) */
+export const FULL_CONTEXT_USER = "full_context_user" as const;
+export const FULL_CONTEXT_ASSISTANT = "full_context_assistant" as const;
+export const FULL_CONTEXT_SYSTEM = "full_context_system" as const;
+export const FULL_CONTEXT_TOOL = "full_context_tool" as const;
+export const FULL_CONTEXT_TOOL_RESULT = "full_context_tool_result" as const;
+export const FULL_CONTEXT_OTHERS = "full_context_others" as const;
+
+export const FULL_CONTEXT_SOURCE_CATEGORIES = [
+  FULL_CONTEXT_USER,
+  FULL_CONTEXT_ASSISTANT,
+  FULL_CONTEXT_SYSTEM,
+  FULL_CONTEXT_TOOL,
+  FULL_CONTEXT_TOOL_RESULT,
+  FULL_CONTEXT_OTHERS,
+] as const;
+
+export type FullContextSourceCategory = (typeof FULL_CONTEXT_SOURCE_CATEGORIES)[number];
+
+export function isFullContextSourceCategory(cat: string): cat is FullContextSourceCategory {
+  return FULL_CONTEXT_SOURCE_CATEGORIES.includes(cat as FullContextSourceCategory);
+}
+
 /** Self-improving memory sub-categories */
 export const SELF_IMPROVING_LEARNINGS = "self_improving_learnings" as const;
 export const SELF_IMPROVING_ERRORS = "self_improving_errors" as const;
@@ -40,11 +63,13 @@ export type SelfImprovingCategory = (typeof SELF_IMPROVING_CATEGORIES)[number];
 export type MemoryCategory =
   | UserMemoryCategory
   | typeof FULL_CONTEXT_MEMORY
+  | FullContextSourceCategory
   | SelfImprovingCategory;
 
 export const ALL_CATEGORIES: readonly MemoryCategory[] = [
   ...USER_MEMORY_CATEGORIES,
   FULL_CONTEXT_MEMORY,
+  ...FULL_CONTEXT_SOURCE_CATEGORIES,
   ...SELF_IMPROVING_CATEGORIES,
 ];
 

package/config.ts

@@ -38,7 +38,7 @@ export type MemoryConfig = {
   enableFullContextMemory: boolean;
   /** When false, self_improving_* is not written or recalled. Default false. */
   enableSelfImprovingMemory: boolean;
-  /** How to extract user and self_improving memories in auto-capture: "regex" (default) or "llm". Case-insensitive; invalid values fall back to "regex". When "llm", llm config is required. */
+  /** How to extract user and self_improving memories in auto-capture: "llm" (default) or "regex". Case-insensitive; invalid values fall back to "llm". When "llm", llm config is required. */
   memoryExtractionMethod: "regex" | "llm";
   autoRecall: boolean;
   autoCapture: boolean;
@@ -210,7 +210,7 @@ export const memoryConfigSchema = {
         ? cfg.memoryExtractionMethod.trim().toLowerCase()
         : "";
     const memoryExtractionMethod: "regex" | "llm" =
-      rawMethod === "llm" ? "llm" : "regex";
+      rawMethod === "regex" ? "regex" : "llm";
     const needsLlm = memory_duplication_conflict_process || memoryExtractionMethod === "llm";
     if (needsLlm && (!cfg.llm || typeof cfg.llm !== "object")) {
       throw new Error(

package/db.ts

@@ -23,6 +23,11 @@ export type MemorySearchResult = {
 
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
+/** Strip 4-byte UTF-8 (e.g. emojis) so text is safe for MySQL utf8 charset. Use as-is when table is utf8mb4. */
+function stripFourByteUtf8(text: string): string {
+  return text.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "");
+}
+
 export class MemoryDB {
   private pool: Pool | null = null;
   private initPromise: Promise<void> | null = null;
@@ -73,10 +78,12 @@ export class MemoryDB {
           category   VARCHAR(64)   DEFAULT '${USER_MEMORY_FACT}',
           created_at BIGINT        NOT NULL,
           is_deleted TINYINT       NOT NULL DEFAULT 0,
-          INDEX idx_agent_id (agent_id)
-        ) ENGINE=InnoDB
+          INDEX idx_agent_id (agent_id),
+          INDEX idx_agent_session_category (agent_id, session_id, category)
+        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
       `);
       await this.ensureIsDeletedColumn(conn);
+      await this.ensureSessionCategoryIndex(conn);
       await this.tryCreateVectorIndex(conn);
     } finally {
       conn.release();
@@ -95,6 +102,18 @@ export class MemoryDB {
     );
   }
 
+  private async ensureSessionCategoryIndex(conn: mysql.PoolConnection): Promise<void> {
+    const [rows] = await conn.query(
+      `SELECT COUNT(1) AS cnt FROM information_schema.statistics
+       WHERE table_schema = DATABASE() AND table_name = ? AND index_name = 'idx_agent_session_category'`,
+      [this.tableName],
+    );
+    if (((rows as Array<{ cnt: number }>)[0]?.cnt ?? 0) > 0) return;
+    await conn.query(
+      `ALTER TABLE \`${this.tableName}\` ADD INDEX idx_agent_session_category (agent_id, session_id, category)`,
+    );
+  }
+
   private async tryCreateVectorIndex(conn: mysql.PoolConnection): Promise<void> {
     if (this.vectorIndexCreated) {
       return;
@@ -123,18 +142,28 @@ export class MemoryDB {
 
   async store(
     agentId: string,
-    entry: { text: string; vector: number[]; importance: number; category: MemoryCategory },
+    entry: {
+      text: string;
+      vector: number[];
+      importance: number;
+      category: MemoryCategory;
+      userId?: string | null;
+      sessionId?: string | null;
+    },
   ): Promise<MemoryEntry> {
     await this.ensureInitialized();
 
     const id = randomUUID();
     const createdAt = Date.now();
     const vectorStr = JSON.stringify(entry.vector);
+    const userId = entry.userId ?? null;
+    const sessionId = entry.sessionId ?? null;
+    const textSafe = stripFourByteUtf8(entry.text);
 
     await this.pool!.query(
-      `INSERT INTO \`${this.tableName}\` (id, agent_id, text, embedding, importance, category, created_at, is_deleted)
-       VALUES (?, ?, ?, VEC_FROMTEXT(?), ?, ?, ?, 0)`,
-      [id, agentId, entry.text, vectorStr, entry.importance, entry.category, createdAt],
+      `INSERT INTO \`${this.tableName}\` (id, agent_id, user_id, session_id, text, embedding, importance, category, created_at, is_deleted)
+       VALUES (?, ?, ?, ?, ?, VEC_FROMTEXT(?), ?, ?, ?, 0)`,
+      [id, agentId, userId, sessionId, textSafe, vectorStr, entry.importance, entry.category, createdAt],
     );
 
     if (!this.vectorIndexCreated) {
@@ -149,13 +178,92 @@ export class MemoryDB {
     return {
       id,
       agentId,
-      text: entry.text,
+      text: textSafe,
       importance: entry.importance,
       category: entry.category,
       createdAt,
     };
   }
 
+  /**
+   * Upsert for full-context by (agent_id, session_id, category): one row per session per category.
+   * If a row exists, UPDATE it; otherwise INSERT. Returns action and entry.
+   */
+  async storeOrUpdateFullContext(
+    agentId: string,
+    sessionId: string | null,
+    entry: {
+      text: string;
+      vector: number[];
+      importance: number;
+      category: MemoryCategory;
+      userId?: string | null;
+    },
+  ): Promise<{ action: "created" | "updated"; entry: MemoryEntry }> {
+    await this.ensureInitialized();
+
+    const textSafe = stripFourByteUtf8(entry.text);
+    const vectorStr = JSON.stringify(entry.vector);
+    const userId = entry.userId ?? null;
+    const createdAt = Date.now();
+
+    const [existingRows] = await this.pool!.query(
+      `SELECT id FROM \`${this.tableName}\`
+       WHERE agent_id = ? AND category = ? AND is_deleted = 0
+         AND ((? IS NULL AND session_id IS NULL) OR (session_id = ?))
+       LIMIT 1`,
+      [agentId, entry.category, sessionId, sessionId],
+    );
+    const existing = (existingRows as Array<{ id: string }>)[0];
+
+    if (existing) {
+      await this.pool!.query(
+        `UPDATE \`${this.tableName}\` SET text = ?, embedding = VEC_FROMTEXT(?), importance = ?, created_at = ?, user_id = ?
+         WHERE id = ? AND agent_id = ?`,
+        [textSafe, vectorStr, entry.importance, createdAt, userId, existing.id, agentId],
+      );
+      return {
+        action: "updated",
+        entry: {
+          id: existing.id,
+          agentId,
+          text: textSafe,
+          importance: entry.importance,
+          category: entry.category,
+          createdAt,
+        },
+      };
+    }
+
+    const id = randomUUID();
+    await this.pool!.query(
+      `INSERT INTO \`${this.tableName}\` (id, agent_id, user_id, session_id, text, embedding, importance, category, created_at, is_deleted)
+       VALUES (?, ?, ?, ?, ?, VEC_FROMTEXT(?), ?, ?, ?, 0)`,
+      [id, agentId, userId, sessionId, textSafe, vectorStr, entry.importance, entry.category, createdAt],
+    );
+
+    if (!this.vectorIndexCreated) {
+      const conn = await this.pool!.getConnection();
+      try {
+        await this.tryCreateVectorIndex(conn);
+      } finally {
+        conn.release();
+      }
+    }
+
+    return {
+      action: "created",
+      entry: {
+        id,
+        agentId,
+        text: textSafe,
+        importance: entry.importance,
+        category: entry.category,
+        createdAt,
+      },
+    };
+  }
+
   /**
    * Search memories by vector similarity.
    * @param categories - When non-empty, only return rows with category IN (categories). Omit for no category filter.

package/index.ts

@@ -19,11 +19,18 @@ import {
   SELF_IMPROVING_ERRORS,
   SELF_IMPROVING_FEATURE_REQUESTS,
   FULL_CONTEXT_MEMORY,
+  FULL_CONTEXT_USER,
+  FULL_CONTEXT_ASSISTANT,
+  FULL_CONTEXT_SYSTEM,
+  FULL_CONTEXT_TOOL,
+  FULL_CONTEXT_TOOL_RESULT,
+  FULL_CONTEXT_OTHERS,
   type UserMemoryCategory,
   type SelfImprovingCategory,
   type MemoryCategory,
   isUserMemoryCategory,
   isSelfImprovingCategory,
+  isFullContextSourceCategory,
 } from "./categories.js";
 import {
   DEFAULT_CAPTURE_MAX_CHARS,
@@ -146,9 +153,10 @@ function formatRelevantMemoriesContext(
 }
 
 function getThresholdForCategory(cfg: MemoryConfig, category: MemoryCategory): number {
-  return isUserMemoryCategory(category)
-    ? cfg.similarityThresholdUserMemory
-    : cfg.similarityThresholdSelfImproving;
+  if (isUserMemoryCategory(category) || isFullContextSourceCategory(category) || category === FULL_CONTEXT_MEMORY) {
+    return cfg.similarityThresholdUserMemory;
+  }
+  return cfg.similarityThresholdSelfImproving;
 }
 
 /** Apply time decay to recall results: effectiveScore = score * decay(createdAt). Returns new array sorted by effectiveScore desc. */
@@ -388,7 +396,7 @@ New memory text:
 ${newText}
 """
 
-Existing similar memories (up to 10):
+Existing similar memories (up to 20):
 ${candidateList}
 
 Rules:
@@ -468,15 +476,34 @@ function getTextPartsFromMessage(msg: Record<string, unknown>): string[] {
   return parts;
 }
 
-/** From raw agent messages, collect user-only texts and full/conversation lines for each memory type. */
+/** Lines by role for full-context (user / assistant / system / tool / tool_result / others). */
+export type LinesByRole = {
+  user: string[];
+  assistant: string[];
+  system: string[];
+  tool: string[];
+  tool_result: string[];
+  others: string[];
+};
+
+/** From raw agent messages, collect user-only texts, full/conversation lines, and lines grouped by role. */
 function parseMessagesForCapture(messages: unknown[]): {
   userMessageTexts: string[];
   allMessageLines: string[];
   userAndAssistantLines: string[];
+  linesByRole: LinesByRole;
 } {
   const userMessageTexts: string[] = [];
   const allMessageLines: string[] = [];
   const userAndAssistantLines: string[] = [];
+  const linesByRole: LinesByRole = {
+    user: [],
+    assistant: [],
+    system: [],
+    tool: [],
+    tool_result: [],
+    others: [],
+  };
 
   for (const msg of messages) {
     if (!msg || typeof msg !== "object") continue;
@@ -489,9 +516,16 @@ function parseMessagesForCapture(messages: unknown[]): {
     allMessageLines.push(line);
     if (role !== "system") userAndAssistantLines.push(line);
     if (role === "user") userMessageTexts.push(...parts);
+
+    if (role === "user") linesByRole.user.push(line);
+    else if (role === "assistant") linesByRole.assistant.push(line);
+    else if (role === "system") linesByRole.system.push(line);
+    else if (role === "tool") linesByRole.tool.push(line);
+    else if (role === "toolResult" || role === "tool_result") linesByRole.tool_result.push(line);
+    else linesByRole.others.push(line);
   }
 
-  return { userMessageTexts, allMessageLines, userAndAssistantLines };
+  return { userMessageTexts, allMessageLines, userAndAssistantLines, linesByRole };
 }
 
 /** Truncate to max chars and append "..." if needed. */
@@ -514,12 +548,13 @@ function stripInjectedContextBlocks(text: string): string {
   return out;
 }
 
-/** Build list of capture candidates: user (regex/LLM) + optional full-context + optional self-improving. */
+/** Build list of capture candidates: user (regex/LLM) + optional full-context by source + optional self-improving. */
 async function buildCaptureCandidates(
   cfg: MemoryConfig,
   userMessageTexts: string[],
   allMessageLines: string[],
   userAndAssistantLines: string[],
+  linesByRole: LinesByRole,
 ): Promise<CaptureCandidate[]> {
   const candidates: CaptureCandidate[] = [];
 
@@ -542,13 +577,56 @@ async function buildCaptureCandidates(
     }
   }
 
-  // Full-context: all roles, keep injected blocks (full audit trail)
-  if (cfg.enableFullContextMemory && allMessageLines.length > 0) {
-    const fullText = allMessageLines.join("\n");
-    candidates.push({
-      category: FULL_CONTEXT_MEMORY,
-      text: truncateForCapture(fullText, cfg.captureMaxChars),
-    });
+  // Full-context by source. Strip injected blocks from user/assistant so real conversation is stored (injected context can be huge and push out the actual question).
+  if (cfg.enableFullContextMemory) {
+    if (linesByRole.user.length > 0) {
+      const userText = linesByRole.user
+        .map((line) => stripInjectedContextBlocks(line))
+        .filter((s) => s.length > 0)
+        .join("\n");
+      if (userText.length > 0) {
+        candidates.push({
+          category: FULL_CONTEXT_USER,
+          text: truncateForCapture(userText, cfg.captureMaxChars),
+        });
+      }
+    }
+    if (linesByRole.assistant.length > 0) {
+      const assistantText = linesByRole.assistant
+        .map((line) => stripInjectedContextBlocks(line))
+        .filter((s) => s.length > 0)
+        .join("\n");
+      if (assistantText.length > 0) {
+        candidates.push({
+          category: FULL_CONTEXT_ASSISTANT,
+          text: truncateForCapture(assistantText, cfg.captureMaxChars),
+        });
+      }
+    }
+    if (linesByRole.system.length > 0) {
+      candidates.push({
+        category: FULL_CONTEXT_SYSTEM,
+        text: truncateForCapture(linesByRole.system.join("\n"), cfg.captureMaxChars),
+      });
+    }
+    if (linesByRole.tool.length > 0) {
+      candidates.push({
+        category: FULL_CONTEXT_TOOL,
+        text: truncateForCapture(linesByRole.tool.join("\n"), cfg.captureMaxChars),
+      });
+    }
+    if (linesByRole.tool_result.length > 0) {
+      candidates.push({
+        category: FULL_CONTEXT_TOOL_RESULT,
+        text: truncateForCapture(linesByRole.tool_result.join("\n"), cfg.captureMaxChars),
+      });
+    }
+    if (linesByRole.others.length > 0) {
+      candidates.push({
+        category: FULL_CONTEXT_OTHERS,
+        text: truncateForCapture(linesByRole.others.join("\n"), cfg.captureMaxChars),
+      });
+    }
   }
 
   // Self-improving: user + assistant only; strip injected blocks, then extract by regex or LLM
@@ -591,6 +669,7 @@ type StoreOneResult = { action: "created" | "updated"; entry: MemoryEntry };
 function getDedupCategories(category: MemoryCategory): readonly MemoryCategory[] {
   if (isUserMemoryCategory(category)) return USER_MEMORY_CATEGORIES;
   if (category === FULL_CONTEXT_MEMORY) return [FULL_CONTEXT_MEMORY];
+  if (isFullContextSourceCategory(category)) return [category];
   if (isSelfImprovingCategory(category)) return SELF_IMPROVING_CATEGORIES;
   return [category];
 }
@@ -602,29 +681,54 @@ async function storeOneCaptureItem(
   cfg: MemoryConfig,
   db: MemoryDB,
   embeddings: Embeddings,
+  options?: { userId?: string | null; sessionId?: string | null },
 ): Promise<StoreOneResult> {
   const importance = item.importance ?? DEFAULT_IMPORTANCE;
   const vector = await embeddings.embed(item.text);
   const threshold = getThresholdForCategory(cfg, item.category);
   const dedupCategories = getDedupCategories(item.category);
+  const storePayload = {
+    text: item.text,
+    vector,
+    importance,
+    category: item.category,
+    userId: options?.userId ?? null,
+    sessionId: options?.sessionId ?? null,
+  };
+
+  // Full-context by source: upsert by (agent_id, session_id, category) so one row per session per category.
+  if (isFullContextSourceCategory(item.category)) {
+    const { action, entry } = await db.storeOrUpdateFullContext(agentId, options?.sessionId ?? null, {
+      text: storePayload.text,
+      vector: storePayload.vector,
+      importance: storePayload.importance,
+      category: storePayload.category,
+      userId: options?.userId ?? null,
+    });
+    return { action, entry };
+  }
 
   if (!cfg.memory_duplication_conflict_process) {
     const existing = await db.search(agentId, vector, 1, threshold, [...dedupCategories]);
     if (existing.length > 0) await db.softDelete(agentId, existing[0].entry.id);
-    const entry = await db.store(agentId, { text: item.text, vector, importance, category: item.category });
+    const entry = await db.store(agentId, storePayload);
     return { action: existing.length > 0 ? "updated" : "created", entry };
   }
 
-  const recallMinScore = Math.max(0.3, threshold - 0.15);
-  const candidates = await db.search(agentId, vector, 10, recallMinScore, [...dedupCategories]);
+  // Lower recall bar for conflict/dedup for both user_memory_* and self_improving_*:
+  // contradictory or same-topic memories (e.g. "dislikes X" vs "loves X", or revised learnings) often have
+  // only moderate embedding similarity (~0.65–0.8); without this they may not enter the candidate list.
+  const recallMinScore = Math.max(0.5, threshold - 0.35);
+  const conflictCandidateLimit = 20;
+  const candidates = await db.search(agentId, vector, conflictCandidateLimit, recallMinScore, [...dedupCategories]);
   if (candidates.length === 0) {
-    const entry = await db.store(agentId, { text: item.text, vector, importance, category: item.category });
+    const entry = await db.store(agentId, storePayload);
     return { action: "created", entry };
   }
 
   const decision = await decideInsertOrUpdate(cfg.llm!, item.text, candidates);
   if (decision.action === "update") await db.softDelete(agentId, decision.memoryId);
-  const entry = await db.store(agentId, { text: item.text, vector, importance, category: item.category });
+  const entry = await db.store(agentId, storePayload);
   return { action: decision.action === "update" ? "updated" : "created", entry };
 }
 
@@ -711,7 +815,16 @@ const memoryPlugin = {
 
     const writableCategories: MemoryCategory[] = [
       ...USER_MEMORY_CATEGORIES,
-      ...(cfg.enableFullContextMemory ? [FULL_CONTEXT_MEMORY] : []),
+      ...(cfg.enableFullContextMemory
+        ? [
+            FULL_CONTEXT_USER,
+            FULL_CONTEXT_ASSISTANT,
+            FULL_CONTEXT_SYSTEM,
+            FULL_CONTEXT_TOOL,
+            FULL_CONTEXT_TOOL_RESULT,
+            FULL_CONTEXT_OTHERS,
+          ]
+        : []),
       ...(cfg.enableSelfImprovingMemory ? SELF_IMPROVING_CATEGORIES : []),
     ];
     api.registerTool(
@@ -741,7 +854,8 @@ const memoryPlugin = {
             category?: MemoryCategory;
           };
 
-          if (category === FULL_CONTEXT_MEMORY && !cfg.enableFullContextMemory) {
+          const isFullContext = category === FULL_CONTEXT_MEMORY || isFullContextSourceCategory(category);
+          if (isFullContext && !cfg.enableFullContextMemory) {
             return {
               content: [{ type: "text", text: "Full context memory is disabled. Enable enableFullContextMemory in config to use it." }],
               details: { error: "full_context_memory_disabled" },
@@ -755,8 +869,10 @@ const memoryPlugin = {
           }
 
           const agentId = ctx.agentId ?? "default";
+          const userId = (ctx as { requesterSenderId?: string }).requesterSenderId ?? null;
+          const sessionId = (ctx as { sessionId?: string }).sessionId ?? null;
           const item: CaptureCandidate = { category, text, importance };
-          const { action, entry } = await storeOneCaptureItem(agentId, item, cfg, db, embeddings);
+          const { action, entry } = await storeOneCaptureItem(agentId, item, cfg, db, embeddings, { userId, sessionId });
           const preview = text.length > 100 ? text.slice(0, 100) + "..." : text;
           return {
             content: [{ type: "text", text: `${action === "updated" ? "Updated" : "Stored"}: "${preview}"` }],
@@ -881,20 +997,32 @@ const memoryPlugin = {
 
         try {
           const agentId = ctx.agentId ?? "default";
-          const { userMessageTexts, allMessageLines, userAndAssistantLines } = parseMessagesForCapture(
+          const userId = (ctx as { requesterSenderId?: string }).requesterSenderId ?? null;
+          const sessionId = (ctx as { sessionId?: string }).sessionId ?? (event as { sessionId?: string }).sessionId ?? null;
+          const { userMessageTexts, allMessageLines, userAndAssistantLines, linesByRole } = parseMessagesForCapture(
             event.messages,
           );
+          api.logger.info(
+            `openclaw-memory-alibaba-mysql: agent_end messages=${event.messages.length} user=${linesByRole.user.length} assistant=${linesByRole.assistant.length} system=${linesByRole.system.length} tool=${linesByRole.tool.length} tool_result=${linesByRole.tool_result.length} others=${linesByRole.others.length}`,
+          );
+          if (linesByRole.user.length === 0 && event.messages.length > 0) {
+            const roles = (event.messages as Array<Record<string, unknown>>).map((m) => m.role ?? "?");
+            api.logger.warn(
+              `openclaw-memory-alibaba-mysql: no user lines parsed; message roles: ${roles.join(", ")}`,
+            );
+          }
           const toProcess = await buildCaptureCandidates(
             cfg,
             userMessageTexts,
             allMessageLines,
             userAndAssistantLines,
+            linesByRole,
           );
           if (toProcess.length === 0) return;
 
           let stored = 0;
           for (const item of toProcess) {
-            await storeOneCaptureItem(agentId, item, cfg, db, embeddings);
+            await storeOneCaptureItem(agentId, item, cfg, db, embeddings, { userId, sessionId });
             stored++;
           }
           if (stored > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-memory-alibaba-mysql",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "OpenClaw memory plugin using Alibaba Cloud RDS MySQL vector storage",
   "type": "module",
   "license": "MIT",