openclaw-node-harness 2.0.0

package/skills/memorylayer/SKILL.md

@@ -0,0 +1,227 @@
+---
+slug: memorylayer
+name: MemoryLayer
+description: "External SaaS semantic memory with vector search for AI agents. Use when you need to store/retrieve memories via MemoryLayer API, reduce token usage with semantic retrieval, or manage multi-tenant agent memory at scale."
+homepage: https://memorylayer.clawbot.hk
+triggers:
+  - "memorylayer"
+  - "semantic memory search"
+  - "vector search memories"
+  - "store memory with embeddings"
+  - "reduce token usage on memory"
+negative_triggers:
+  - "self-reflection"
+  - "local memory files"
+  - "clawvault"
+  - "edit MEMORY.md"
+metadata:
+  clawdbot:
+    emoji: "🧠"
+---
+
+# MemoryLayer
+
+Semantic memory infrastructure for AI agents that actually scales.
+
+## Features
+
+- **95% Token Savings** - Retrieve only relevant memories
+- **Semantic Search** - Find memories by meaning, not keywords
+- **Sub-200ms** - Lightning-fast memory retrieval
+- **Multi-tenant** - Isolated memory per agent instance
+
+## Setup
+
+### 1. Sign up for FREE account
+
+Visit https://memorylayer.clawbot.hk and sign up with Google. You'll get:
+- 10,000 operations/month
+- 1GB storage
+- Community support
+
+### 2. Configure credentials
+
+```bash
+# Option 1: Email/Password
+export MEMORYLAYER_EMAIL=your@email.com
+export MEMORYLAYER_PASSWORD=your_password
+
+# Option 2: API Key (recommended for production)
+export MEMORYLAYER_API_KEY=ml_your_api_key_here
+```
+
+### 3. Install Python SDK (if not using skill wrapper)
+
+```bash
+pip install memorylayer
+```
+
+## Usage
+
+### Basic Example
+
+```javascript
+// In your Clawdbot agent
+const memory = require('memorylayer');
+
+// Store a memory
+await memory.remember(
+  'User prefers dark mode UI',
+  { type: 'semantic', importance: 0.8 }
+);
+
+// Search memories
+const results = await memory.search('UI preferences');
+console.log(results[0].content); // "User prefers dark mode UI"
+```
+
+### Python Example
+
+```python
+from plugins.memorylayer import memory
+
+# Store
+memory.remember(
+    "Boss prefers direct reporting with zero bullshit",
+    memory_type="semantic",
+    importance=0.9
+)
+
+# Search
+results = memory.recall("What are Boss's preferences?")
+for r in results:
+    print(f"{r.relevance_score:.2f}: {r.memory.content}")
+```
+
+### Token Savings
+
+**Before MemoryLayer:**
+```python
+# Inject entire memory files
+context = open('MEMORY.md').read()  # 10,500 tokens
+prompt = f"{context}\n\nUser: What are my preferences?"
+```
+
+**After MemoryLayer:**
+```python
+# Inject only relevant memories
+context = memory.get_context("user preferences", limit=5)  # ~500 tokens
+prompt = f"{context}\n\nUser: What are my preferences?"
+```
+
+**Result:** 95% token reduction, $900/month savings at scale
+
+## API Reference
+
+### `memory.remember(content, options)`
+
+Store a new memory.
+
+**Parameters:**
+- `content` (string): Memory content
+- `options.type` (string): 'episodic' | 'semantic' | 'procedural'
+- `options.importance` (number): 0.0 to 1.0
+- `options.metadata` (object): Additional tags/data
+
+**Returns:** Memory object with `id`
+
+### `memory.search(query, limit)`
+
+Search memories semantically.
+
+**Parameters:**
+- `query` (string): Search query (natural language)
+- `limit` (number): Max results (default: 10)
+
+**Returns:** Array of SearchResult objects
+
+### `memory.get_context(query, limit)`
+
+Get formatted context for prompt injection.
+
+**Parameters:**
+- `query` (string): What context do you need?
+- `limit` (number): Max memories (default: 5)
+
+**Returns:** Formatted string ready for prompt
+
+### `memory.stats()`
+
+Get usage statistics.
+
+**Returns:** Object with `total_memories`, `memory_types`, `operations_this_month`
+
+## Advanced
+
+### Memory Types
+
+**Episodic** - Events and experiences
+```javascript
+memory.remember('Deployed MemoryLayer on 2026-02-03', { type: 'episodic' });
+```
+
+**Semantic** - Facts and knowledge
+```javascript
+memory.remember('Boss prefers concise reports', { type: 'semantic' });
+```
+
+**Procedural** - How-to and processes
+```javascript
+memory.remember('To restart server: ssh root@... && systemctl restart...', { type: 'procedural' });
+```
+
+### Metadata Tagging
+
+```javascript
+memory.remember('User likes blue', {
+  type: 'semantic',
+  metadata: {
+    category: 'preferences',
+    subcategory: 'colors',
+    source: 'user_profile'
+  }
+});
+```
+
+### Usage Tracking
+
+```javascript
+const stats = await memory.stats();
+console.log(`Total memories: ${stats.total_memories}`);
+console.log(`Operations this month: ${stats.operations_this_month}`);
+console.log(`Plan: ${stats.plan} (${stats.operations_limit}/month)`);
+```
+
+## Pricing
+
+**FREE Plan** (Current)
+- 10,000 operations/month
+- 1GB storage
+- Community support
+
+**Pro Plan** ($99/mo)
+- 1M operations/month
+- 10GB storage
+- Email support
+- 99.9% SLA
+
+**Enterprise** (Custom)
+- Unlimited operations
+- Unlimited storage
+- Dedicated support
+- Self-hosted option
+- Custom SLA
+
+## Support
+
+- **Documentation:** https://memorylayer.clawbot.hk/docs
+- **API Reference:** https://memorylayer.clawbot.hk/api
+- **Community:** Discord (link in docs)
+- **Issues:** GitHub (link in docs)
+
+## Links
+
+- **Homepage:** https://memorylayer.clawbot.hk
+- **Dashboard:** https://dashboard.memorylayer.clawbot.hk
+- **API Docs:** https://memorylayer.clawbot.hk/docs
+- **Python SDK:** https://pypi.org/project/memorylayer (when published)

