Memory Systems

Pluggable memory backends for conversation history and state persistence. Choose from in-memory, Redis, or Postgres backends.

Available Backends

Backend	Use Case	Persistence
InMemory	Development, testing, single-instance	None (process memory)
Redis	Multi-instance, fast access	Optional (depends on Redis config)
Postgres	Full persistence, audit requirements	Full (database)

---

createMemoryStorage

Factory function to create memory backends:

TypeScript

import { createMemoryStorage } from '@sekuire/sdk';

// In-memory (default)
const memory = createMemoryStorage({ type: 'memory' });

// Redis
const redisMemory = createMemoryStorage({
  type: 'redis',
  url: 'redis://localhost:6379',
  keyPrefix: 'agent:conversations:'
});

// Postgres
const pgMemory = createMemoryStorage({
  type: 'postgres',
  connectionString: process.env.DATABASE_URL,
  tableName: 'agent_memory'
});

Python

from sekuire_sdk.memory import create_memory_storage

# In-memory (default)
memory = create_memory_storage(type="memory")

# Redis
redis_memory = create_memory_storage(
    type="redis",
    url="redis://localhost:6379",
    key_prefix="agent:conversations:"
)

# Postgres
pg_memory = create_memory_storage(
    type="postgres",
    connection_string=os.environ["DATABASE_URL"],
    table_name="agent_memory"
)

Rust

use sekuire_sdk::memory::create_memory_storage;

// In-memory (default)
let memory = create_memory_storage(MemoryConfig::InMemory)?;

// Redis
let redis_memory = create_memory_storage(MemoryConfig::Redis {
    url: "redis://localhost:6379".into(),
    key_prefix: Some("agent:conversations:".into()),
})?;

// Postgres
let pg_memory = create_memory_storage(MemoryConfig::Postgres {
    connection_string: std::env::var("DATABASE_URL")?,
    table_name: Some("agent_memory".into()),
})?;

---

Using with Agents

TypeScript

import { getAgent, createMemoryStorage } from '@sekuire/sdk';

const memory = createMemoryStorage({
  type: 'redis',
  url: 'redis://localhost:6379'
});

const agent = await getAgent('assistant', { memory });

// Conversations persist across agent restarts
await agent.chat('Hello!');
// Later...
const history = await memory.getHistory('session_123');

Python

from sekuire_sdk import get_agent, create_memory_storage

memory = create_memory_storage(
    type="redis",
    url="redis://localhost:6379"
)

agent = await get_agent("assistant", memory=memory)

# Conversations persist across agent restarts
await agent.chat("Hello!")
# Later...
history = await memory.get_history("session_123")

Rust

use sekuire_sdk::{get_agent, memory::create_memory_storage};

let memory = create_memory_storage(MemoryConfig::Redis {
    url: "redis://localhost:6379".into(),
    key_prefix: None,
})?;

let agent = get_agent(Some("assistant"), Some(AgentOptions {
    memory: Some(memory.clone()),
    ..Default::default()
})).await?;

let history = memory.get_history("session_123").await?;

---

Memory API

TypeScript

// Store a message
await memory.store('session_123', {
  role: 'user',
  content: 'Hello!'
});

// Get full history
const history = await memory.getHistory('session_123');

// Get last N messages
const recent = await memory.getHistory('session_123', { limit: 10 });

// Clear session
await memory.clear('session_123');

// Clear all (use with caution)
await memory.clearAll();

Python

# Store a message
await memory.store("session_123", {
    "role": "user",
    "content": "Hello!"
})

# Get full history
history = await memory.get_history("session_123")

# Get last N messages
recent = await memory.get_history("session_123", limit=10)

# Clear session
await memory.clear("session_123")

# Clear all (use with caution)
await memory.clear_all()

Rust

// Store a message
memory.store("session_123", Message::user("Hello!")).await?;

// Get full history
let history = memory.get_history("session_123", None).await?;

// Get last N messages
let recent = memory.get_history("session_123", Some(10)).await?;

// Clear session
memory.clear("session_123").await?;

Next Steps

• Agent API - Configure agents with memory
• Streaming - Stream responses with memory