AI Memory for the EdgePrivate, Fast, Offline
Bring persistent memory to robots, drones, IoT devices, and defence systems—running entirely on-device. No cloud latency, no connectivity required, no data leaving your edge.
Edge-Native: 4MB binary, <100ms retrieval, works offline •Stack: Rust + RocksDB + Vamana HNSW + ONNX Runtime + llama.cpp •Targets: Drones, Robots, Industrial IoT, Defence
Why Edge Devices Need Local Memory
Robots, drones, and IoT devices can't wait for cloud APIs. They need instant, offline intelligence.
Cloud-Dependent Systems
With Shodh Memory
Enterprise-Grade Memory Features
Built with Rust for performance, designed for production, free for everyone
3-Tier Memory Hierarchy
Mimics human memory: Working → Session → Long-term with intelligent promotion
<1ms working memory, <10ms session, <100ms long-term retrieval
Knowledge Graph Intelligence
Track entities, relationships, and episodes with temporal validity
Graphiti-inspired architecture for complex knowledge modeling
100% Offline & Private
No cloud dependency, GDPR compliant by design, your data stays local
Multi-tenant isolation with user_id, agent_id, run_id, actor_id
Lightning Fast (Rust)
10x faster than Python alternatives, 4MB binary, <100ms startup
RocksDB storage with LZ4 compression, custom Vamana HNSW index
Multi-Modal Retrieval
5 search modes: Similarity, Temporal, Causal, Associative, Hybrid
ONNX Runtime + llama.cpp - bring your own embedding models
Enterprise-Ready
28 REST APIs, audit logging, compression, GDPR compliance
Production-grade with Docker deployment and web dashboard
Get Started in 2 Lines of Code
Simple Python API, auto-start server, instant memory
# Install
pip install shodh-memory # Coming soon
# Import and initialize (native PyO3 bindings)
import shodh_memory
memory = shodh_memory.MemorySystem(storage_path="./my_memory")
# Record experiences
memory.record(
content="User prefers concise explanations with code examples",
experience_type="learning",
entities=["user", "preferences"]
)
memory.record(
content="John Smith works at OpenAI on GPT-4 development",
experience_type="discovery",
entities=["John Smith", "OpenAI", "GPT-4"]
)
# Semantic search (hybrid mode)
results = memory.retrieve(
query="user preferences for documentation",
max_results=5,
mode="hybrid" # semantic, temporal, or hybrid
)
# Access results
for mem in results:
print(f"{mem['content']} (importance: {mem['importance']:.2f})")
# Flush to disk before shutdown
memory.flush()⚡ Native Performance: PyO3 Rust bindings - 5-10ms faster than REST API, zero IPC overhead, single process deployment.
🔧 Flexible: Bring your own embedding models via ONNX Runtime. Works with llama.cpp for local LLM inference.
pip install shodh-memorydocker-compose upPOST /api/recordBuilt For Real AI Applications
Where local memory makes the difference
Autonomous Drones
Drones that learn from every flight
Store obstacle maps, terrain data, mission parameters—no internet needed in remote areas
Example: Agricultural drone surveying fields remembers crop patterns, irrigation issues from previous flights. Works in areas with zero connectivity.
Defence & Military Systems
Mission-critical memory for secure operations
Air-gapped deployment, classified data stays on-device, complete audit trail for compliance
Example: Reconnaissance drone stores mission data locally. Tactical robots remember terrain, threats, patrol routes—all offline and secure.
Industrial Robotics
Factory robots with persistent knowledge
Assembly procedures, quality checks, maintenance logs—all stored locally on robot controllers
Example: Manufacturing robot recalls "Part X123 requires 45° angle, torque 12Nm" from assembly manual. Warehouse robot optimizes paths based on stored floor layouts.
IoT & Smart Devices
Edge intelligence without cloud
Smart city sensors, medical devices, surveillance systems—process and remember locally
Example: Smart city traffic sensor builds knowledge graph of congestion patterns. Medical IoT device stores patient context privately without cloud transmission.
How Shodh Memory Works
3-Tier memory hierarchy + Knowledge graph + Vector search
┌──────────────────────────────────────────────────────────────┐
│ SHODH MEMORY SYSTEM │
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ WORKING MEMORY (LRU Cache) │ │
│ │ • 100 most recent/frequent memories │ │
│ │ • Retrieval: <1ms │ │
│ │ • High importance items (>0.4) │ │
│ └────────────────────────────────────────────────────────┘ │
│ ↓↑ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ SESSION MEMORY (Size-Limited) │ │
│ │ • 100MB current session context │ │
│ │ • Retrieval: <10ms │ │
│ │ • Promotion threshold: importance >0.6 │ │
│ └────────────────────────────────────────────────────────┘ │
│ ↓↑ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ LONG-TERM MEMORY (RocksDB) │ │
│ │ • Unlimited storage with LZ4 compression │ │
│ │ • Retrieval: <100ms uncompressed, <200ms compressed │ │
│ │ • Auto-compression after 7+ days │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ KNOWLEDGE GRAPH (Graphiti-Inspired) │ │
│ │ │ │
│ │ [Entity: John] ──WorksAt──> [Entity: OpenAI] │ │
│ │ │ │ │ │
│ │ └──────Uses──────> [Entity: GPT-4] │ │
│ │ │ │
│ │ • Entities: Person, Org, Location, Tech, Concept │ │
│ │ • Relationships: Temporal validity + confidence │ │
│ │ • Episodes: Time-bounded context windows │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ VECTOR INDEX (Custom Vamana HNSW) │ │
│ │ • ONNX Runtime for embeddings (any model) │ │
│ │ • Cosine similarity search │ │
│ │ • Model-agnostic (384, 512, 768, 1024, 1536 dims) │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────────┘
↕
┌──────────────────┐
│ 28 REST APIs │
│ Python Client │
│ Web Dashboard │
└──────────────────┘Intelligent Promotion
Memories automatically promoted based on 7-factor importance scoring
Knowledge Graphs
Extract entities and relationships automatically with temporal tracking
Auto-Compression
Old memories compressed automatically with LZ4 (2-5x) or semantic (10-50x)
Why Choose Shodh Memory?
Edge-native, offline alternative to cloud-based mem0 ($24M funding) and Zep (Graphiti)
| Feature | Shodh Memory | mem0 | Zep |
|---|---|---|---|
| Speed (add memory) | <1ms | 5-10ms | 10-20ms |
| Speed (semantic search) | 10-20ms | 100-200ms | 50-100ms |
| Deployment | 100% Edge/Offline | Cloud-only | Hybrid |
| Connectivity | Works Offline | Requires Internet | Requires Internet |
| Memory Hierarchy | 3-Tier (Unique) | Single-tier | Single-tier |
| Knowledge Graph | Yes (Graphiti) | No | Yes (Graphiti) |
| Language | Rust | Python | TypeScript |
| Binary Size | 4MB | 200MB+ | 50MB+ |
| Air-Gapped Support | Yes | No | No |
Privacy-First Architecture
Unlike cloud-based alternatives, Shodh Memory runs 100% locally. Your data never leaves your machine. Perfect for healthcare, finance, legal, or any privacy-sensitive application. GDPR compliant by design with built-in "Right to be Forgotten" support.
Development Roadmap
Where we are and where we're going
Native Python SDK
PyO3 bindings completed - zero IPC overhead, 5-10ms faster than REST API
Production Launch
JavaScript/TypeScript SDK, comprehensive documentation, ROS2 integration examples
Advanced Features
GraphQL API, Prometheus metrics, distributed tracing, advanced compression
Distributed Mode
Multi-node synchronization for distributed AI agent fleets via Zenoh
Multi-Modal Memory
Image, audio, video embeddings for complete multi-modal memory systems
Bring Intelligence to the Edge
Deploy Shodh Memory on your robots, drones, and IoT devices. Production-ready, runs completely offline, no cloud required.