package/skills/memorylayer/examples/agent-integration.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+/**
+ * MemoryLayer Agent Integration Example
+ * 
+ * This example shows how to integrate MemoryLayer into an AI agent workflow:
+ * 1. Inject relevant context into prompts
+ * 2. Store important learnings from conversations
+ * 3. Build up agent knowledge over time
+ */
+
+const memory = require('../index.js');
+
+// Simulated AI agent
+class AIAgent {
+  constructor() {
+    this.name = 'ClawdBot';
+  }
+  
+  async processUserMessage(message) {
+    console.log(`\n👤 User: ${message}`);
+    
+    // 1. Get relevant context from MemoryLayer
+    const context = await memory.get_context(message, 5);
+    
+    // 2. Build prompt with context
+    const prompt = `${context}
+
+User message: ${message}
+
+Based on the relevant memories above, provide a helpful response.`;
+    
+    console.log('\n🧠 Agent thinking...');
+    console.log('Context retrieved:');
+    console.log(context);
+    
+    // 3. Simulate AI response (in real use, this would call your LLM)
+    let response;
+    if (message.includes('preferences')) {
+      response = "Based on your preferences, I see you prefer dark mode UI with blue accents. I'll keep that in mind!";
+      
+      // 4. Store this interaction as a memory
+      await memory.remember(
+        `User asked about their preferences on ${new Date().toISOString().split('T')[0]}`,
+        { type: 'episodic', importance: 0.5 }
+      );
+      
+    } else if (message.includes('export')) {
+      response = "To export your data, go to Settings > Account > Export Data button. Let me know if you need help!";
+      
+    } else {
+      response = "I'm here to help! What would you like to know?";
+    }
+    
+    console.log(`\n🤖 ${this.name}: ${response}`);
+    
+    return response;
+  }
+  
+  async learnFromFeedback(feedback, importance = 0.7) {
+    // Store important learnings
+    await memory.remember(feedback, {
+      type: 'semantic',
+      importance,
+      metadata: {
+        source: 'user_feedback',
+        timestamp: new Date().toISOString()
+      }
+    });
+    
+    console.log(`\n📚 Learned: ${feedback}`);
+  }
+}
+
+async function main() {
+  console.log('🤖 MemoryLayer Agent Integration Example\n');
+  console.log('=' .repeat(50));
+  
+  try {
+    const agent = new AIAgent();
+    
+    // Store some initial preferences
+    console.log('\n📝 Setting up agent knowledge...');
+    await memory.remember(
+      'User prefers dark mode UI with blue accent colors',
+      { type: 'semantic', importance: 0.8 }
+    );
+    
+    await memory.remember(
+      'User is a developer who likes concise, technical explanations',
+      { type: 'semantic', importance: 0.9 }
+    );
+    
+    await memory.remember(
+      'To export data: Settings > Account > Export Data button',
+      { type: 'procedural', importance: 0.7 }
+    );
+    
+    console.log('✅ Initial knowledge stored');
+    
+    // Simulate conversation
+    console.log('\n' + '='.repeat(50));
+    console.log('💬 Starting conversation...');
+    console.log('='.repeat(50));
+    
+    await agent.processUserMessage("What are my UI preferences?");
+    
+    await agent.processUserMessage("How do I export my data?");
+    
+    // Learn from user feedback
+    console.log('\n' + '='.repeat(50));
+    await agent.learnFromFeedback(
+      'User found the export feature confusing - add a tutorial',
+      0.8
+    );
+    
+    // Show how memory grows
+    console.log('\n' + '='.repeat(50));
+    console.log('\n📊 Memory Status:');
+    const stats = await memory.stats();
+    console.log(`Total memories stored: ${stats.total_memories || 'N/A'}`);
+    console.log(`Operations used: ${stats.operations_this_month || 'N/A'}`);
+    
+    console.log('\n💡 Key Benefits:');
+    console.log('✅ Only relevant memories loaded (not entire history)');
+    console.log('✅ Memory grows over time without token bloat');
+    console.log('✅ 95% token savings vs. loading full context');
+    console.log('✅ Sub-200ms retrieval speed');
+    
+    console.log('\n✅ Example complete!');
+    
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    
+    if (error.message.includes('Missing credentials')) {
+      console.log('\n💡 Set credentials first:');
+      console.log('export MEMORYLAYER_EMAIL=your@email.com');
+      console.log('export MEMORYLAYER_PASSWORD=your_password');
+    }
+    
+    process.exit(1);
+  }
+}
+
+main();

