openclaw-mem 1.2.1 → 1.3.0

package/README.md

@@ -30,6 +30,19 @@ npm install
 npm install openclaw-mem
 ```
 
+> ⚠️ **Important:** npm installation does NOT automatically prompt for API key configuration. You MUST manually configure your DeepSeek API key after installation. See [Configuration](#configuration) section below.
+
+**After npm install, choose one of these methods:**
+
+```bash
+# Method 1: Run the setup wizard
+npx openclaw-mem-setup
+
+# Method 2: Set environment variable directly
+export DEEPSEEK_API_KEY="your-deepseek-api-key"
+# Add this line to your ~/.bashrc or ~/.zshrc to persist
+```
+
 ## Quick Start
 
 1. **Install the hook** (see above)

package/backfill-embeddings.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Backfill embeddings for existing observations.
+ * Run manually: node backfill-embeddings.js
+ *
+ * Finds all observations without embeddings and generates them
+ * in batches of 16 using the DeepSeek embeddings API.
+ */
+
+import database from './database.js';
+import { batchEmbeddings } from './gateway-llm.js';
+
+const BATCH_SIZE = 16;
+
+async function backfill() {
+  const totalObs = database.getStats().total_observations;
+  const existingEmbeddings = database.getEmbeddingCount();
+  console.log(`Total observations: ${totalObs}`);
+  console.log(`Existing embeddings: ${existingEmbeddings}`);
+  console.log(`Missing: ~${totalObs - existingEmbeddings}`);
+  console.log('');
+
+  let processed = 0;
+  let saved = 0;
+  let failed = 0;
+
+  while (true) {
+    const batch = database.getObservationsWithoutEmbeddings(BATCH_SIZE);
+    if (batch.length === 0) break;
+
+    // Build text for each observation
+    const texts = batch.map(obs => {
+      const parts = [obs.summary, obs.narrative].filter(Boolean);
+      return parts.join(' ').trim() || `Observation #${obs.id}`;
+    });
+
+    console.log(`Batch ${Math.floor(processed / BATCH_SIZE) + 1}: generating embeddings for ${batch.length} observations (IDs ${batch[0].id}-${batch[batch.length - 1].id})...`);
+
+    const embeddings = await batchEmbeddings(texts);
+
+    for (let i = 0; i < batch.length; i++) {
+      const obs = batch[i];
+      const embedding = embeddings[i];
+
+      if (embedding) {
+        const result = database.saveEmbedding(obs.id, embedding);
+        if (result.success) {
+          saved++;
+        } else {
+          failed++;
+          console.error(`  Failed to save embedding for #${obs.id}: ${result.error}`);
+        }
+      } else {
+        failed++;
+        console.error(`  No embedding returned for #${obs.id}`);
+      }
+    }
+
+    processed += batch.length;
+    console.log(`  Progress: ${saved} saved, ${failed} failed, ${processed} processed`);
+
+    // Small delay between batches to avoid rate limiting
+    if (batch.length === BATCH_SIZE) {
+      await new Promise(r => setTimeout(r, 500));
+    }
+  }
+
+  console.log('');
+  console.log('=== Backfill Complete ===');
+  console.log(`Processed: ${processed}`);
+  console.log(`Saved: ${saved}`);
+  console.log(`Failed: ${failed}`);
+  console.log(`Total embeddings now: ${database.getEmbeddingCount()}`);
+}
+
+backfill().catch(err => {
+  console.error('Backfill failed:', err);
+  process.exit(1);
+});

package/database.js

@@ -7,6 +7,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import Database from 'better-sqlite3';
+import * as sqliteVec from 'sqlite-vec';
 
 const DATA_DIR = path.join(os.homedir(), '.openclaw-mem');
 const DB_PATH = path.join(DATA_DIR, 'memory.db');
