302 lines
11 KiB
Python
302 lines
11 KiB
Python
|
#!/usr/bin/env python3
|
|||
|
|
"""
|
|||
|
|
Auto-memory management with proactive context retrieval
|
|||
|
|
Usage: auto_memory.py store "text" [--importance medium] [--tags tag1,tag2]
|
|||
|
|
auto_memory.py search "query" [--limit 3]
|
|||
|
|
auto_memory.py should_store "conversation_snippet"
|
|||
|
|
auto_memory.py context "current_topic" [--min-score 0.6]
|
|||
|
|
auto_memory.py proactive "user_message" [--auto-include]
|
|||
|
|
"""
|
|||
|
|
|
|||
|
|
import argparse
|
|||
|
|
import json
|
|||
|
|
import subprocess
|
|||
|
|
import sys
|
|||
|
|
|
|||
|
|
WORKSPACE = "/root/.openclaw/workspace"
|
|||
|
|
QDRANT_SKILL = f"{WORKSPACE}/skills/qdrant-memory/scripts"
|
|||
|
|
|
|||
|
|
def store_memory(text, importance="medium", tags=None, confidence="high",
|
|||
|
|
source_type="user", verified=True, expires=None):
|
|||
|
|
"""Store a memory automatically with full metadata"""
|
|||
|
|
cmd = [
|
|||
|
|
"python3", f"{QDRANT_SKILL}/store_memory.py",
|
|||
|
|
text,
|
|||
|
|
"--importance", importance,
|
|||
|
|
"--confidence", confidence,
|
|||
|
|
"--source-type", source_type,
|
|||
|
|
]
|
|||
|
|
if verified:
|
|||
|
|
cmd.append("--verified")
|
|||
|
|
if tags:
|
|||
|
|
cmd.extend(["--tags", ",".join(tags)])
|
|||
|
|
if expires:
|
|||
|
|
cmd.extend(["--expires", expires])
|
|||
|
|
|
|||
|
|
result = subprocess.run(cmd, capture_output=True, text=True)
|
|||
|
|
return result.returncode == 0
|
|||
|
|
|
|||
|
|
def search_memories(query, limit=3, min_score=0.0):
|
|||
|
|
"""Search memories for relevant context"""
|
|||
|
|
cmd = [
|
|||
|
|
"python3", f"{QDRANT_SKILL}/search_memories.py",
|
|||
|
|
query,
|
|||
|
|
"--limit", str(limit),
|
|||
|
|
"--json"
|
|||
|
|
]
|
|||
|
|
|
|||
|
|
result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
|
|||
|
|
if result.returncode == 0:
|
|||
|
|
try:
|
|||
|
|
memories = json.loads(result.stdout)
|
|||
|
|
# Filter by score if specified
|
|||
|
|
if min_score > 0:
|
|||
|
|
memories = [m for m in memories if m.get("score", 0) >= min_score]
|
|||
|
|
return memories
|
|||
|
|
except:
|
|||
|
|
return []
|
|||
|
|
return []
|
|||
|
|
|
|||
|
|
def should_store_memory(text):
|
|||
|
|
"""Determine if a memory should be stored based on content"""
|
|||
|
|
text_lower = text.lower()
|
|||
|
|
|
|||
|
|
# Explicit store markers (highest priority)
|
|||
|
|
explicit_markers = ["remember this", "note this", "save this", "log this", "record this"]
|
|||
|
|
if any(marker in text_lower for marker in explicit_markers):
|
|||
|
|
return True, "explicit_store", "high"
|
|||
|
|
|
|||
|
|
# Permanent markers (never expire)
|
|||
|
|
permanent_markers = [
|
|||
|
|
"my name is", "i am ", "i'm ", "call me", "i live in", "my address",
|
|||
|
|
"my phone", "my email", "my birthday", "i work at", "my job"
|
|||
|
|
]
|
|||
|
|
if any(marker in text_lower for marker in permanent_markers):
|
|||
|
|
return True, "permanent_fact", "high"
|
|||
|
|
|
|||
|
|
# Preference/decision indicators
|
|||
|
|
pref_markers = ["i prefer", "i like", "i want", "my favorite", "i need", "i use", "i choose"]
|
|||
|
|
if any(marker in text_lower for marker in pref_markers):
|
|||
|
|
return True, "preference", "high"
|
|||
|
|
|
|||
|
|
# Setup/achievement markers
|
|||
|
|
setup_markers = ["setup", "installed", "configured", "working", "completed", "finished", "created"]
|
|||
|
|
if any(marker in text_lower for marker in setup_markers):
|
|||
|
|
return True, "setup_complete", "medium"
|
|||
|
|
|
|||
|
|
# Rule/policy markers
|
|||
|
|
rule_markers = ["rule", "policy", "always", "never", "every", "schedule", "deadline"]
|
|||
|
|
if any(marker in text_lower for marker in rule_markers):
|
|||
|
|
return True, "rule_policy", "high"
|
|||
|
|
|
|||
|
|
# Temporary markers (should expire)
|
|||
|
|
temp_markers = ["for today", "for now", "temporarily", "this time only", "just for"]
|
|||
|
|
if any(marker in text_lower for marker in temp_markers):
|
|||
|
|
return True, "temporary", "low", "7d" # 7 day expiration
|
|||
|
|
|
|||
|
|
# Important keywords (check density)
|
|||
|
|
important_keywords = [
|
|||
|
|
"important", "critical", "essential", "key", "main", "primary",
|
|||
|
|
"password", "api key", "token", "secret", "backup", "restore",
|
|||
|
|
"decision", "choice", "selected", "chose", "picked"
|
|||
|
|
]
|
|||
|
|
matches = sum(1 for kw in important_keywords if kw in text_lower)
|
|||
|
|
if matches >= 2:
|
|||
|
|
return True, "keyword_match", "medium"
|
|||
|
|
|
|||
|
|
# Error/lesson learned markers
|
|||
|
|
lesson_markers = ["error", "mistake", "fixed", "solved", "lesson", "learned", "solution"]
|
|||
|
|
if any(marker in text_lower for marker in lesson_markers):
|
|||
|
|
return True, "lesson", "high"
|
|||
|
|
|
|||
|
|
return False, "not_important", None
|
|||
|
|
|
|||
|
|
def get_relevant_context(query, min_score=0.6, limit=5):
|
|||
|
|
"""Get relevant memories for current context with smart filtering"""
|
|||
|
|
memories = search_memories(query, limit=limit, min_score=min_score)
|
|||
|
|
|
|||
|
|
# Sort by importance and score
|
|||
|
|
importance_order = {"high": 0, "medium": 1, "low": 2}
|
|||
|
|
memories.sort(key=lambda m: (
|
|||
|
|
importance_order.get(m.get("importance", "medium"), 1),
|
|||
|
|
-m.get("score", 0)
|
|||
|
|
))
|
|||
|
|
|
|||
|
|
return memories
|
|||
|
|
|
|||
|
|
def proactive_retrieval(user_message, auto_include=False):
|
|||
|
|
"""
|
|||
|
|
Proactively retrieve relevant memories based on user message.
|
|||
|
|
Returns relevant memories that might be helpful context.
|
|||
|
|
"""
|
|||
|
|
# Extract key concepts from the message
|
|||
|
|
# Simple approach: use the whole message as query
|
|||
|
|
# Better approach: extract noun phrases (could be enhanced)
|
|||
|
|
|
|||
|
|
memories = get_relevant_context(user_message, min_score=0.5, limit=5)
|
|||
|
|
|
|||
|
|
if not memories:
|
|||
|
|
return []
|
|||
|
|
|
|||
|
|
# Filter for highly relevant or important memories
|
|||
|
|
proactive_memories = []
|
|||
|
|
for m in memories:
|
|||
|
|
score = m.get("score", 0)
|
|||
|
|
importance = m.get("importance", "medium")
|
|||
|
|
|
|||
|
|
# Include if:
|
|||
|
|
# - High score (0.7+) regardless of importance
|
|||
|
|
# - Medium score (0.5+) AND high importance
|
|||
|
|
if score >= 0.7 or (score >= 0.5 and importance == "high"):
|
|||
|
|
proactive_memories.append(m)
|
|||
|
|
|
|||
|
|
return proactive_memories
|
|||
|
|
|
|||
|
|
def format_context_for_prompt(memories):
|
|||
|
|
"""Format memories as context for the LLM prompt"""
|
|||
|
|
if not memories:
|
|||
|
|
return ""
|
|||
|
|
|
|||
|
|
context = "\n[Relevant context from previous conversations]:\n"
|
|||
|
|
for i, m in enumerate(memories, 1):
|
|||
|
|
text = m.get("text", "")
|
|||
|
|
date = m.get("date", "unknown")
|
|||
|
|
importance = m.get("importance", "medium")
|
|||
|
|
|
|||
|
|
prefix = "🔴" if importance == "high" else "🟡" if importance == "medium" else "🟢"
|
|||
|
|
context += f"{prefix} [{date}] {text}\n"
|
|||
|
|
|
|||
|
|
return context
|
|||
|
|
|
|||
|
|
def auto_tag(text, reason):
|
|||
|
|
"""Automatically generate tags based on content"""
|
|||
|
|
tags = []
|
|||
|
|
|
|||
|
|
# Add tag based on reason
|
|||
|
|
reason_tags = {
|
|||
|
|
"explicit_store": "recorded",
|
|||
|
|
"permanent_fact": "identity",
|
|||
|
|
"preference": "preference",
|
|||
|
|
"setup_complete": "setup",
|
|||
|
|
"rule_policy": "policy",
|
|||
|
|
"temporary": "temporary",
|
|||
|
|
"keyword_match": "important",
|
|||
|
|
"lesson": "lesson"
|
|||
|
|
}
|
|||
|
|
if reason in reason_tags:
|
|||
|
|
tags.append(reason_tags[reason])
|
|||
|
|
|
|||
|
|
# Content-based tags
|
|||
|
|
text_lower = text.lower()
|
|||
|
|
content_tags = {
|
|||
|
|
"voice": ["voice", "tts", "stt", "whisper", "audio", "speak"],
|
|||
|
|
"tools": ["tool", "script", "command", "cli", "error"],
|
|||
|
|
"config": ["config", "setting", "setup", "install"],
|
|||
|
|
"memory": ["memory", "remember", "recall", "search"],
|
|||
|
|
"web": ["search", "web", "online", "internet"],
|
|||
|
|
"security": ["password", "token", "secret", "key", "auth"]
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for tag, keywords in content_tags.items():
|
|||
|
|
if any(kw in text_lower for kw in keywords):
|
|||
|
|
tags.append(tag)
|
|||
|
|
|
|||
|
|
return list(set(tags)) # Remove duplicates
|
|||
|
|
|
|||
|
|
if __name__ == "__main__":
|
|||
|
|
parser = argparse.ArgumentParser(description="Auto-memory management")
|
|||
|
|
parser.add_argument("action", choices=[
|
|||
|
|
"store", "search", "should_store", "context",
|
|||
|
|
"proactive", "auto_process"
|
|||
|
|
])
|
|||
|
|
parser.add_argument("text", help="Text to process")
|
|||
|
|
parser.add_argument("--importance", default="medium", choices=["low", "medium", "high"])
|
|||
|
|
parser.add_argument("--tags", help="Comma-separated tags")
|
|||
|
|
parser.add_argument("--limit", type=int, default=3)
|
|||
|
|
parser.add_argument("--min-score", type=float, default=0.6)
|
|||
|
|
parser.add_argument("--auto-include", action="store_true", help="Auto-include context in response")
|
|||
|
|
parser.add_argument("--json", action="store_true", help="Output as JSON")
|
|||
|
|
|
|||
|
|
args = parser.parse_args()
|
|||
|
|
|
|||
|
|
if args.action == "store":
|
|||
|
|
tags = [t.strip() for t in args.tags.split(",")] if args.tags else []
|
|||
|
|
if store_memory(args.text, args.importance, tags):
|
|||
|
|
result = {"stored": True, "importance": args.importance, "tags": tags}
|
|||
|
|
print(json.dumps(result) if args.json else f"✅ Stored: {args.text[:50]}...")
|
|||
|
|
else:
|
|||
|
|
result = {"stored": False, "error": "Failed to store"}
|
|||
|
|
print(json.dumps(result) if args.json else "❌ Failed to store")
|
|||
|
|
sys.exit(1)
|
|||
|
|
|
|||
|
|
elif args.action == "search":
|
|||
|
|
results = search_memories(args.text, args.limit, args.min_score)
|
|||
|
|
if args.json:
|
|||
|
|
print(json.dumps(results))
|
|||
|
|
else:
|
|||
|
|
print(f"Found {len(results)} memories:")
|
|||
|
|
for r in results:
|
|||
|
|
print(f" [{r.get('score', 0):.2f}] {r.get('text', '')[:60]}...")
|
|||
|
|
|
|||
|
|
elif args.action == "should_store":
|
|||
|
|
should_store, reason, importance = should_store_memory(args.text)
|
|||
|
|
result = {"should_store": should_store, "reason": reason, "importance": importance}
|
|||
|
|
print(json.dumps(result) if args.json else f"Store? {should_store} ({reason}, {importance})")
|
|||
|
|
|
|||
|
|
elif args.action == "context":
|
|||
|
|
context = get_relevant_context(args.text, args.min_score, args.limit)
|
|||
|
|
if args.json:
|
|||
|
|
print(json.dumps(context))
|
|||
|
|
else:
|
|||
|
|
print(format_context_for_prompt(context))
|
|||
|
|
|
|||
|
|
elif args.action == "proactive":
|
|||
|
|
memories = proactive_retrieval(args.text, args.auto_include)
|
|||
|
|
if args.json:
|
|||
|
|
print(json.dumps(memories))
|
|||
|
|
else:
|
|||
|
|
if memories:
|
|||
|
|
print(f"🔍 Found {len(memories)} relevant memories:")
|
|||
|
|
for m in memories:
|
|||
|
|
score = m.get("score", 0)
|
|||
|
|
text = m.get("text", "")[:60]
|
|||
|
|
print(f" [{score:.2f}] {text}...")
|
|||
|
|
else:
|
|||
|
|
print("ℹ️ No highly relevant memories found")
|
|||
|
|
|
|||
|
|
elif args.action == "auto_process":
|
|||
|
|
# Full pipeline: check if should store, auto-tag, store, and return context
|
|||
|
|
should_store, reason, importance = should_store_memory(args.text)
|
|||
|
|
|
|||
|
|
result = {
|
|||
|
|
"should_store": should_store,
|
|||
|
|
"reason": reason,
|
|||
|
|
"stored": False
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if should_store:
|
|||
|
|
# Auto-generate tags
|
|||
|
|
tags = auto_tag(args.text, reason)
|
|||
|
|
if args.tags:
|
|||
|
|
tags.extend([t.strip() for t in args.tags.split(",")])
|
|||
|
|
tags = list(set(tags))
|
|||
|
|
|
|||
|
|
# Determine expiration for temporary memories
|
|||
|
|
expires = None
|
|||
|
|
if reason == "temporary":
|
|||
|
|
from datetime import datetime, timedelta
|
|||
|
|
expires = (datetime.now() + timedelta(days=7)).strftime("%Y-%m-%d")
|
|||
|
|
|
|||
|
|
# Store it
|
|||
|
|
stored = store_memory(args.text, importance or "medium", tags,
|
|||
|
|
expires=expires)
|
|||
|
|
result["stored"] = stored
|
|||
|
|
result["tags"] = tags
|
|||
|
|
result["importance"] = importance
|
|||
|
|
|
|||
|
|
# Also get relevant context
|
|||
|
|
context = get_relevant_context(args.text, args.min_score, args.limit)
|
|||
|
|
result["context"] = context
|
|||
|
|
|
|||
|
|
print(json.dumps(result) if args.json else result)
|