Openclaw Memvid Logger

Unified Conversation Logger v1.2.5

Version: 1.2.5 (Critical Fixes Edition)
Author: stackBlock
License: MIT
OpenClaw: >= 2026.2.12

A dual-output conversation logger for OpenClaw that captures everything - user messages, assistant responses, sub-agent conversations, tool calls, and system events - to both JSONL (backup) and Memvid (semantic search) formats.

Memvid: A single-file memory layer for AI agents with instant retrieval and long-term memory. Persistent, versioned, and portable memory, without databases.

"Replace complex RAG pipelines with a single portable file you own, and give your agent instant retrieval and long-term memory."

⚠️ Security & Privacy Notice

Before installing, please understand:

This skill captures everything - by design. It logs all user messages, assistant responses, sub-agent conversations, tool outputs, and system events to local files. This enables powerful long-term memory but requires trust.

What you should know:

• Broad capture scope: This is intentional - the skill's purpose is complete conversation logging
• Sensitive data risk: Tool outputs (commands, API responses, file contents) are logged. Review what tools expose.
• Continuous logging: Once installed, it runs automatically on every assistant response until removed
• Optional cloud mode: API mode with MEMVID_API_KEY sends data to memvid.com (third-party service). Free/local modes keep data on your machine only.
• Your responsibility: Secure the JSONL/.mv2 files, rotate logs regularly, and audit what gets captured.

Mitigations available:

• Use Free/Sharding mode to keep data local (no API key needed)
• Change default paths to encrypted locations
• Review tools/log.py before installing to understand exactly what gets logged
• File permissions: restrict access to log files (chmod 600)

This skill is for users who want complete conversation memory and accept the privacy trade-offs.

✨ What Makes This Different

• 📝 Dual Storage - Every message saved to JSONL + Memvid simultaneously
• 🔍 Semantic Search - Ask "What did the researcher agent find about Tesla?" not just keyword search
• 🤖 Full Context - Captures user input, assistant output, agent chatter, tool results
• 💾 Three Modes - API (unlimited), Free (50MB), or Sharding (multi-file)
• 🚀 Always On - Hooks into OpenClaw automatically

What's New in v1.2.5

Critical Fixes

• Memvid Tag Format Fixed: Updated to KEY=VALUE format for Memvid 2.0+ compatibility
  • Old (broken): --tag "user,telegram"
  • New (fixed): --tag "role=user" --tag "source=telegram"