@@ -20,6 +21,14 @@ if (!fs.existsSync(DATA_DIR)) {
 const db = new Database(DB_PATH);
 db.pragma('journal_mode = WAL');
 
+// Load sqlite-vec extension for vector search
+try {
+  sqliteVec.load(db);
+  console.log('[openclaw-mem] sqlite-vec extension loaded');
+} catch (e) {
+  console.error('[openclaw-mem] Failed to load sqlite-vec:', e.message);
+}
+
 // Create tables (base schema without new columns for backward compatibility)
 db.exec(`
   -- Sessions table
@@ -168,6 +177,28 @@ db.exec(`
   END;
 `);
 
+// Create vec0 virtual table for vector embeddings
+// Drop and recreate if dimension mismatch (migration from 768/1024 to 384)
+try {
+  const vecInfo = db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='observation_embeddings'`).get();
+  if (vecInfo && !vecInfo.sql.includes('float[384]')) {
+    console.log('[openclaw-mem] Recreating vec0 table with 384 dimensions...');
+    db.exec(`DROP TABLE IF EXISTS observation_embeddings`);
+  }
+} catch (e) { /* table doesn't exist yet */ }
+
+try {
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS observation_embeddings USING vec0(
+      observation_id INTEGER PRIMARY KEY,
+      embedding float[384]
+    );
+  `);
+  console.log('[openclaw-mem] observation_embeddings vec0 table ready');
+} catch (e) {
+  console.error('[openclaw-mem] Failed to create vec0 table:', e.message);
+}
+
 // Prepared statements
 const stmts = {
   // Sessions
@@ -261,8 +292,8 @@ const stmts = {
 
   // Summaries
   saveSummary: db.prepare(`
-    INSERT INTO summaries (session_id, content, request, learned, completed, next_steps)
-    VALUES (?, ?, ?, ?, ?, ?)
+    INSERT INTO summaries (session_id, content, request, investigated, learned, completed, next_steps)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
   `),
 
   getRecentSummaries: db.prepare(`
@@ -290,6 +321,34 @@ const stmts = {
     LIMIT 1
   `),
 
+  // Embedding operations
+  saveEmbedding: db.prepare(`
+    INSERT OR REPLACE INTO observation_embeddings (observation_id, embedding)
+    VALUES (?, ?)
+  `),
+
+  searchByVector: db.prepare(`
+    SELECT observation_id, distance
+    FROM observation_embeddings
+    WHERE embedding MATCH ?
+    AND k = ?
+    ORDER BY distance
+  `),
+
+  getEmbeddingCount: db.prepare(`
+    SELECT COUNT(*) as count FROM observation_embeddings
+  `),
+
+  getObservationsWithoutEmbeddings: db.prepare(`
+    SELECT o.id, o.summary, o.narrative
+    FROM observations o
+    LEFT JOIN observation_embeddings oe ON o.id = oe.observation_id
+    WHERE oe.observation_id IS NULL
+    AND (o.summary IS NOT NULL OR o.narrative IS NOT NULL)
+    ORDER BY o.id
+    LIMIT ?
+  `),
+
   // Stats
   getStats: db.prepare(`
     SELECT
@@ -298,7 +357,8 @@ const stmts = {
       (SELECT COUNT(*) FROM summaries) as total_summaries,
       (SELECT COUNT(*) FROM user_prompts) as total_user_prompts,
       (SELECT SUM(tokens_discovery) FROM observations) as total_discovery_tokens,
-      (SELECT SUM(tokens_read) FROM observations) as total_read_tokens
+      (SELECT SUM(tokens_read) FROM observations) as total_read_tokens,
+      (SELECT COUNT(*) FROM observation_embeddings) as total_embeddings
   `)
 };
 
@@ -489,8 +549,8 @@ export const database = {
   },
 
   // Summary operations
-  saveSummary(sessionId, content, request = null, learned = null, completed = null, nextSteps = null) {
-    const result = stmts.saveSummary.run(sessionId, content, request, learned, completed, nextSteps);
+  saveSummary(sessionId, content, request = null, investigated = null, learned = null, completed = null, nextSteps = null) {
+    const result = stmts.saveSummary.run(sessionId, content, request, investigated, learned, completed, nextSteps);
     return { success: true, id: result.lastInsertRowid };
   },
 
@@ -506,6 +566,51 @@ export const database = {
     return stmts.getSummaryBySessionKey.get(sessionKey);
   },
 
+  // Embedding operations
+  saveEmbedding(observationId, embedding) {
+    try {
+      // sqlite-vec expects Float32Array directly, not Buffer
+      const vec = embedding instanceof Float32Array
+        ? embedding
+        : new Float32Array(embedding);
+      stmts.saveEmbedding.run(BigInt(observationId), vec);
+      return { success: true };
+    } catch (err) {
+      console.error('[openclaw-mem] saveEmbedding error:', err.message);
+      return { success: false, error: err.message };
+    }
+  },
+
+  searchByVector(embedding, limit = 20) {
+    try {
+      const vec = embedding instanceof Float32Array
+        ? embedding
+        : new Float32Array(embedding);
+      const rows = stmts.searchByVector.all(vec, limit);
+      return rows;
+    } catch (err) {
+      console.error('[openclaw-mem] searchByVector error:', err.message);
+      return [];
+    }
+  },
+
+  getEmbeddingCount() {
+    try {
+      return stmts.getEmbeddingCount.get().count;
+    } catch {
+      return 0;
+    }
+  },
+
+  getObservationsWithoutEmbeddings(limit = 100) {
+    try {
+      return stmts.getObservationsWithoutEmbeddings.all(limit);
+    } catch (err) {
+      console.error('[openclaw-mem] getObservationsWithoutEmbeddings error:', err.message);
+      return [];
+    }
+  },
+
   // Stats
   getStats() {
     return stmts.getStats.get();

package/extractor.js

@@ -1,19 +1,31 @@
 /**
  * OpenClaw-Mem LLM Extractor
- * Uses the local OpenClaw Gateway model to extract concepts and metadata
+ *
+ * Structured observation extraction inspired by claude-mem's observer agent pattern.
+ * Uses DeepSeek API to produce rich, searchable memory records.
  */
 
 import { callGatewayChat } from './gateway-llm.js';
 
-// Cache for extracted concepts (to avoid repeated API calls)
+// ── Valid concept categories (fixed taxonomy for consistent search) ──
+const VALID_CONCEPTS = [
+  'how-it-works',      // understanding mechanisms
+  'why-it-exists',     // purpose or rationale
+  'what-changed',      // modifications made
+  'problem-solution',  // issues and their fixes
+  'gotcha',            // traps or edge cases
+  'pattern',           // reusable approach
+  'trade-off'          // pros/cons of a decision
+];
+
+// ── Cache ──
 const conceptCache = new Map();
 const CACHE_MAX_SIZE = 1000;
 const CACHE_TTL = 60 * 60 * 1000; // 1 hour
 
 function getCacheKey(text) {
-  // Simple hash for cache key
   let hash = 0;
-  const str = text.slice(0, 500); // Only hash first 500 chars
+  const str = text.slice(0, 500);
   for (let i = 0; i < str.length; i++) {
     const char = str.charCodeAt(i);
     hash = ((hash << 5) - hash) + char;
@@ -30,7 +42,6 @@ function cleanCache() {
         conceptCache.delete(key);
       }
     }
-    // If still too large, remove oldest entries
     if (conceptCache.size > CACHE_MAX_SIZE) {
       const entries = [...conceptCache.entries()];
       entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
@@ -43,17 +54,13 @@ function cleanCache() {
 }
 
 /**
- * Extract concepts/keywords from text using LLM
- * @param {string} text - The text to extract concepts from
- * @param {object} options - Options
- * @returns {Promise<string[]>} - Array of extracted concepts
+ * Extract concepts from text using LLM
  */
 export async function extractConcepts(text, options = {}) {
   if (!text || typeof text !== 'string' || text.trim().length < 10) {
     return [];
   }
 
-  // Check cache first
   const cacheKey = getCacheKey(text);
   const cached = conceptCache.get(cacheKey);
   if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
@@ -61,123 +68,174 @@ export async function extractConcepts(text, options = {}) {
   }
 
   try {
-    const content = await callGatewayChat([{
-      role: 'user',
-      content: `Extract 3-7 key concepts/topics from this text. Return ONLY a JSON array of strings, no explanation.
-
-Text: "${text.slice(0, 800)}"
+    const content = await callGatewayChat([
+      {
+        role: 'system',
+        content: `You are a knowledge classifier. Categorize the given text into 2-4 concept categories from this fixed list:
+- how-it-works: understanding mechanisms or implementation details
+- why-it-exists: purpose, rationale, or motivation
+- what-changed: modifications, updates, or configuration changes
+- problem-solution: issues encountered and their fixes
+- gotcha: traps, edge cases, or surprising behavior
+- pattern: reusable approaches or best practices
+- trade-off: pros/cons analysis or design decisions
 
-JSON array:`
-    }], { sessionKey: 'extract-concepts', temperature: 0.2, max_tokens: 200 });
+Return ONLY a JSON array of matching categories. No explanation.`
+      },
+      {
+        role: 'user',
+        content: text.slice(0, 2000)
+      }
+    ], { sessionKey: 'extract-concepts', temperature: 0.1, max_tokens: 100 });
 
     if (!content) return [];
-    // Parse JSON array from response
+
     let concepts = [];
     try {
-      // Try to extract JSON array from response
       const match = content.match(/\[[\s\S]*?\]/);
       if (match) {
         concepts = JSON.parse(match[0]);
       }
     } catch (parseErr) {
-      console.error('[openclaw-mem] Failed to parse LLM response:', parseErr.message);
+      console.error('[openclaw-mem] Failed to parse concepts response:', parseErr.message);
       return [];
     }
 
-    // Validate and clean concepts
+    // Validate against fixed taxonomy
     concepts = concepts
-      .filter(c => typeof c === 'string' && c.length > 1 && c.length < 50)
+      .filter(c => typeof c === 'string')
       .map(c => c.trim().toLowerCase())
-      .slice(0, 7);
+      .filter(c => VALID_CONCEPTS.includes(c))
+      .slice(0, 4);
 
-    // Cache the result
     cleanCache();
-    conceptCache.set(cacheKey, {
-      concepts,
-      timestamp: Date.now()
-    });
-
+    conceptCache.set(cacheKey, { concepts, timestamp: Date.now() });
     return concepts;
   } catch (err) {
-    console.error('[openclaw-mem] LLM extraction error:', err.message);
+    console.error('[openclaw-mem] Concept extraction error:', err.message);
     return [];
   }
 }
 
 /**
- * Extract structured information from a tool call
- * @param {object} data - Tool call data
- * @returns {Promise<object>} - Extracted information
+ * Extract structured observation from a tool call
+ *
+ * Produces rich, searchable records with:
+ * - Accurate type classification
+ * - Descriptive title (short, action-oriented)
+ * - Detailed narrative (what happened, how it works, why it matters)
+ * - Structured facts (self-contained, grep-friendly)
+ * - Fixed concept categories
  */
 export async function extractFromToolCall(data) {
   const { tool_name, tool_input, tool_response, filesRead, filesModified } = data;
 
-  // Build context for extraction
+  // Provide generous context (2000 chars each, not 300)
   const inputStr = typeof tool_input === 'string'
-    ? tool_input.slice(0, 300)
-    : JSON.stringify(tool_input).slice(0, 300);
+    ? tool_input.slice(0, 2000)
+    : JSON.stringify(tool_input, null, 0).slice(0, 2000);
 
   const responseStr = typeof tool_response === 'string'
-    ? tool_response.slice(0, 300)
-    : JSON.stringify(tool_response).slice(0, 300);
+    ? tool_response.slice(0, 2000)
+    : JSON.stringify(tool_response, null, 0).slice(0, 2000);
 
   try {
-    const content = await callGatewayChat([{
-      role: 'user',
-      content: `Analyze this tool call and extract structured information. Return ONLY valid JSON.
+    const content = await callGatewayChat([
+      {
+        role: 'system',
+        content: `You are OpenClaw-Mem, a specialized observer that creates searchable memory records for FUTURE SESSIONS.
+
+Your job: analyze a tool call and produce a structured observation capturing what was LEARNED, BUILT, FIXED, or CONFIGURED.
+
+RULES:
+- Record deliverables and capabilities, not process steps
+- Use action verbs: implemented, fixed, deployed, configured, migrated, optimized, discovered, decided
+- The "narrative" field is the most important: explain WHAT happened, HOW it works, and WHY it matters
+- Facts must be self-contained statements (each fact should make sense without the others)
+- Title should be a short noun phrase (3-10 words) capturing the core topic
+
+TYPE DEFINITIONS (pick exactly one):
+- bugfix: something was broken and is now fixed
+- feature: new capability or functionality added
+- refactor: code restructured without behavior change
+- change: generic modification (docs, config, dependencies)
+- discovery: learning about existing system, reading code, exploring
+- decision: architectural or design choice with rationale
 
-Tool: ${tool_name}
+CONCEPT CATEGORIES (pick 1-3):
+- how-it-works: understanding mechanisms
+- why-it-exists: purpose or rationale
+- what-changed: modifications made
+- problem-solution: issues and their fixes
+- gotcha: traps or edge cases
+- pattern: reusable approach
+- trade-off: pros/cons of a decision
+
+Return ONLY valid JSON, no markdown fences, no explanation.`
+      },
+      {
+        role: 'user',
+        content: `Tool: ${tool_name}
 Input: ${inputStr}
 Output: ${responseStr}
 Files read: ${filesRead?.join(', ') || 'none'}
 Files modified: ${filesModified?.join(', ') || 'none'}
 
-Return JSON with these fields:
+Return JSON:
 {
-  "type": "decision|bugfix|feature|refactor|discovery|testing|setup|other",
-  "narrative": "One sentence describing what happened",
-  "facts": ["fact1", "fact2"],
-  "concepts": ["keyword1", "keyword2", "keyword3"]
-}
-
-JSON:`
-    }], { sessionKey: 'extract-toolcall', temperature: 0.2, max_tokens: 300 });
+  "type": "one of: bugfix|feature|refactor|change|discovery|decision",
+  "title": "Short descriptive title (3-10 words)",
+  "narrative": "2-4 sentences: what was done, how it works, why it matters. Be specific and include key details.",
+  "facts": ["Self-contained fact 1", "Self-contained fact 2", "...up to 5"],
+  "concepts": ["category1", "category2"]
+}`
+      }
+    ], { sessionKey: 'extract-toolcall', temperature: 0.2, max_tokens: 800 });
 
     if (!content) throw new Error('empty response');
 
-    // Parse JSON from response
     const match = content.match(/\{[\s\S]*\}/);
     if (match) {
       const result = JSON.parse(match[0]);
+
+      // Validate type
+      const validTypes = ['bugfix', 'feature', 'refactor', 'change', 'discovery', 'decision'];
+      const type = validTypes.includes(result.type) ? result.type : 'discovery';
+
+      // Validate concepts against fixed taxonomy
+      const concepts = Array.isArray(result.concepts)
+        ? result.concepts.filter(c => VALID_CONCEPTS.includes(c)).slice(0, 3)
+        : [];
+
       return {
-        type: result.type || 'other',
-        narrative: result.narrative || '',
-        facts: Array.isArray(result.facts) ? result.facts.slice(0, 5) : [],
-        concepts: Array.isArray(result.concepts) ? result.concepts.slice(0, 7) : []
+        type,
+        title: (result.title || '').slice(0, 120),
+        narrative: (result.narrative || '').slice(0, 1000),
+        facts: Array.isArray(result.facts)
+          ? result.facts.filter(f => typeof f === 'string').slice(0, 5)
+          : [],
+        concepts: concepts.length > 0 ? concepts : ['how-it-works']
       };
     }
   } catch (err) {
     console.error('[openclaw-mem] Tool extraction error:', err.message);
   }
 
-  // Return empty result on error
   return {
-    type: 'other',
+    type: 'discovery',
+    title: '',
     narrative: '',
     facts: [],
-    concepts: []
+    concepts: ['how-it-works']
   };
 }
 
 /**
  * Batch extract concepts from multiple texts
- * @param {string[]} texts - Array of texts to extract from
- * @returns {Promise<Map<string, string[]>>} - Map of text to concepts
  */
 export async function batchExtractConcepts(texts) {
   const results = new Map();
 
-  // Filter out cached results first
   const uncached = [];
   for (const text of texts) {
     const cacheKey = getCacheKey(text);
@@ -189,7 +247,6 @@ export async function batchExtractConcepts(texts) {
     }
   }
 
-  // Process uncached in batches
   const BATCH_SIZE = 5;
   for (let i = 0; i < uncached.length; i += BATCH_SIZE) {
     const batch = uncached.slice(i, i + BATCH_SIZE);

package/gateway-llm.js

@@ -27,7 +27,7 @@ function truncateText(text, maxChars) {
   return text.slice(0, maxChars) + '…';
 }
 
-function formatTranscript(messages, maxChars = 8000) {
+function formatTranscript(messages, maxChars = 12000) {
   const lines = [];
   for (const m of messages) {
     const role = (m.role || 'unknown').toUpperCase();
@@ -60,6 +60,7 @@ function normalizeSummaryFields(obj) {
   };
   return {
     request: pick('request'),
+    investigated: pick('investigated'),
     learned: pick('learned'),
     completed: pick('completed'),
     next_steps: pick('next_steps')
@@ -118,20 +119,37 @@ async function callGatewayChat(messages, options = {}) {
 
 export async function summarizeSession(messages, options = {}) {
   const { sessionKey = 'unknown' } = options;
-  const transcript = formatTranscript(messages);
+  const transcript = formatTranscript(messages, 12000);
   if (!transcript) return null;
 
   const buildPrompts = (strict = false) => {
-    const systemPrompt = [
-      '你是一个对话总结助手。请用中文总结这段对话，返回一个 JSON 对象，包含以下字段：',
-      '- request: 用户的主要问题或需求（一句话）',
-      '- learned: 用户从对话中学到了什么',
-      '- completed: 完成了什么任务或解答',
-      '- next_steps: 建议的下一步行动',
-      '只返回 JSON 对象，不要 markdown 代码块，不要其他内容。',
-      strict ? '重要：只输出纯 JSON，不要任何额外文字。' : ''
-    ].filter(Boolean).join('\n');
-    const userPrompt = '对话记录:\n' + transcript + '\n\nJSON:';
+    const systemPrompt = `You are a session summarizer for an AI agent memory system. Your summaries help the agent recall past work in future sessions.
+
+INSTRUCTIONS:
+- Focus on OUTCOMES and DELIVERABLES, not conversational flow
+- Use action verbs: implemented, fixed, configured, discovered, decided, explored
+- Be specific: include file names, tool names, error messages, key decisions
+- Write in the language the user used (Chinese if they spoke Chinese, English if English)
+
+OUTPUT FORMAT: Return ONLY a valid JSON object with these fields:
+{
+  "request": "What the user wanted to accomplish (1 sentence, specific)",
+  "investigated": "What was explored or researched to fulfill the request",
+  "learned": "Key technical insights, discoveries, or new understanding gained",
+  "completed": "Concrete deliverables: what was built, fixed, configured, or decided",
+  "next_steps": "Unfinished work or logical follow-up actions (null if fully completed)"
+}
+
+QUALITY GUIDELINES:
+- "request" should capture the real goal, not just "user asked a question"
+- "investigated" should list specific files read, APIs explored, architectures examined
+- "learned" should contain reusable knowledge (not "learned how to do X" but the actual insight)
+- "completed" should be a concrete outcome someone can verify
+- "next_steps" should be actionable, not vague
+
+${strict ? 'CRITICAL: Output ONLY the JSON object. No markdown, no explanation, no code fences.' : ''}`;
+
+    const userPrompt = 'Session transcript:\n' + transcript + '\n\nJSON:';
     return [
       { role: 'system', content: systemPrompt },
       { role: 'user', content: userPrompt }
@@ -139,17 +157,94 @@ export async function summarizeSession(messages, options = {}) {
   };
 
   // First attempt
-  let content = await callGatewayChat(buildPrompts(false), { sessionKey, temperature: 0.2, max_tokens: 300 });
+  let content = await callGatewayChat(buildPrompts(false), { sessionKey, temperature: 0.2, max_tokens: 600 });
   let parsed = parseSummaryJson(content || '');
   if (parsed) return normalizeSummaryFields(parsed);
 
   // Retry once with stricter instruction
-  content = await callGatewayChat(buildPrompts(true), { sessionKey, temperature: 0.2, max_tokens: 300 });
+  content = await callGatewayChat(buildPrompts(true), { sessionKey, temperature: 0.1, max_tokens: 600 });
   parsed = parseSummaryJson(content || '');
   if (parsed) return normalizeSummaryFields(parsed);
 
   return null;
 }
 
+// ============ Local Embedding Model (Qwen3-Embedding-0.6B) ============
+
+const EMBEDDING_MODEL = 'Xenova/multilingual-e5-small';
+const EMBEDDING_DIMS = 384;
+const EMBEDDING_PREFIX = 'query: ';
+
+// Singleton: lazily initialized embedding pipeline
+let _extractorPromise = null;
+
+function getExtractor() {
+  if (!_extractorPromise) {
+    _extractorPromise = (async () => {
+      try {
+        const { pipeline } = await import('@huggingface/transformers');
+        console.log('[openclaw-mem] Loading embedding model (first run downloads ~110MB)...');
+        const extractor = await pipeline('feature-extraction', EMBEDDING_MODEL);
+        console.log('[openclaw-mem] Embedding model loaded');
+        return extractor;
+      } catch (err) {
+        console.error('[openclaw-mem] Failed to load embedding model:', err.message);
+        _extractorPromise = null; // Allow retry
+        return null;
+      }
+    })();
+  }
+  return _extractorPromise;
+}
+
+/**
+ * Generate embedding vector for text using local Qwen3-Embedding-0.6B model.
+ * Returns Float32Array of 1024 dimensions, or null on failure.
+ */
+export async function callGatewayEmbeddings(text) {
+  try {
+    const extractor = await getExtractor();
+    if (!extractor) return null;
+
+    const input = EMBEDDING_PREFIX + text;
+    const output = await extractor(input, {
+      pooling: 'mean',
+      normalize: true,
+    });
+
+    return new Float32Array(output.data);
+  } catch (err) {
+    console.error('[openclaw-mem] Embedding generation error:', err.message);
+    return null;
+  }
+}
+
+/**
+ * Generate embeddings for multiple texts sequentially.
+ * Returns array of Float32Array, or null entries on failure.
+ */
+export async function batchEmbeddings(texts) {
+  const extractor = await getExtractor();
+  if (!extractor) return texts.map(() => null);
+
+  const results = [];
+  for (const text of texts) {
+    try {
+      const input = EMBEDDING_PREFIX + text;
+      const output = await extractor(input, {
+        pooling: 'mean',
+        normalize: true,
+      });
+      results.push(new Float32Array(output.data));
+    } catch (err) {
+      console.error('[openclaw-mem] Batch embedding error:', err.message);
+      results.push(null);
+    }
+  }
+  return results;
+}
+
+export { EMBEDDING_DIMS };
+
 export const INTERNAL_SUMMARY_PREFIX = SUMMARY_SESSION_PREFIX;
 export { callGatewayChat };

package/handler.js

@@ -14,11 +14,11 @@ import path from 'node:path';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
-import { summarizeSession, INTERNAL_SUMMARY_PREFIX } from './gateway-llm.js';
+import { summarizeSession, INTERNAL_SUMMARY_PREFIX, callGatewayEmbeddings } from './gateway-llm.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 console.log('[openclaw-mem] >>> HANDLER LOADED AT', new Date().toISOString(), '<<<');
-const USE_LLM_EXTRACTION = false;
+const USE_LLM_EXTRACTION = true;
 const SUMMARY_MAX_MESSAGES = 200;
 const MCP_API_PORT = 18790;
 
@@ -255,102 +255,9 @@ async function handleAgentBootstrap(event) {
     console.log('[openclaw-mem] Sample has content:', !!sample.content);
   }
 
-  // ============ NEW: Capture incoming messages to database ============
-  // This ensures every message through gateway is captured, not just on /new
-  // Messages can be in: event.messages (array), event.message, or event.context.userMessage
-  let messagesToCapture = [];
-
-  // ============ Capture messages from session file ============
-  // At bootstrap time, the incoming message isn't in the event yet
-  // But we can read the session file which contains previous messages
-
-  // Construct session file path from sessionKey
-  // Session files are stored at ~/.openclaw/agents/main/sessions/<sessionKey>.jsonl
-  const agentId = event.context?.agentId || 'main';
-  const sessionFile = path.join(os.homedir(), '.openclaw', 'agents', agentId, 'sessions', `${sessionKey}.jsonl`);
-  console.log('[openclaw-mem] Constructed session file path:', sessionFile);
-
-  // Check if session file exists
-  let sessionFileExists = false;
-  try {
-    await fs.access(sessionFile);
-    sessionFileExists = true;
-  } catch {
-    sessionFileExists = false;
-  }
-
-  if (sessionFileExists) {
-    console.log('[openclaw-mem] Found session file:', sessionFile);
-    try {
-      const messages = await extractSessionContent(sessionFile, 50);
-      if (messages && messages.length > 0) {
-        console.log(`[openclaw-mem] Found ${messages.length} messages in session file`);
-
-        // Get or create session for this sessionKey
-        let dbSessionId = getOrCreateSessionForKey(sessionKey, workspaceDir);
-
-        // Track which messages we've already saved (to avoid duplicates)
-        const savedHashes = new Set();
-        try {
-          const existing = database.getRecentObservations(null, 100);
-          for (const obs of existing) {
-            // Content is stored in the 'result' field as JSON
-            try {
-              const result = JSON.parse(obs.result || '{}');
-              if (result.content) {
-                savedHashes.add(hashContent(result.content));
-              }
-            } catch {
-              // If result isn't JSON, use summary
-              if (obs.summary) {
-                savedHashes.add(hashContent(obs.summary));
-              }
-            }
-          }
-          console.log(`[openclaw-mem] Loaded ${savedHashes.size} existing message hashes`);
-        } catch (e) {
-          console.log('[openclaw-mem] Could not check existing observations:', e.message);
-        }
-
-        let newCount = 0;
-        for (const msg of messages) {
-          const contentHash = hashContent(msg.content);
-          if (savedHashes.has(contentHash)) {
-            continue; // Skip already saved messages
-          }
-
-          const toolName = msg.role === 'assistant' ? 'AssistantMessage' : 'UserMessage';
-          const summary = msg.content.slice(0, 100) + (msg.content.length > 100 ? '...' : '');
-          database.saveObservation(
-            dbSessionId,
-            toolName,
-            { role: msg.role, sessionKey },
-            { content: msg.content },
-            {
-              summary,
-              // Use full message text so FTS can index real topics
-              concepts: msg.content,
-              tokensDiscovery: estimateTokens(msg.content),
-              tokensRead: estimateTokens(summary)
-            }
-          );
-          savedHashes.add(contentHash);
-          newCount++;
-        }
-
-        if (newCount > 0) {
-          console.log(`[openclaw-mem] ✓ Saved ${newCount} new messages to database`);
-        } else {
-          console.log('[openclaw-mem] All messages already in database');
-        }
-      }
-    } catch (err) {
-      console.log('[openclaw-mem] Could not read session file:', err.message);
-    }
-  } else {
-    console.log('[openclaw-mem] No session file found in context');
-  }
-  // ============ END: Capture messages ============
+  // Raw messages are no longer stored individually — session summaries capture the important bits.
+  // This eliminates noise from greetings and low-value messages.
+  console.log('[openclaw-mem] Skipping per-message capture (handled via session summary)');
 
   // Ensure API server is running
   await startApiServer();
@@ -488,30 +395,8 @@ async function handleCommandNew(event) {
 
   if (messages && messages.length > 0) {
     console.log(`[openclaw-mem] Extracted ${messages.length} messages from session`);
-
-    // Save each message as an observation
-    for (const msg of messages) {
-      const toolName = msg.role === 'user' ? 'UserMessage' : 'AssistantMessage';
-      const summary = msg.content.slice(0, 100) + (msg.content.length > 100 ? '...' : '');
-
-      database.saveObservation(
-        sessionId,
-        toolName,
-        { role: msg.role },
-        { content: msg.content },
-        {
-          summary,
-          // Use message body for concepts to keep topic search working
-          concepts: msg.content,
-          tokensDiscovery: estimateTokens(msg.content),
-          tokensRead: estimateTokens(summary)
-        }
-      );
-    }
-
-    console.log('[openclaw-mem] Session saved successfully');
-    console.log('[openclaw-mem] >>> CODE VERSION 2026-02-03-1622 <<<');
-    console.log('[openclaw-mem] >>> STARTING AI SUMMARY <<<');
+    // Raw messages are no longer stored individually — only the AI summary matters.
+    console.log('[openclaw-mem] Generating AI summary...');
 
     // Generate AI summary using DeepSeek
     let aiSummary = null;
@@ -528,6 +413,7 @@ async function handleCommandNew(event) {
         sessionId,
         summaryContent,
         aiSummary.request,
+        aiSummary.investigated || null,
         aiSummary.learned,
         aiSummary.completed,
         aiSummary.next_steps
@@ -545,6 +431,7 @@ async function handleCommandNew(event) {
         `Session with ${messages.length} messages`,
         fallbackRequest,
         null,
+        null,
         fallbackCompleted ? `Discussed: ${fallbackCompleted}` : null,
         null
       );
@@ -558,76 +445,20 @@ async function handleCommandNew(event) {
 
 /**
  * Handle agent:response event
- * Capture assistant responses to database
+ * Skip storing raw assistant messages — session summary at stop/new captures the important bits.
+ * This avoids noise from greetings, acknowledgments, and other low-value messages.
  */
 async function handleAgentResponse(event) {
-  console.log('[openclaw-mem] Agent response event');
-
-  if (!await loadModules()) return;
-
-  const sessionKey = event.sessionKey || 'unknown';
-  const response = event.response || event.message || event.content;
-  const workspaceDir = event.context?.workspaceDir || path.join(os.homedir(), '.openclaw', 'workspace');
-
-  if (response && typeof response === 'string' && response.trim()) {
-    console.log('[openclaw-mem] Capturing assistant response:', response.slice(0, 50) + '...');
-
-    let sessionId = getOrCreateSessionForKey(sessionKey, workspaceDir);
-
-    const summary = response.slice(0, 100) + (response.length > 100 ? '...' : '');
-    database.saveObservation(
-      sessionId,
-      'AssistantMessage',
-      { role: 'assistant', sessionKey },
-      { content: response },
-      {
-        summary,
-        // Keep full content in concepts column for better topic recall
-        concepts: response,
-        tokensDiscovery: estimateTokens(response),
-        tokensRead: estimateTokens(summary)
-      }
-    );
-    console.log('[openclaw-mem] ✓ Assistant response saved to database');
-  }
+  console.log('[openclaw-mem] Agent response event (skipped — captured via session summary)');
 }
 
 /**
  * Handle message events
- * Alternative event type for capturing messages
+ * Skip storing raw messages — session summary at stop/new captures the important bits.
+ * This avoids noise from greetings, acknowledgments, and other low-value messages.
  */
 async function handleMessage(event) {
-  console.log('[openclaw-mem] Message event:', event.action || 'unknown');
-
-  if (!await loadModules()) return;
-
-  const sessionKey = event.sessionKey || 'unknown';
-  const message = event.message || event.content || event.text;
-  const role = event.role || event.action || 'user';
-  const workspaceDir = event.context?.workspaceDir || path.join(os.homedir(), '.openclaw', 'workspace');
-
-  if (message && typeof message === 'string' && message.trim() && !message.startsWith('/')) {
-    console.log(`[openclaw-mem] Capturing ${role} message:`, message.slice(0, 50) + '...');
-
-    let sessionId = getOrCreateSessionForKey(sessionKey, workspaceDir);
-
-    const toolName = role === 'assistant' ? 'AssistantMessage' : 'UserMessage';
-    const summary = message.slice(0, 100) + (message.length > 100 ? '...' : '');
-    database.saveObservation(
-      sessionId,
-      toolName,
-      { role, sessionKey },
-      { content: message },
-      {
-        summary,
-        // Index actual message text (not just role) for topic search
-        concepts: message,
-        tokensDiscovery: estimateTokens(message),
-        tokensRead: estimateTokens(summary)
-      }
-    );
-    console.log(`[openclaw-mem] ✓ ${role} message saved to database`);
-  }
+  console.log('[openclaw-mem] Message event (skipped — captured via session summary)');
 }
 
 /**
@@ -830,15 +661,19 @@ async function handleToolPost(event) {
         extractedNarrative = extracted.narrative || narrative;
         extractedFacts = extracted.facts;
         extractedConcepts = extracted.concepts?.join(', ') || extractedConcepts;
+        // Use LLM-generated title as summary if available
+        if (extracted.title) {
+          summary = extracted.title;
+        }
       }
-      console.log(`[openclaw-mem] LLM extracted: type=${extractedType}, concepts=${extractedConcepts.slice(0, 50)}...`);
+      console.log(`[openclaw-mem] LLM extracted: type=${extractedType}, title=${summary.slice(0, 60)}, concepts=${extractedConcepts}`);
     } catch (err) {
       console.log(`[openclaw-mem] LLM extraction failed, using fallback: ${err.message}`);
     }
   }
 
   // Save observation with extended metadata
-  database.saveObservation(
+  const saveResult = database.saveObservation(
     sessionId,
     toolName,
     toolInput,
@@ -849,7 +684,7 @@ async function handleToolPost(event) {
       tokensDiscovery: estimateTokens(responseStr),
       tokensRead: estimateTokens(summary),
       type: extractedType,
-      narrative: extractedNarrative.slice(0, 500),
+      narrative: extractedNarrative.slice(0, 1000),
       facts: extractedFacts,
       filesRead: filesRead,
       filesModified: filesModified
@@ -857,6 +692,21 @@ async function handleToolPost(event) {
   );
 
   console.log(`[openclaw-mem] ✓ Tool ${toolName} recorded (type: ${extractedType})`);
+
+  // Fire-and-forget: generate embedding for the new observation
+  if (saveResult.success && saveResult.id) {
+    const embeddingText = [summary, extractedNarrative].filter(Boolean).join(' ').trim();
+    if (embeddingText.length > 10) {
+      callGatewayEmbeddings(embeddingText).then(embedding => {
+        if (embedding) {
+          database.saveEmbedding(Number(saveResult.id), embedding);
+          console.log(`[openclaw-mem] ✓ Embedding saved for observation #${saveResult.id}`);
+        }
+      }).catch(err => {
+        console.log(`[openclaw-mem] Embedding generation failed: ${err.message}`);
+      });
+    }
+  }
 }
 
 /**
@@ -898,40 +748,7 @@ async function handleUserPromptSubmit(event) {
   database.saveUserPrompt(sessionId, prompt);
   console.log(`[openclaw-mem] ✓ User prompt saved (${prompt.slice(0, 50)}...)`);
 
-  // Also save as an observation for searchability
-  const summary = prompt.slice(0, 100) + (prompt.length > 100 ? '...' : '');
-
-  // Try LLM extraction for concepts
-  let concepts = prompt;
-  if (USE_LLM_EXTRACTION && extractor && extractor.extractConcepts) {
-    try {
-      const extracted = await extractor.extractConcepts(prompt);
-      if (extracted && extracted.length > 0) {
-        concepts = extracted.join(', ');
-      }
-    } catch (err) {
-      console.log('[openclaw-mem] LLM extraction failed for prompt:', err.message);
-    }
-  }
-
-  database.saveObservation(
-    sessionId,
-    'UserPrompt',
-    { prompt: prompt.slice(0, 500) },
-    { recorded: true },
-    {
-      summary,
-      concepts,
-      tokensDiscovery: estimateTokens(prompt),
-      tokensRead: estimateTokens(summary),
-      type: 'user_input',
-      narrative: `User asked: ${summary}`,
-      facts: null,
-      filesRead: null,
-      filesModified: null
-    }
-  );
-  console.log('[openclaw-mem] ✓ User prompt observation saved');
+  // User prompts are saved to user_prompts table only (no observation duplication).
 }
 
 /**
@@ -1014,6 +831,7 @@ async function handleAgentStop(event) {
         sessionId,
         summaryContent,
         summary.request,
+        summary.investigated || null,
         summary.learned,
         summary.completed,
         summary.next_steps
@@ -1031,7 +849,8 @@ async function handleAgentStop(event) {
         sessionId,
         summaryContent,
         firstUserMsg,
-        '',
+        null,
+        null,
         `Discussed: ${lastAssistant}`,
         null
       );

package/mcp-http-api.js

@@ -9,6 +9,7 @@
 
 import http from 'http';
 import database from './database.js';
+import { callGatewayEmbeddings } from './gateway-llm.js';
 
 const PORT = process.env.OPENCLAW_MEM_API_PORT || 18790;
 
@@ -90,9 +91,53 @@ function normalizeIds(input) {
   return ids;
 }
 
+// ============ Hybrid Search ============
+
+function mergeHybridResults(ftsResults, vectorResults, limit) {
+  let ftsMin = Infinity, ftsMax = -Infinity;
+  for (const r of ftsResults) {
+    const rank = Math.abs(r.rank ?? 0);
+    if (rank < ftsMin) ftsMin = rank;
+    if (rank > ftsMax) ftsMax = rank;
+  }
+  const ftsRange = ftsMax - ftsMin || 1;
+
+  const scoreMap = new Map();
+
+  for (const r of ftsResults) {
+    const rank = Math.abs(r.rank ?? 0);
+    const ftsScore = 1 - ((rank - ftsMin) / ftsRange);
+    scoreMap.set(r.id, { obs: r, ftsScore, vecScore: 0 });
+  }
+
+  for (const v of vectorResults) {
+    const vecScore = 1 - (v.distance ?? 0);
+    const existing = scoreMap.get(v.observation_id);
+    if (existing) {
+      existing.vecScore = vecScore;
+    } else {
+      const obs = database.getObservation(v.observation_id);
+      if (obs) {
+        scoreMap.set(v.observation_id, { obs, ftsScore: 0, vecScore });
+      }
+    }
+  }
+
+  const scored = [];
+  for (const [id, entry] of scoreMap) {
+    const { obs, ftsScore, vecScore } = entry;
+    const inBoth = ftsScore > 0 && vecScore > 0;
+    const combined = (0.4 * ftsScore) + (0.6 * vecScore) + (inBoth ? 0.2 : 0);
+    scored.push({ obs, combined });
+  }
+
+  scored.sort((a, b) => b.combined - a.combined);
+  return scored.slice(0, limit).map(s => s.obs);
+}
+
 // ============ API 功能 ============
 
-function search(args = {}) {
+async function search(args = {}) {
   const query = typeof args === 'string' ? args : (args.query || args.q || '*');
   const limit = args.limit ?? 30;
 
@@ -100,7 +145,25 @@ function search(args = {}) {
   if (query === '*' || !query) {
     results = database.getRecentObservations(null, limit);
   } else {
-    results = database.searchObservations(query, limit);
+    // Hybrid search: FTS + vector
+    const ftsResults = database.searchObservations(query, limit * 2);
+
+    let vectorResults = [];
+    try {
+      const embedding = await callGatewayEmbeddings(query);
+      if (embedding) {
+        vectorResults = database.searchByVector(embedding, limit * 2);
+      }
+    } catch (err) {
+      console.error('[openclaw-mem-api] Vector search error:', err.message);
+    }
+
+    if (vectorResults.length > 0) {
+      results = mergeHybridResults(ftsResults, vectorResults, limit);
+      console.log(`[openclaw-mem-api] Hybrid: ${ftsResults.length} FTS + ${vectorResults.length} vector → ${results.length} merged`);
+    } else {
+      results = ftsResults.slice(0, limit);
+    }
   }
 
   // 按日期分组
@@ -229,7 +292,7 @@ const server = http.createServer((req, res) => {
 
   let body = '';
   req.on('data', chunk => body += chunk);
-  req.on('end', () => {
+  req.on('end', async () => {
     // 处理未编码的中文 URL - 手动编码非 ASCII 字符
     let safeUrl = req.url;
     try {
@@ -278,7 +341,7 @@ const server = http.createServer((req, res) => {
           break;
 
         case '/search':
-          result = search(args);
+          result = await search(args);
           break;
 
         case '/timeline':
@@ -342,6 +405,11 @@ curl -X POST "http://localhost:${PORT}/get_observations" -d '{"ids":[123,124]}'
 server.listen(PORT, '127.0.0.1', () => {
   console.log(`[openclaw-mem] HTTP API running on http://127.0.0.1:${PORT}`);
   console.log(`[openclaw-mem] Try: curl "http://127.0.0.1:${PORT}/help"`);
+
+  // Preload embedding model in background
+  callGatewayEmbeddings('warmup').then(() => {
+    console.log('[openclaw-mem] Embedding model preloaded for HTTP API');
+  }).catch(() => {});
 });
 
 // 优雅关闭

package/mcp-server.js

@@ -13,6 +13,7 @@ import {
   ListToolsRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 import database from './database.js';
+import { callGatewayEmbeddings } from './gateway-llm.js';
 
 // ============ 工具函数 ============
 
@@ -97,7 +98,57 @@ function normalizeIds(input) {
 
 // ============ 搜索功能 ============
 
-function search(args = {}) {
+/**
+ * Hybrid search: merge FTS5 keyword results with vector KNN results.
+ * FTS results get fts_score (normalized 0-1), vector results get vec_score (1 - distance).
+ * Results found in both get a 0.2 intersection bonus.
+ */
+function mergeHybridResults(ftsResults, vectorResults, limit) {
+  // Normalize FTS scores (rank is negative, lower is better)
+  let ftsMin = Infinity, ftsMax = -Infinity;
+  for (const r of ftsResults) {
+    const rank = Math.abs(r.rank ?? 0);
+    if (rank < ftsMin) ftsMin = rank;
+    if (rank > ftsMax) ftsMax = rank;
+  }
+  const ftsRange = ftsMax - ftsMin || 1;
+
+  const scoreMap = new Map(); // id -> { obs, ftsScore, vecScore }
+
+  for (const r of ftsResults) {
+    const rank = Math.abs(r.rank ?? 0);
+    const ftsScore = 1 - ((rank - ftsMin) / ftsRange); // normalize to 0-1, higher is better
+    scoreMap.set(r.id, { obs: r, ftsScore, vecScore: 0 });
+  }
+
+  for (const v of vectorResults) {
+    const vecScore = 1 - (v.distance ?? 0); // cosine distance -> similarity
+    const existing = scoreMap.get(v.observation_id);
+    if (existing) {
+      existing.vecScore = vecScore;
+    } else {
+      // Need to fetch the full observation for vector-only results
+      const obs = database.getObservation(v.observation_id);
+      if (obs) {
+        scoreMap.set(v.observation_id, { obs, ftsScore: 0, vecScore });
+      }
+    }
+  }
+
+  // Calculate combined scores
+  const scored = [];
+  for (const [id, entry] of scoreMap) {
+    const { obs, ftsScore, vecScore } = entry;
+    const inBoth = ftsScore > 0 && vecScore > 0;
+    const combined = (0.4 * ftsScore) + (0.6 * vecScore) + (inBoth ? 0.2 : 0);
+    scored.push({ obs, combined, ftsScore, vecScore });
+  }
+
+  scored.sort((a, b) => b.combined - a.combined);
+  return scored.slice(0, limit);
+}
+
+async function search(args = {}) {
   const query = typeof args === 'string' ? args : (args.query || args.q || '*');
   const limit = args.limit ?? args.maxResults ?? 30;
   const project = args.project || null;
@@ -108,11 +159,33 @@ function search(args = {}) {
   let results;
 
   if (query === '*' || !query) {
-    // 获取最近的 observations
+    // 获取最近的 observations — no embedding needed for recent listing
     results = database.getRecentObservations(project, limit * 2);
   } else {
-    // 搜索
-    results = database.searchObservations(query, limit * 2);
+    // Hybrid search: FTS5 + vector KNN
+    const ftsResults = database.searchObservations(query, limit * 2);
+
+    // Try vector search in parallel
+    let vectorResults = [];
+    try {
+      const embedding = await callGatewayEmbeddings(query);
+      if (embedding) {
+        vectorResults = database.searchByVector(embedding, limit * 2);
+      }
+    } catch (err) {
+      console.error('[openclaw-mem-mcp] Vector search error:', err.message);
+    }
+
+    if (vectorResults.length > 0) {
+      // Merge hybrid results
+      const merged = mergeHybridResults(ftsResults, vectorResults, limit * 2);
+      results = merged.map(m => m.obs);
+      console.error(`[openclaw-mem-mcp] Hybrid search: ${ftsResults.length} FTS + ${vectorResults.length} vector → ${results.length} merged`);
+    } else {
+      // Fallback to FTS-only
+      results = ftsResults;
+      console.error(`[openclaw-mem-mcp] FTS-only search: ${results.length} results`);
+    }
   }
 
   // 过滤
@@ -475,7 +548,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         break;
 
       case 'search':
-        result = search(args || {});
+        result = await search(args || {});
         break;
 
       case 'timeline':
@@ -517,6 +590,13 @@ async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error('[openclaw-mem-mcp] MCP Server started (stdio)');
+
+  // Preload embedding model in background so first search doesn't timeout
+  callGatewayEmbeddings('warmup').then(() => {
+    console.error('[openclaw-mem-mcp] Embedding model preloaded');
+  }).catch(() => {
+    console.error('[openclaw-mem-mcp] Embedding model preload failed (will retry on first search)');
+  });
 }
 
 main().catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-mem",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Persistent memory system for OpenClaw - captures conversations, generates summaries, and injects context into new sessions",
   "type": "module",
   "main": "handler.js",
@@ -20,7 +20,8 @@
     "api:start": "nohup node mcp-http-api.js > ~/.openclaw-mem/logs/api.log 2>&1 &",
     "debug": "node debug-logger.js",
     "setup": "node setup.js",
-    "postinstall": "node setup.js"
+    "postinstall": "node setup.js",
+    "backfill-embeddings": "node backfill-embeddings.js"
   },
   "keywords": [
     "openclaw",
@@ -63,13 +64,16 @@
     "session-watcher.js",
     "sync-recent.js",
     "setup.js",
+    "backfill-embeddings.js",
     "HOOK.md",
     "MCP.json",
     "README.md"
   ],
   "dependencies": {
+    "@huggingface/transformers": "^3.8.1",
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "better-sqlite3": "^11.0.0"
+    "better-sqlite3": "^12.6.2",
+    "sqlite-vec": "^0.1.7-alpha.2"
   },
   "devDependencies": {
     "vitest": "^2.0.0"