Nemo API Documentation

Comprehensive documentation for integrating advanced AI memory systems into your applications. Build intelligent systems with persistent memory, associative reasoning, and episodic recall.

🚀 Quick Start

Get up and running with Nemo in under 5 minutes. Install the SDK, authenticate, and make your first memory API call.

📚 API Reference

Complete reference documentation for all Nemo API endpoints, parameters, and response formats.

💡 Examples

Practical code examples demonstrating common use cases and advanced memory system implementations.

🛠️ SDKs

Official SDKs for Python, JavaScript, Go, and Rust with type safety and built-in error handling.

Core Features

Memory Allocation

Dynamic memory allocation with configurable types, persistence levels, and automatic scaling capabilities.

Episodic Storage

Store and retrieve specific episodes with full contextual information and temporal relationships.

Associative Networks

Build complex associative memory structures with weighted connections and multi-hop reasoning.

Memory Consolidation

Automatic memory optimization and consolidation using advanced compression and organization algorithms.

Cross-Modal Integration New

Unified memory formation across text, images, audio, and structured data with seamless retrieval.

Real-Time Processing

Sub-millisecond response times with concurrent access support and lock-free data structures.

Simple Example

Here's a basic example of storing and retrieving a memory using the Nemo API:

import nemo

# Initialize the Nemo client
client = nemo.Client(api_key="your_api_key")

# Allocate memory space
memory_id = client.memory.allocate(
    size="1GB", 
    type="episodic",
    persistence="session"
)

# Store a memory
response = client.memory.store(
    memory_id=memory_id,
    data={
        "content": "First successful API call",
        "timestamp": "2025-06-10T10:30:00Z",
        "context": {"mood": "excited", "location": "office"}
    },
    associations=["success", "first_time", "api"]
)

# Retrieve memories
memories = client.memory.retrieve(
    query="successful API call",
    similarity_threshold=0.8,
    limit=10
)

print(f"Found {len(memories)} related memories")
                

This example demonstrates the core workflow: allocate memory space, store structured data with context, and retrieve relevant memories using semantic search.

Key Concepts

Memory Types

Nemo supports multiple memory types optimized for different use cases:

Episodic: Specific events and experiences with temporal context
Semantic: Factual knowledge and conceptual relationships
Working: Temporary information for active processing
Procedural: Skills and learned behaviors

Persistence Levels

Control how long memories are retained:

Session: Cleared when session ends
Temporary: Automatic expiration (hours to days)
Persistent: Long-term storage (months to years)
Permanent: Never automatically deleted

Associative Strength

Connections between memories have strength values (0.0 to 1.0) that influence retrieval probability and consolidation priority. Higher strength connections are more likely to be activated during memory searches.

Next Steps

Ready to start building with Nemo? Here are some recommended next steps: