Nuggets: Best AI Memory Systems for Solo Developers in 2026

What Is Nuggets?

Nuggets is a TypeScript-based holographic memory system built by NeoVertex1 for persistent AI assistants. It combines holographic reduced representations (HRR) with a multi-channel messaging gateway to enable Claude-powered agents that retain facts across sessions via algebraic vector operations. Nuggets is one of the best AI Memory Systems tools for solo developers and indie hackers, with 259 GitHub stars as of October 2024 and zero external dependencies for core recall.

The system stores key-value pairs as compressed complex vectors in fixed-size holographic memory, supporting operations like superposition, binding, and unbinding in under 1ms on local hardware. Developers deploy it via npm for Telegram or WhatsApp integration, where facts recalled 3+ times auto-promote to permanent Markdown files. This eliminates RAG infrastructure while enabling proactive check-ins and cron-scheduled tasks.

Quick Overview

Who Should Use Nuggets?

• Solo indie hackers prototyping AI agents who need session-persistent memory without Pinecone or Weaviate setup, as Nuggets rebuilds vectors from seeded PRNG in JSON files under 1KB.
• Power users integrating Claude via Pi for Telegram bots that recall user preferences across restarts, with proactive heartbeats every 30 minutes during waking hours.
• TypeScript developers building local-first AI tools, since the engine runs pure JS with deterministic reconstruction and no runtime dependencies beyond Node.js.
• Minimalists avoiding RAG who prioritize sub-millisecond recall over semantic search, fitting workflows with 10-50 facts per nugget topic.

Not ideal for:

• Enterprise teams handling 10k+ documents, where vector DBs like Qdrant outperform HRR superposition density.
• Real-time multi-user apps beyond 5 concurrent sessions, due to per-user Pi subprocess limits and 5-minute idle reaping.
• Python-first stacks lacking Node.js, as the gateway relies on TypeScript JSONL RPC over stdin/stdout.

Key Features of Nuggets

• Holographic Memory Engine — Encodes facts via HRR binding into superposed complex vectors; recall uses cosine similarity cleanup for ~1ms decoding of individual key-value pairs from a single fixed-size object.
• Self-Promotion Mechanism — Tracks recall counts across sessions; facts hitting 3+ recalls write to MEMORY.md for permanent prompt injection, reducing token costs by 20-50% over repeated sessions.
• Multi-Channel Gateway — Routes Telegram and WhatsApp messages to isolated Pi subprocesses per user, serializing via message queue to handle concurrency without races.
• JSONL RPC Protocol — Pi communicates bidirectionally over stdin/stdout with the TypeScript parent; supports structured requests for remember/recall/forget without HTTP overhead.
• Cron Scheduler — Parses 5-field cron strings for reminders and tasks; executes in-process during heartbeats, sending outputs through the same chat channel.
• Process Pool Management — Spawns one Pi per user, reuses for 5 minutes post-idle, with heartbeat pings every 30 minutes to trigger proactive messages.
• Topic-Scoped Nuggets — Organizes memory into per-topic JSON files at ~/.nuggets/, e.g., 'projects.nugget' for scoped superposition without global interference.

Nuggets vs Alternatives

Claude Context Mode suits Claude-only workflows prioritizing prompt engineering over structured storage, but lacks Nuggets' vector superposition for fact isolation. MemGPT excels in hierarchical paging for 100k+ token histories via LLM decisions, picking it over Nuggets for verbose conversation logs. OpenSwarm handles agent fleets better with its gossip-based coordination, while Nuggets focuses on single-assistant persistence.

For broader options, browse all AI Memory Systems tools.

How Nuggets Works

Nuggets architecture splits into a holographic memory engine in src/nuggets/ and a messaging gateway in src/gateway/. The engine uses HRR to map strings to random complex vectors via a seeded PRNG, then binds keys to values through circular convolution. Superposition sums multiple bindings into one vector; recall probes with a key vector, inverse-convolves, and ranks by cosine similarity to decode values. Storage avoids vector serialization—JSON holds only keys, values, and seeds for deterministic rebuilds, keeping files at 500-2KB per nugget.

The gateway spins up Node.js processes routing inbound webhooks from Telegram/WhatsApp to per-user Pi instances running Claude. JSONL lines encode RPC calls like {"action":"recall","nugget":"projects","key":"deadline"}, with Pi responding via stdout for injection into prompts. Concurrency serializes via a user-keyed queue; idles reap after 5 minutes to cap RAM at 200MB per active user.

Heartbeats run cron jobs during user-defined waking hours (e.g., 9-21), querying memory for tasks like "remind project deadline." Promotion scans recall logs post-session, appending high-count facts to MEMORY.md for baseline context.

# Clone and install
 git clone https://github.com/NeoVertex1/nuggets.git
 cd nuggets
 npm install

# Setup env (copy .env.example, add TELEGRAM_TOKEN, ANTHROPIC_API_KEY)
 cp .env.example .env

# Run gateway
 npm start

These commands install dependencies, load env vars for API keys, and launch the gateway on port 3000. Configure Telegram webhook to /telegram/<userId>; first message triggers Pi spawn and nugget init at ~/.nuggets/. Expect initial recall latency at 5ms, dropping to 1ms after cache warmup.

Pros and Cons of Nuggets

Pros:

• Sub-millisecond recall via algebraic HRR ops beats embedding lookup by 10-100x on consumer CPUs.
• Zero external deps for memory; rebuilds from 1KB JSON scale to 1,000 facts per nugget without degredation.
• Proactive cron and heartbeats enable always-on assistants without polling infrastructure.
• TypeScript purity runs anywhere Node.js does, with deterministic seeds ensuring reproducible superpositions.
• Per-user isolation via process pools prevents cross-talk in multi-tenant Telegram bots.
• Auto-promotion cuts LLM costs: repeated facts shift from dynamic recall to static Markdown in 3 sessions.

Cons:

• HRR capacity caps at ~500 unique facts per nugget before interference rises above 5% error rate.
• Tied to Pi/Claude stdin RPC; no native OpenAI or local LLM support without forking.
• No semantic search—exact key matching only, unsuitable for fuzzy queries like RAG.
• WhatsApp integration requires Meta API approval, limiting to business accounts.
• Lacks distributed storage; single-node only, no sharding for >10 users.

Getting Started with Nuggets

Prerequisites include Node.js 20+, Anthropic API key, and Telegram bot token from BotFather. The repo includes .env.example listing ANTHROPIC_API_KEY, TELEGRAM_TOKEN, and optional WHATSAPP_TOKEN. No Docker needed—runs natively.

# After clone/install from above

# Create first nugget
 node -e "
 const { remember } = require('./src/nuggets');
 remember('projects', 'deadline', 'Oct 15 2026', 'seed123');
 "

# Test recall
 node -e "
 const { recall } = require('./src/nuggets');
 console.log(recall('projects', 'deadline', 'seed123'));
 "  # Outputs: 'Oct 15 2026'

# Start gateway and set Telegram webhook
 curl -F "url=https://yourdomain.com/telegram" https://api.telegram.org/bot<TOKEN>/setWebhook

Running remember binds the key-value via convolution into ~/.nuggets/projects.json. Recall rebuilds the hologram, inverse-binds, and cosine-ranks for exact match. Gateway launch monitors /telegram endpoint; send a message to @yourbot to spawn Pi and inject memory into Claude prompt. Initial setup takes 2 minutes; configure cron via chat like "schedule daily reminder at 9am: check projects deadline."

Scale by adding users—each gets a dedicated Pi process. Monitor via logs for recall hits promoting to MEMORY.md after 3 uses. Pair with Claude Context Mode for hybrid prompt+memory flows.

Verdict

Nuggets is the strongest option for solo developers building persistent Claude assistants when avoiding RAG databases, delivering 1ms local HRR recall and proactive Telegram integration. Its deterministic vector rebuild keeps storage minimal at 1KB per topic. Choose it for pocket AI that learns without infra, but switch to MemGPT for deeper hierarchies.