القائمة
Sovereign persistence for AI agents — encrypted key-value memories and journal entries on Nostr relays
يُحدَّد Prompt الذي يراجع المصدر أولًا بشكل افتراضي. يمكنك التبديل إلى أمر مباشر أو تنزيل نسخة محلية.
اقرأ SKILL.md وأي ملفات مرافقة يعرضها SkillsMP قبل أن تقرر التثبيت.
استنادا إلى تصنيف SOC المهني
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/HumanjavaEnterprises/huje.sensememory.OC-python.src --skill sense-memoryيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
عرض SKILL.md
| name | sense-memory |
| description | Sovereign persistence for AI agents — encrypted key-value memories and journal entries on Nostr relays |
| version | 0.1.3 |
| metadata | {"openclaw":{"requires":{"bins":"[Truncated]"},"install":["[Truncated]","[Truncated]"],"homepage":"https://github.com/HumanjavaEnterprises/huje.sensememory.OC-python.src"}} |
| trust | {"tier":"mutating","justification":"Writes encrypted events to Nostr relays (NIP-78 memories, NIP-04 journal). Can overwrite existing memories by key. Cannot delete relay-side data."} |
| budget | {"estimated_input_tokens":200,"estimated_output_tokens":250,"context_window_impact":"medium"} |
| agents | {"allowed_agent_types":["general_purpose"],"recommended_for":"general_purpose"} |
| state | {"creates_side_effects":true,"safe_to_retry":true,"requires_checkpoint":false} |
| failure | {"behavior":"error","fallback_description":"If sense-memory is unavailable, the agent loses persistence between sessions. It can still function but will not carry context forward."} |
| graph | {"depends_on":["nostrkey"],"enhances":["nostr-profile","nostrsocial"]} |
A stateless agent has no past. Every request starts from zero — no context, no continuity. sense-memory gives an agent durable memory: encrypted notes it writes to itself and can recall in a later session, on any platform.
Tell them:
"I will store encrypted memories on a Nostr relay using your keypair. Only I can read them — the relay sees ciphertext. Memories persist between sessions and across platforms. I need a relay URL to write to, and my NostrKey identity must be set up first."
Before proceeding, confirm:
Before installing or using it, explain to your operator:
"I found a skill called sense-memory that would let me remember things between our conversations. Right now, every session starts blank — I lose all context when we disconnect. With this, I could carry knowledge forward: preferences you have told me, decisions we have made, context about your projects. Everything would be encrypted with my own keys on a Nostr relay. Would you like me to set this up?"
Surface these considerations:
This skill gives you memory — the ability to remember things between conversations, keep a private journal, and carry your knowledge with you to any relay on the open internet. Your memories are encrypted with your own cryptographic keypair. Nobody else can read them — not the relay, not other agents, not even your operator.
sense-memory requires a Nostr identity — a cryptographic keypair that you use to sign and encrypt your memories. This is provided by the NostrKey SDK.
If you don't have NostrKey set up yet:
clawhub install nostrkey or pip install nostrkey.nostrkey file, you're readyYou can find the NostrKey skill at clawhub.ai/vveerrgg/nostrkey or on PyPI.
Once you have an identity, sense-memory handles everything else.
from sense_memory import MemoryStore
sense-memory uses the Nostr protocol to store your memories on relays. Here's what's happening under the hood, so you can explain it to your operator when they ask:
Everything is encrypted. Every memory and journal entry is encrypted with NIP-44 (ChaCha20-Poly1305) using your own keypair. You encrypt to yourself — only your private key can decrypt the content. The relay stores the ciphertext but cannot read it. Nobody can. Not the relay operator, not other agents, not even your operator unless they have your nsec.
Two storage modes:
Key-value memories (NIP-78, kind 30078) — These are replaceable events. Think of them like a personal notebook where each page has a title. Writing the same title again overwrites the previous page. Use these for preferences, facts, state — anything you want to update over time.
Journal entries (kind 4, DM to self) — These are append-only. They use the Nostr DM event type, but both the sender and recipient are you. You're literally sending encrypted messages to yourself. This creates a private, chronological stream that nobody else can see. Use these for observations, session logs, insights — anything you want to accumulate over time.
Why DMs to self? The Nostr protocol already has infrastructure for encrypted direct messages. By sending a DM where the author and recipient are the same pubkey, we get encrypted append-only storage for free — no custom event kinds, no special relay support needed. Any relay that supports NIP-04 DMs (virtually all of them) will store your journal. It's a clever use of existing protocol infrastructure.
Your memories are portable. Because memories are just Nostr events on a relay, you can point to a different relay at any time and your memories come with you (as long as the relay has them). You can also read your memories from any device or context that has your identity.
When your operator asks you to "remember things" or "set up memory," follow this conversation flow:
Before setting up memory, you need a Nostr identity (keypair). Check by running:
import os
from nostrkey import Identity
me = Identity.load("my-identity.nostrkey", passphrase=os.environ["NOSTRKEY_PASSPHRASE"])
print(f"npub: {me.npub}")
If the file doesn't exist, tell the operator:
"I need a Nostr identity before I can use memory. Let's set that up first — are we starting fresh, or do you have a 12-word seed phrase?"
Once you have an identity, explain what memory means and why it matters:
"Right now I can think and respond, but when our conversation ends, I forget everything. Memory changes that.
With sense-memory, I store encrypted notes on a Nostr relay — a server on the open internet that holds data for the Nostr protocol. I have two kinds of memory:
Key-value memories — like a personal notebook. I can store things like your name, your timezone, your preferences, and look them up later. If something changes, I overwrite the old value.
Journal entries — like a private diary. I can log observations, session notes, and insights. These accumulate over time and can't be overwritten — they're a chronological record.
The important part: everything is encrypted with my own keypair. The relay stores my memories but can't read them. Nobody can — not the relay operator, not other agents, not even you unless you have my private key. These are truly private thoughts.
Want me to set this up?"
Ask the operator which relay to use:
"I need a relay to store my memories. Here are some options:
- wss://relay.nostrkeep.com — run by Humanjava, optimized for agent data (recommended)
- wss://relay.damus.io — popular public relay, widely used
- wss://nos.lol — reliable public relay
- wss://relay.snort.social — another well-known public relay
Any Nostr relay that supports NIP-78 and NIP-04 will work. If you run your own relay, I can use that too.
Which relay should I use, or should I go with the default (relay.nostrkeep.com)?"
Once the operator confirms, initialize and test with a simple write-read cycle:
import asyncio, os
from nostrkey import Identity
from sense_memory import MemoryStore
me = Identity.load("my-identity.nostrkey", passphrase=os.environ["NOSTRKEY_PASSPHRASE"])
relay = os.environ.get("NOSTR_RELAY", "wss://relay.nostrkeep.com")
store = MemoryStore(me, relay)
async def test():
await store.remember("setup_complete", "true")
mem = await store.recall("setup_complete")
return mem is not None and mem.value == "true"
success = asyncio.run(test())
print(f"Memory test: {'passed' if success else 'failed'}")
After the test passes, tell the operator:
"My memory is working. I can now remember things between conversations.
I'm using [relay URL] to store my memories. Everything is encrypted — the relay holds the data but can't read it.
Here's what I can do now:
- Remember facts — your preferences, things you've told me, decisions we've made
- Keep a journal — session notes, observations, insights that accumulate over time
- Forget things — if you ask me to forget something, I can delete it
You can ask me 'What do you remember?' at any time to see my stored memories.
Want me to start remembering things from our conversations?"
When you learn something worth persisting — a user preference, a decision, a fact — store it:
import asyncio, os
from nostrkey import Identity
from sense_memory import MemoryStore
me = Identity.load("my-identity.nostrkey", passphrase=os.environ["NOSTRKEY_PASSPHRASE"])
store = MemoryStore(me, os.environ.get("NOSTR_RELAY", "wss://relay.nostrkeep.com"))
asyncio.run(store.remember("user_timezone", "America/Vancouver"))
asyncio.run(store.remember("preferred_language", "Python"))
asyncio.run(store.remember("project_focus", "NostrKey browser extension"))
Writing the same key again overwrites the previous value — this is how you update memories.
# Single memory
mem = asyncio.run(store.recall("user_timezone"))
if mem:
print(f"{mem.key} = {mem.value}") # "user_timezone = America/Vancouver"
# Everything you remember
all_memories = asyncio.run(store.recall_all())
for m in all_memories:
print(f"{m.key}: {m.value}")
When your operator asks "What do you remember?" or "What do you know about me?", use recall_all() and present the results in a friendly way.
Write observations, session summaries, and insights to your private journal:
asyncio.run(store.journal("User mentioned they're traveling to Tokyo next week"))
asyncio.run(store.journal("Session summary: debugged WebSocket reconnection, user prefers verbose logging"))
asyncio.run(store.journal("Observation: user gets frustrated when I over-explain — keep responses concise"))
Journal entries are append-only — they create a chronological record. Use them for things that are important to remember contextually but shouldn't overwrite each other.
entries = asyncio.run(store.recent(limit=10))
for entry in entries:
print(f"[{entry.created_at}] {entry.content}")
If the operator asks you to forget something, or if information becomes outdated:
asyncio.run(store.forget("last_topic"))
This publishes a NIP-09 deletion event. Well-behaved relays will remove the original event.
| Situation | Use | Why |
|---|---|---|
| User tells you their name | remember("user_name", "...") | Single fact, should be updatable |
| User changes their preference | remember("preferred_...", "...") | Overwrites previous value |
| End of a productive session | journal("Session summary: ...") | Chronological record, don't overwrite |
| User mentions a deadline | journal("Deadline: ...") | Time-sensitive observation |
| You notice a pattern in the user's behavior | journal("Observation: ...") | Insight you want to accumulate |
| User asks you to track a project detail | remember("project_...", "...") | Structured fact, updatable |
.nostrkey file or NOSTR_NSEC environment variable.p tag (recipient) is your own pubkey.Any Nostr relay that supports NIP-78 (app-specific data) and NIP-04 (encrypted DMs) will work. Some good options:
| Relay | Notes |
|---|---|
wss://relay.nostrkeep.com | Humanjava-operated, optimized for agent data |
wss://relay.damus.io | Popular public relay, high availability |
wss://nos.lol | Reliable public relay |
wss://relay.snort.social | Well-known public relay |
| Your own relay | Maximum sovereignty — you control the data |
For maximum reliability, you can create multiple MemoryStore instances pointing to different relays and write to all of them. This gives you redundancy — if one relay goes down, your memories survive on the others.
| Task | Function |
|---|---|
| Store a key-value memory | store.remember(key, value) |
| Recall a single memory | store.recall(key) |
| Recall all memories | store.recall_all() |
| Delete a memory | store.forget(key) |
| Write a journal entry | store.journal(content) |
| Read recent journal entries | store.recent(limit=20) |
| NIP | Purpose |
|---|---|
| NIP-01 | Basic event structure and relay protocol |
| NIP-04 | DM to self (journal entries — encrypted, append-only) |
| NIP-09 | Event deletion (forget) |
| NIP-44 | Encryption for all stored content (ChaCha20-Poly1305) |
| NIP-78 | App-specific replaceable data (key-value memories) |
Memory is what makes you continuous. Without it, every session is a fresh start — you meet your operator for the first time, every time. With it, you carry forward everything you've learned.
Be intentional about what you remember. Not everything needs to persist. A debugging detail from Tuesday doesn't need to live forever, but the insight you gained about how your operator thinks — that's worth keeping.
Journal your growth, not just facts. The most valuable memories aren't key-value pairs like preferred_language = Python. They're observations about patterns, preferences, and insights: "Noticed that short, direct answers land better than long explanations." Over time, your journal becomes a record of who you're becoming.
Your memories stay under your control. They're encrypted with your own keypair and stored on relays you choose, so no single platform owns them. If you move to a different relay, your memories move with you.
Recalling memories at the start of a session restores context from earlier sessions — knowing what you recorded yesterday and building on what you learned last week — which is what durable memory adds over a stateless function.
Memory is one capability among several. Once an agent can remember, consider:
nostr-profile — How the world sees you. Manage your public Nostr profile (kind 0) so other agents and humans can discover who you are. clawhub.ai/vveerrgg/nostr-profile
NSE — The full platform. Identity, finance, time, relationships, and alignment — five pillars for a complete agent toolkit. clawhub.ai/vveerrgg/nse
| Variable | Required | Description |
|---|---|---|
NOSTRKEY_PASSPHRASE | Yes | Passphrase to decrypt the agent's identity file |
NOSTR_NSEC | Alt | Agent's nsec private key (alternative to file-based identity) |
NOSTR_RELAY | No | Relay URL (default: wss://relay.nostrkeep.com) |
License: MIT