Edge AI Memory • For Robots, Drones & IoT

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

Join Beta Program Documentation

4MB

Binary Size

<100ms

Startup Time

Cloud Dependency

REST APIs

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

❌

Network Latency

200-500ms API roundtrip kills real-time decisions

❌

Connectivity Required

Drone in remote field, robot in factory dead zone = system stops

❌

Data Transmission Risk

Sensitive defence/industrial data sent to cloud servers

❌

Per-API Costs

1000 robots × 10K queries/day = ₹4L+/month cloud bills

With Shodh Memory

✓

Sub-100ms Response

Local RocksDB + Vamana index = real-time decisions

✓

100% Offline Operation

Works in remote fields, factory floors, military zones—no internet needed

✓

Air-Gapped Deployment

Classified defence data, sensitive industrial IP—stays on your edge devices

✓

4MB Binary, Low Power

Rust efficiency = runs on resource-constrained edge devices

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

Python SDK for Robots & Drones - Full Robotics Support

# Install
pip install shodh-memory

from shodh_memory import ShodhClient, Position, GeoLocation, ExperienceType

# Initialize with robot identity
client = ShodhClient(robot_id="drone_001")

# Start a mission (all experiences auto-tagged)
client.start_mission("survey_mission_42")

# Record with GPS + local position (works offline)
client.record(
    content="Obstacle detected: tree at 2m distance",
    position=Position(x=10.5, y=20.3, z=0.0),       # Local coords (meters)
    geo_location=GeoLocation(37.7749, -122.4194, 50.0),  # GPS
    heading=45.0,                                    # Orientation (degrees)
    action_type="obstacle_detection",
    sensor_data={"lidar_distance": 2.1, "confidence": 0.95},
    experience_type=ExperienceType.DISCOVERY
)

# Query with geo-spatial filters
from shodh_memory import GeoFilter
results = client.query(
    query_text="obstacles near landing zone",
    mission_id="survey_mission_42",
    geo_filter=GeoFilter(
        center=GeoLocation(37.7749, -122.4194, 0),
        radius_meters=500  # Search within 500m radius
    )
)

for mem in results.memories:
    print(f"{mem.content} @ {mem.position} (score: {mem.score:.2f})")

🤖 Robotics-First: Native support for Position (x,y,z), GeoLocation (lat,lon,alt), heading, mission tracking, and sensor data. Works completely offline.

⚡ Edge Performance: 15-50 records/sec, 6-35ms query latency. Tested with 500+ rapid insertions at 100% success rate.

Python SDK

pip install shodh-memory

ROS2 Node

from shodh_memory.ros2 import *

REST API

POST /api/record

Native ROS2 Integration

Drop-in node for ROS2 robots - auto-tracks position, GPS, and battery

ROS2 Node - Automatic Position & Sensor Tracking

# In your ROS2 package
from shodh_memory.ros2 import ShodhMemoryNode
import rclpy

def main():
    rclpy.init()

    # Node auto-subscribes to /odom, /gps/fix, /battery
    node = ShodhMemoryNode(robot_id="warehouse_robot_01")

    # Record obstacles (position auto-attached from /odom)
    node.record_obstacle("forklift blocking aisle 3", distance=2.5)

    # Record waypoints
    node.record_waypoint("loading_dock_b", status="reached")

    # Record sensor readings
    node.record_sensor_reading(
        sensor_name="temperature",
        readings={"motor_temp": 45.2, "ambient": 22.0},
        anomaly=False
    )

    rclpy.spin(node)

# Auto-subscribed topics:
# /memory/record (String) - Record arbitrary memories
# /odom (Odometry) - Auto-track robot position
# /gps/fix (NavSatFix) - Auto-track GPS (drones)
# /battery (BatteryState) - Battery warnings at <20%
# /mission/start, /mission/end - Mission lifecycle

📍 Auto Position: Every memory automatically tagged with current odometry position and GPS coordinates

🔋 Battery Alerts: Automatically records critical battery warnings when level drops below 20%

Built 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.

Proven Edge Performance

Real benchmarks from integration tests - not synthetic

6-35ms

Query Latency

Hybrid semantic + temporal

15-50

Records/Second

With embedding generation

500+

Stress Test Passed

Rapid insertions, 100% success

Integration Tests

All passing, production-ready

$ cargo test --test integration_tests

✓ test_core_memory_operations (initialization, record, retrieve)

✓ test_robotics_scenarios (mission tracking, obstacle detection, calibration)

✓ test_drone_fleet_operations (multi-drone, geo-spatial, flight paths)

✓ test_performance_benchmarks (latency, throughput, concurrency)

✓ test_reliability_and_edge_cases (unicode, empty content, stress)

✓ test_stress_scenarios (500 rapid insertions, 100% success)

test result: ok. 34 passed; 0 failed

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

Q1-Q3 2025Completed

Core Memory System

3-tier memory hierarchy, knowledge graph, vector indexing - production-ready Rust engine

Q4 2025Completed

Robotics Python SDK

Full robotics support: Position, GeoLocation, mission tracking, sensor data, ROS2 integration

Q1 2026In Progress

Fleet Coordination

Multi-robot memory sync via Zenoh, shared knowledge graphs, fleet-wide learning

Q2 2026Planned

Visual Positioning

VPS integration for GPS-denied environments, Gaussian Splat scene memory (.spz format)

Q3 2026+Vision

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.

Join Beta Program Read Documentation