Getting Started - Nemo API Documentation

Welcome to the Nemo API! This guide will help you get up and running with advanced AI memory systems in just a few minutes. Nemo provides powerful memory capabilities including episodic storage, associative networks, and cross-modal integration.

What you'll learn: How to install the Nemo SDK, authenticate your requests, and make your first API call to store and retrieve memories.

Prerequisites

Before you begin, make sure you have:

A Nemo API account (email nemosresearch@outlook.com)
Your API key from the Nemo dashboard
Python 3.8+ or Node.js 16+ (depending on your preferred SDK)
Basic familiarity with REST APIs or your chosen programming language

API Key Security: Never expose your API key in client-side code or public repositories. Store it securely as an environment variable.

Installation

Choose your preferred language and install the corresponding Nemo SDK:

Python

JavaScript

Go

Rust

# Install via pip
pip install nemo-ai

# Or with conda
conda install -c nemo nemo-ai

# Verify installation
python -c "import nemo; print(nemo.__version__)"
                    

# Install via npm
npm install @nemo/sdk

# Or with yarn
yarn add @nemo/sdk

# Verify installation
node -e "console.log(require('@nemo/sdk').version)"
                    

# Install via go mod
go mod init your-project
go get github.com/nemo-ai/go-sdk

# Verify installation
go list -m github.com/nemo-ai/go-sdk
                    

# Add to Cargo.toml
[dependencies]
nemo = "0.1.0"

# Verify installation
cargo check
                    

Authentication

Nemo uses API keys for authentication. Your API key must be included in the Authorization header of every request.

Step 1

Get Your API Key

Log in to your Nemo dashboard and navigate to the API Keys section. Create a new key and copy it to your clipboard.

Step 2

Set Environment Variable

Store your API key as an environment variable for security:

# Unix/macOS
export NEMO_API_KEY="your_api_key_here"

# Windows
set NEMO_API_KEY=your_api_key_here

# Or add to your .env file
NEMO_API_KEY=your_api_key_here
                    

Step 3

Initialize the Client

Python

JavaScript

Go

Rust

import os
import nemo

# Initialize client with API key from environment
client = nemo.Client(api_key=os.getenv("NEMO_API_KEY"))

# Or pass directly (not recommended for production)
client = nemo.Client(api_key="your_api_key_here")
                        

const Nemo = require('@nemo/sdk');

// Initialize client with API key from environment
const client = new Nemo.Client({
  apiKey: process.env.NEMO_API_KEY
});

// Or with ES modules
import { Client } from '@nemo/sdk';
const client = new Client({ apiKey: process.env.NEMO_API_KEY });
                        

package main

import (
    "os"
    "github.com/nemo-ai/go-sdk"
)

func main() {
    client := nemo.NewClient(nemo.Config{
        APIKey: os.Getenv("NEMO_API_KEY"),
    })
}
                        

use nemo::Client;
use std::env;

fn main() {
    let api_key = env::var("NEMO_API_KEY")
        .expect("NEMO_API_KEY must be set");
    
    let client = Client::new(&api_key);
}
                        

Your First Request

Let's make your first API call to store and retrieve a memory. This example demonstrates the core Nemo workflow:

Step 1

Allocate Memory Space

Python

JavaScript

Go

Rust

import nemo
import os

# Initialize client
client = nemo.Client(api_key=os.getenv("NEMO_API_KEY"))

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

print(f"Allocated memory space: {memory_id}")
                        

const { Client } = require('@nemo/sdk');

// Initialize client
const client = new Client({
  apiKey: process.env.NEMO_API_KEY
});

async function allocateMemory() {
  // Allocate memory space
  const memoryId = await client.memory.allocate({
    size: "1GB",
    type: "episodic",
    persistence: "session",
    name: "my_first_memory_space"
  });
  
  console.log(`Allocated memory space: ${memoryId}`);
  return memoryId;
}
                        

package main

import (
    "fmt"
    "os"
    "github.com/nemo-ai/go-sdk"
)

func main() {
    client := nemo.NewClient(nemo.Config{
        APIKey: os.Getenv("NEMO_API_KEY"),
    })
    
    memoryID, err := client.Memory.Allocate(nemo.AllocateRequest{
        Size:        "1GB",
        Type:        "episodic",
        Persistence: "session",
        Name:        "my_first_memory_space",
    })
    
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Allocated memory space: %s\n", memoryID)
}
                        

use nemo::{Client, AllocateRequest};
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box> {
    let api_key = env::var("NEMO_API_KEY")?;
    let client = Client::new(&api_key);
    
    let memory_id = client.memory().allocate(AllocateRequest {
        size: "1GB".to_string(),
        memory_type: "episodic".to_string(),
        persistence: "session".to_string(),
        name: Some("my_first_memory_space".to_string()),
    }).await?;
    
    println!("Allocated memory space: {}", memory_id);
    Ok(())
}
                        

Step 2

Store a Memory

Now let's store some data in our allocated memory space:

# Store a memory with context and associations
response = client.memory.store(
    memory_id=memory_id,
    data={
        "content": "Successfully completed Nemo API tutorial",
        "timestamp": "2025-06-10T15:30:00Z",
        "context": {
            "activity": "learning",
            "mood": "accomplished",
            "difficulty": "beginner"
        },
        "metadata": {
            "source": "tutorial",
            "version": "1.0"
        }
    },
    associations=["tutorial", "success", "first_memory", "learning"],
    strength=0.9
)

print(f"Stored memory with ID: {response.memory_item_id}")
                    

Step 3

Retrieve Memories

Finally, let's search for and retrieve our stored memory:

# Search for memories using semantic similarity
memories = client.memory.retrieve(
    memory_id=memory_id,
    query="tutorial completion",
    similarity_threshold=0.7,
    limit=10,
    include_context=True
)

print(f"Found {len(memories)} related memories:")
for memory in memories:
    print(f"- {memory.data['content']} (similarity: {memory.similarity:.2f})")
    print(f"  Associations: {', '.join(memory.associations)}")
    print(f"  Stored: {memory.timestamp}")
                    

Success! You've successfully allocated memory space, stored your first memory with context and associations, and retrieved it using semantic search. You're ready to build more complex memory-enhanced applications!

Next Steps

Now that you've made your first successful API call, here are some recommended next steps:

1

Explore More Examples

Check out our comprehensive examples covering episodic memory, associative networks, and cross-modal integration.

2

Learn the API

Dive deeper into the API reference to understand all available endpoints, parameters, and response formats.

3

Build Something Amazing

Start building your memory-enhanced application! Consider use cases like:

Intelligent chatbots with conversation memory
Personalized recommendation systems
Knowledge bases with associative search
Educational platforms with adaptive learning
Content management with semantic organization

4

Join the Community

Connect with other developers building with Nemo:

Follow @NemosResearch on X