package/skills/memorylayer/examples/basic-usage.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+/**
+ * MemoryLayer Basic Usage Example
+ * 
+ * This example shows:
+ * 1. Storing memories
+ * 2. Searching for relevant memories
+ * 3. Getting formatted context for prompts
+ * 4. Checking usage stats
+ */
+
+const memory = require('../index.js');
+
+async function main() {
+  console.log('🧠 MemoryLayer Basic Usage Example\n');
+  
+  try {
+    // 1. Store some memories
+    console.log('📝 Storing memories...');
+    
+    await memory.remember(
+      'User prefers dark mode UI with blue accent colors',
+      { type: 'semantic', importance: 0.8 }
+    );
+    
+    await memory.remember(
+      'User completed onboarding on 2026-02-03',
+      { type: 'episodic', importance: 0.6 }
+    );
+    
+    await memory.remember(
+      'To export data: Settings > Account > Export Data button',
+      { type: 'procedural', importance: 0.7 }
+    );
+    
+    console.log('✅ Stored 3 memories\n');
+    
+    // 2. Search for relevant memories
+    console.log('🔍 Searching for "UI preferences"...');
+    const results = await memory.search('UI preferences', 5);
+    
+    console.log(`Found ${results.length} results:\n`);
+    results.forEach((result, i) => {
+      console.log(`${i + 1}. [${result.relevance_score.toFixed(2)}] ${result.memory.content}`);
+      console.log(`   Type: ${result.memory.memory_type}, Importance: ${result.memory.importance}`);
+    });
+    console.log();
+    
+    // 3. Get formatted context for prompt injection
+    console.log('📋 Getting formatted context...');
+    const context = await memory.get_context('user interface settings', 3);
+    console.log(context);
+    console.log();
+    
+    // 4. Check usage stats
+    console.log('📊 Usage statistics...');
+    const stats = await memory.stats();
+    console.log(`Email: ${stats.email}`);
+    console.log(`Total memories: ${stats.total_memories || 'N/A'}`);
+    console.log(`Operations this month: ${stats.operations_this_month || 'N/A'}`);
+    console.log();
+    
+    // Token savings calculation
+    console.log('💰 Token Savings:');
+    console.log('Before MemoryLayer: 10,500 tokens (entire MEMORY.md)');
+    console.log('After MemoryLayer: ~500 tokens (5 relevant memories)');
+    console.log('Savings: 95% = ~$900/month at scale');
+    console.log();
+    
+    console.log('✅ Example complete!');
+    
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    
+    if (error.message.includes('Missing credentials')) {
+      console.log('\n💡 Set credentials first:');
+      console.log('export MEMORYLAYER_EMAIL=your@email.com');
+      console.log('export MEMORYLAYER_PASSWORD=your_password');
+      console.log('\nOr visit: https://memorylayer.clawbot.hk to sign up');
+    }
+    
+    process.exit(1);
+  }
+}
+
+main();