• Environment Variable Documentation: Added /etc/environment instructions (.bashrc doesn't work for background services)
• Hook Handler Format: Documented JavaScript (.js) requirement for OpenClaw 2026.2.12+
• Comprehensive Troubleshooting: Added detailed troubleshooting section for common setup issues

Compatibility

• Verified with OpenClaw 2026.2.12
• Verified with Memvid CLI 2.0+

Previous Versions

v1.2.4

• Neural Search Default: Updated search guidance to use --mode neural as default for maximum accuracy
• Performance Documentation: Clarified latency trade-offs (~200ms for neural vs ~8ms for lexical)
• Search Mode Policy: Recommends neural for semantic understanding, lexical only when speed is critical

v1.2.3

• Version Cohesion: All files synchronized to v1.2.3
• Documentation Consistency: README and SKILL.md now have matching content
• Security Improvements: Generic paths (no hardcoded user directories), install script asks permission
• Registry Compliance: Complete metadata (env vars, credentials, warnings) for ClawHub transparency
• Privacy Documentation: Comprehensive Security & Privacy Notice explaining data capture scope
• Role Tagging: Distinguishes user, assistant, agent:*, system, and tool messages
• Full Context: Captures sub-agent chatter, tool results, background processes
• Three Storage Modes: API mode (single file), Free mode (50MB), Sharding mode (monthly rotation)
• Semantic Search: Ask "What did the researcher agent find?" or "What did I say about X?"

Quick Install (Choose Your Mode)

Option 1: API Mode (Recommended) - Near Limitless Memory

Best for: Heavy users, unified search across everything
Cost: $59-299/month via memvid.com

# 1. Get API key from memvid.com ($59/month for 1GB, $299 for 25GB)
export MEMVID_API_KEY="your_api_key_here"
export MEMVID_MODE="single"

# 2. Install
npm install -g memvid
git clone https://github.com/stackBlock/openclaw-memvid-logger.git
cp -r openclaw-memvid-logger ~/.openclaw/workspace/skills/

# 3. Create unified memory file
memvid create ~/memory.mv2

# 4. Start OpenClaw - everything logs to one searchable file

Search everything at once:

memvid ask memory.mv2 "What did we discuss about BadjAI?"
memvid ask memory.mv2 "What did the researcher agent find about Tesla?"
memvid ask memory.mv2 "Show me all the Python scripts I asked for"

Option 2: Free Mode (50MB Limit) - Complete Memory in One Place

Best for: Testing, light usage, single searchable file
Cost: FREE

# 1. Install (no API key needed)
npm install -g memvid
git clone https://github.com/stackBlock/openclaw-memvid-logger.git
cp -r openclaw-memvid-logger ~/.openclaw/workspace/skills/
export MEMVID_MODE="single"

# 2. Create memory file
memvid create ~/memory.mv2

# 3. Start OpenClaw

⚠️ Limit: 50MB (~5,000 conversation turns). When you hit it:

• Archive and start fresh, OR
• Upgrade to API mode ($59-299/month), OR
• Switch to Sharding mode

Option 3: Sharding Mode - More Than 50MB, Free Forever

Best for: Long-term use, staying under free tier
Cost: FREE
Trade-off: Multi-file search

# 1. Install (no API key needed)
npm install -g memvid
git clone https://github.com/stackBlock/openclaw-memvid-logger.git
cp -r openclaw-memvid-logger ~/.openclaw/workspace/skills/
export MEMVID_MODE="monthly"  # This is the default

# 2. Start OpenClaw - auto-creates monthly files

How it works:

• memory_2026-02.mv2 (February)
• memory_2026-03.mv2 (March - auto-created)
• Each file stays under 50MB

⚠️ Sharding Search Differences:

Single-file search (API/Free modes):

# One search gets everything
memvid ask memory.mv2 "What car did I decide to buy?"
# Returns: Results from ALL conversations across ALL time

Sharding search (requires multiple queries):

# Must search each month separately
memvid ask memory_2026-02.mv2 "car decision"  # Recent
memvid ask memory_2026-01.mv2 "car decision"  # January

# Or use a wrapper script to search all files
for file in memory_*.mv2; do
    echo "=== $file ==="
    memvid ask "$file" "car decision" 2>/dev/null | head -5
done

# You must know which month the conversation happened
# No cross-month context - "compare this month to last month" won't work

Why sharding is harder:

• Can't ask "what did we discuss in the past 3 months?" in one query
• No unified timeline across months
• Must remember which month you talked about what
• No cross-file semantic comparison

What Gets Logged

Role Tags (Automatic)

Everything Captured

• ✅ User messages (what you type)
• ✅ Assistant responses (what I say back)
• ✅ Sub-agent conversations (researcher, coder, vision, math, etc.)
• ✅ Tool executions (bash commands, browser actions, file edits)
• ✅ Background processes (cron jobs, heartbeats, scheduled tasks)
• ✅ System events (config changes, restarts, errors)

Architecture

┌─────────────────────────────────────────┐
│           OpenClaw Ecosystem            │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐ │
│  │  User   │  │Assistant│  │  Agents │ │
│  │ Messages│  │Responses│  │Research │ │
│  └────┬────┘  └────┬────┘  └────┬────┘ │
│       └─────────────┴─────────────┘     │
│                     │                   │
│              ┌──────▼──────┐            │
│              │  log.py     │            │
│              │  (this skill)│           │
│              └──────┬──────┘            │
└─────────────────────┼───────────────────┘
                      │
    ┌─────────────────┼─────────────────┐
    ↓                 ↓                 ↓
┌───────┐      ┌─────────────┐    ┌──────────┐
│ JSONL │      │   Memvid    │    │  Search  │
│ File  │      │   Files     │    │  Query   │
└───────┘      └─────────────┘    └──────────┘
    │                 │
    ↓                 ↓
 grep/jq       memvid ask/find

Usage Examples

Natural Language Search

# What did you say about...?
memvid ask memory_2026-02.mv2 "What was your recommendation about the Mercedes vs Tesla?"

# What did I ask for...?
memvid ask memory_2026-02.mv2 "What Python scripts did I request last week?"

# What did agents do...?
memvid ask memory_2026-02.mv2 "What did the researcher agent find about options trading?"

# System events...?
memvid ask memory_2026-02.mv2 "When did the PowerSchool grades cron job run?"

Keyword Search

# Find specific terms
memvid find memory_2026-02.mv2 --query "Mercedes"

# With filters
memvid find memory_2026-02.mv2 --query "script" --tag agent:coder

Temporal Queries

memvid when memory_2026-02.mv2 "yesterday"
memvid when memory_2026-02.mv2 "last Tuesday"
memvid when memory_2026-02.mv2 "3 days ago"

⚡ Search Performance Guide

Memvid has three search modes. This skill uses --mode neural by default for maximum accuracy:

Default: Neural Search (Recommended)

# Always use neural for semantic understanding and context
memvid ask memory.mv2 "What supplements did Dr. Sinclair recommend?" --mode neural
memvid ask memory.mv2 "What did we discuss about BadjAI?" --mode neural
memvid ask memory.mv2 "Show me the Python scripts I requested" --mode neural

Speed: ~200ms | Best for: Semantic understanding, context, synonyms, conceptual relationships

Alternative Modes (Use When Explicitly Requested)

Mode 1: Lexical Search (Fastest)

# Use only for exact keyword matching when speed is critical
memvid find memory.mv2 --mode lex --query "metformin"

Speed: ~8ms | Use when: Exact word matching needed, latency is critical

Mode 2: Hybrid Search (Balanced)

# Combines lexical + neural
memvid find memory.mv2 --mode hybrid --query "diabetes medications"

Speed: ~300-500ms | Use when: You want both exact matches and semantic similarity

Why Neural as Default?

The ~200ms trade-off is worth it: Neural mode understands context, handles paraphrases, and finds conceptually related information that lexical search misses entirely.

JSONL Backup

# Quick grep
grep "Mercedes" conversation_log.jsonl

# Complex queries with jq
jq 'select(.role_tag == "user" and .content | contains("Python"))' conversation_log.jsonl

# Time range
jq 'select(.timestamp >= "2026-02-01" and .timestamp < "2026-03-01")' conversation_log.jsonl

Configuration

Environment Variables

OpenClaw Hooks (Advanced)

Add to openclaw.json:

{
  "hooks": {
    "internal": {
      "enabled": true,
      "entries": {
        "conversation-logger": {
          "enabled": true,
          "command": "python3 ~/.openclaw/workspace/skills/unified-logger/tools/log.py"
        }
      }
    }
  }
}

Memory File Formats

Mode 1: Single File (API or Free Mode)

memory.mv2
├── [user] messages
├── [assistant] responses  
├── [agent:researcher] findings
├── [agent:coder] code
├── [tool:exec] commands
└── [system] events

Mode 2: Sharding (Monthly Rotation)

memory_2026-01.mv2  (January conversations)
memory_2026-02.mv2  (February conversations) ← Current
memory_2026-03.mv2  (March, auto-created on March 1)

Troubleshooting

"Free tier limit exceeded" (Free Mode)

# Option 1: Archive and start fresh
mv memory.mv2 memory_archive.mv2
memvid create memory.mv2

# Option 2: Switch to monthly sharding
export MEMVID_MODE="monthly"

# Option 3: Get API key
export MEMVID_API_KEY="your_key"  # $59-299/month at memvid.com

"Cannot find memory file" (Sharding Mode)

Current month's file auto-creates. If missing:

memvid create memory_$(date +%Y-%m).mv2

Missing agent conversations

Agents log to their own sessions. Ensure skill is installed in main agent workspace and sub-agents inherit it.

Search returns wrong speaker

Memvid uses semantic search. Be specific:

• ❌ "Mercedes" → Returns all mentions
• ✅ "What did I say about Mercedes" → Targets [user] frames
• ✅ "Your recommendation about Mercedes" → Targets [assistant] frames

Comparing the Three Modes

💸 The Pricing Gap (AKA Why Sharding Exists)

The situation: Memvid's pricing goes from $0 (50MB) straight to $59/month (25GB).
The problem: That's like buying a Ferrari when you just need a Honda Civic for your commute.

What we're doing about it:
I reached out. While they consider it, Sharding Mode exists so you don't have to pay Ferrari prices for Honda Civic usage.

You can help:
If you also think $0 → $59 is a bit much, reach out to Memvid at memvid.com and tell them stackBlock sent you. The more voices, the faster we get that $10-20 middle tier for the rest of us.

Until then: Sharding Mode. Because startups shouldn't have to choose between ramen and memory. 🍜

Future Enhancements

• Auto-archive old months to cold storage
• Web UI for browsing conversations
• Cross-file search wrapper script
• Export to other formats (Markdown, PDF)
• Conversation threading visualization

Support

• GitHub Issues: github.com/stackBlock/openclaw-memvid-logger
• OpenClaw Discord: discord.com/invite/clawd
• Memvid Support: memvid.com/docs

License

MIT - See LICENSE

About Memvid:

Memvid is a single-file memory layer for AI agents with instant retrieval and long-term memory. Persistent, versioned, and portable memory, without databases.

Replace complex RAG pipelines with a single portable file you own, and give your agent instant retrieval and long-term memory.