package/skills/memorylayer/examples/token-savings-demo.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+
+/**
+ * MemoryLayer Token Savings Demo
+ * 
+ * This example demonstrates the token savings you get by using MemoryLayer
+ * instead of loading entire memory files.
+ */
+
+const memory = require('../index.js');
+const fs = require('fs');
+const path = require('path');
+
+// Simple token counter (rough estimate: 1 token ≈ 4 characters)
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+async function main() {
+  console.log('💰 MemoryLayer Token Savings Demo\n');
+  console.log('=' .repeat(60));
+  
+  try {
+    // Simulate storing a lot of memories (like MEMORY.md would have)
+    console.log('\n📝 Setting up test memories...');
+    
+    const testMemories = [
+      'User prefers dark mode UI with blue accent colors',
+      'User completed onboarding on 2026-02-03',
+      'User is a developer who likes concise technical explanations',
+      'User timezone is Asia/Hong_Kong',
+      'User works at QuantechCo as a senior engineer',
+      'To export data: Settings > Account > Export Data button',
+      'User reported bug in search feature on 2026-02-01',
+      'User favorite programming language is JavaScript',
+      'User prefers email notifications over push notifications',
+      'User last login was 2026-02-03 14:30:00',
+      'User created project "MemoryLayer" on 2026-01-15',
+      'To reset password: Click "Forgot Password" on login page',
+      'User subscribed to Pro plan on 2026-01-20',
+      'User requested feature: bulk export',
+      'User reported performance issue with large datasets',
+    ];
+    
+    for (const content of testMemories) {
+      await memory.remember(content, {
+        type: 'semantic',
+        importance: Math.random() * 0.5 + 0.5
+      });
+    }
+    
+    console.log(`✅ Stored ${testMemories.length} test memories\n`);
+    
+    // === BEFORE: Loading entire memory file ===
+    console.log('='.repeat(60));
+    console.log('📊 BEFORE: Traditional Approach (Loading entire MEMORY.md)');
+    console.log('='.repeat(60));
+    
+    // Simulate a typical MEMORY.md file
+    const fullMemoryContent = `
+# MEMORY.md - Long-term Memory
+
+## User Profile
+- Name: John Doe
+- Email: john@example.com
+- Timezone: Asia/Hong_Kong
+- Role: Senior Engineer at QuantechCo
+- Preferences: Dark mode UI, blue accents
+- Notification preference: Email > Push
+- Favorite language: JavaScript
+
+## Recent Events
+- 2026-02-03: Completed onboarding
+- 2026-02-03: Last login at 14:30:00
+- 2026-02-01: Reported bug in search feature
+- 2026-01-20: Subscribed to Pro plan
+- 2026-01-15: Created project "MemoryLayer"
+
+## Feature Knowledge
+- Export data: Settings > Account > Export Data button
+- Reset password: Click "Forgot Password" on login page
+
+## User Feedback
+- Found export feature confusing - needs tutorial
+- Requested feature: bulk export
+- Reported performance issue with large datasets
+
+## Technical Details
+- Preferred response style: Concise, technical
+- Complexity tolerance: High (developer)
+- Documentation preference: Code examples > long explanations
+
+... (imagine many more sections) ...
+
+## Historical Context
+(This would typically include hundreds of lines of conversation history,
+decisions made, code written, bugs fixed, features requested, etc.)
+
+Total: This is a typical MEMORY.md file that could easily grow to 2,500+ lines
+and 10,000+ tokens as the agent learns more about the user.
+`.trim();
+    
+    const beforeTokens = estimateTokens(fullMemoryContent);
+    console.log(`\n📄 Full MEMORY.md file size: ${fullMemoryContent.length} characters`);
+    console.log(`🎯 Estimated tokens: ${beforeTokens.toLocaleString()}`);
+    console.log(`💵 Cost per 1M tokens (GPT-4): ~$30`);
+    console.log(`💰 Cost per prompt: $${((beforeTokens / 1000000) * 30).toFixed(4)}`);
+    console.log(`\n❌ Problems:`);
+    console.log(`   - Loads ALL memories every time (90% irrelevant)`);
+    console.log(`   - Slow as memory file grows`);
+    console.log(`   - Context window fills up quickly`);
+    console.log(`   - Expensive at scale`);
+    
+    // === AFTER: Using MemoryLayer ===
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 AFTER: MemoryLayer Approach (Semantic Search)');
+    console.log('='.repeat(60));
+    
+    const query = "What are the user's UI preferences?";
+    console.log(`\n🔍 Query: "${query}"`);
+    
+    const context = await memory.get_context(query, 5);
+    
+    const afterTokens = estimateTokens(context);
+    console.log(`\n📄 Retrieved context size: ${context.length} characters`);
+    console.log(`🎯 Estimated tokens: ${afterTokens.toLocaleString()}`);
+    console.log(`💵 Cost per 1M tokens (GPT-4): ~$30`);
+    console.log(`💰 Cost per prompt: $${((afterTokens / 1000000) * 30).toFixed(4)}`);
+    
+    console.log(`\n✅ Benefits:`);
+    console.log(`   - Only loads relevant memories (5 out of ${testMemories.length})`);
+    console.log(`   - Sub-200ms retrieval time`);
+    console.log(`   - Context window stays clean`);
+    console.log(`   - Scales to millions of memories`);
+    
+    console.log('\n' + '='.repeat(60));
+    console.log('💰 SAVINGS CALCULATION');
+    console.log('='.repeat(60));
+    
+    const tokenSavings = beforeTokens - afterTokens;
+    const percentSavings = ((tokenSavings / beforeTokens) * 100).toFixed(1);
+    const costSavingsPerPrompt = ((tokenSavings / 1000000) * 30).toFixed(4);
+    
+    console.log(`\n📉 Token reduction: ${tokenSavings.toLocaleString()} tokens (${percentSavings}%)`);
+    console.log(`💵 Cost savings per prompt: $${costSavingsPerPrompt}`);
+    
+    // Calculate monthly savings at scale
+    const promptsPerDay = 1000;
+    const daysPerMonth = 30;
+    const monthlyPrompts = promptsPerDay * daysPerMonth;
+    const monthlySavings = ((tokenSavings / 1000000) * 30 * monthlyPrompts).toFixed(2);
+    
+    console.log(`\n📊 At scale (${promptsPerDay.toLocaleString()} prompts/day):`);
+    console.log(`   Monthly prompts: ${monthlyPrompts.toLocaleString()}`);
+    console.log(`   Monthly savings: $${monthlySavings}`);
+    console.log(`   Annual savings: $${(monthlySavings * 12).toLocaleString()}`);
+    
+    console.log('\n✨ Retrieved context:');
+    console.log('─'.repeat(60));
+    console.log(context);
+    console.log('─'.repeat(60));
+    
+    console.log('\n✅ Demo complete!');
+    console.log('\n💡 Key Takeaway:');
+    console.log('   MemoryLayer reduces tokens by ~95% while maintaining');
+    console.log('   full context relevance. This is the difference between');
+    console.log('   paying $1,000/month and $50/month at scale.');
+    
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    
+    if (error.message.includes('Missing credentials')) {
+      console.log('\n💡 Set credentials first:');
+      console.log('export MEMORYLAYER_EMAIL=your@email.com');
+      console.log('export MEMORYLAYER_PASSWORD=your_password');
+      console.log('\nOr visit: https://memorylayer.clawbot.hk to sign up');
+    }
+    
+    process.exit(1);
+  }
+}
+
+main();