omnimemory

OmniMemory

Vendor-neutral memory abstraction layer for Go. Store and retrieve semantic memories across multiple backends with a unified API.

Features

• 🔌 Multi-Provider Support: PostgreSQL+pgvector, In-memory, KVS, Twilio Memory API
• 🎯 Unified API: Same interface across all providers
• 🔍 Semantic Search: Vector similarity search with configurable embeddings
• 🏢 Multi-Tenancy: Built-in tenant and subject isolation
• 📍 Memory Scopes: User, agent, tenant, team, session, domain
• 🏷️ Memory Types: Observation, fact, preference, summary, trait, relationship
• 🔄 Fallback Support: Automatic failover to backup providers
• ✅ Conformance Tests: Validate provider implementations

Installation

go get github.com/plexusone/omnimemory

Quick Start

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/plexusone/omnimemory"
    "github.com/plexusone/omnimemory/core"
    _ "github.com/plexusone/omnimemory/provider/memory" // Register provider
)

func main() {
    client, err := omnimemory.NewClient(core.ClientConfig{
        Providers: []core.ProviderConfig{
            {Name: core.ProviderNameMemory},
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    ctx := context.Background()

    // Add a memory
    memory, err := client.Add(ctx, &core.AddRequest{
        Context: core.Context{
            TenantID:  "tenant-123",
            SubjectID: "user-456",
        },
        Type:    core.MemoryTypeObservation,
        Content: "User prefers dark mode interfaces",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Added memory: %s\n", memory.ID)

    // Recall memories
    recalled, err := client.Recall(ctx, &core.RecallRequest{
        Context: core.Context{
            TenantID:  "tenant-123",
            SubjectID: "user-456",
        },
        Query: "user interface preferences",
    })
    if err != nil {
        log.Fatal(err)
    }

    for _, mem := range recalled.Memories {
        fmt.Printf("- %s\n", mem.Content)
    }
}

Providers

SQLite (Local Persistence)

Single-file database, no server required. Recommended for local development with persistence.

import (
    "github.com/plexusone/omnimemory"
    "github.com/plexusone/omnimemory/core"
    _ "github.com/plexusone/omnimemory/provider/kvs"
    "github.com/plexusone/omnistorage-core/kvs/backend/sqlite"
)

store, _ := sqlite.New(sqlite.Config{Path: "memories.db"})

client, _ := omnimemory.NewClient(core.ClientConfig{
    Providers: []core.ProviderConfig{
        {Name: core.ProviderNameKVS, Options: map[string]any{
            "store": store,
        }},
    },
})

Redis (Distributed)

Shared state across multiple instances. Good for horizontally scaled applications.

import (
    "github.com/plexusone/omnimemory"
    "github.com/plexusone/omnimemory/core"
    _ "github.com/plexusone/omnimemory/provider/kvs"
    "github.com/plexusone/omnistorage-core/kvs/backend/redis"
)

store, _ := redis.New(redis.Config{Addr: "localhost:6379"})

client, _ := omnimemory.NewClient(core.ClientConfig{
    Providers: []core.ProviderConfig{
        {Name: core.ProviderNameKVS, Options: map[string]any{
            "store": store,
        }},
    },
})

PostgreSQL + pgvector (Production)

Full vector similarity search with HNSW indexing. Recommended for production.

import _ "github.com/plexusone/omnimemory/provider/postgres"

client, _ := omnimemory.NewClient(core.ClientConfig{
    Providers: []core.ProviderConfig{
        {Name: core.ProviderNamePostgres, Options: map[string]any{
            "connection_string": os.Getenv("DATABASE_URL"),
        }},
    },
})

AWS DynamoDB (Serverless)

Fully managed, serverless with automatic scaling and TTL support.

import _ "github.com/plexusone/omni-aws/omnimemory/dynamodb"

client, _ := omnimemory.NewClient(core.ClientConfig{
    Providers: []core.ProviderConfig{
        {Name: core.ProviderNameAWSDynamoDB, Options: map[string]any{
            "table_name":   "omnimemory",
            "region":       "us-east-1",
            "create_table": true, // Auto-create for development
        }},
    },
})

mem0 (Hosted API)

Managed memory service with automatic fact extraction.

import _ "github.com/plexusone/mem0-go/omnimemory"

client, _ := omnimemory.NewClient(core.ClientConfig{
    Providers: []core.ProviderConfig{
        {Name: core.ProviderNameMem0, APIKey: os.Getenv("MEM0_API_KEY")},
    },
})

Multi-Provider with Fallback

client, _ := omnimemory.NewClient(core.ClientConfig{
    Providers: []core.ProviderConfig{
        // Primary: PostgreSQL
        {Name: core.ProviderNamePostgres, Options: map[string]any{
            "connection_string": os.Getenv("DATABASE_URL"),
        }},
        // Fallback: SQLite
        {Name: core.ProviderNameKVS, Options: map[string]any{
            "store": sqliteStore,
        }},
    },
})

Memory Types

Memory Scopes

Documentation

• Documentation Site
• Go Package Reference

Related Projects

• omnillm-core - Unified LLM SDK
• omni-twilio - Twilio adapters including Memory provider
• omnistorage-core - Storage abstraction for KVS provider
• omni-aws - AWS adapters including S3 object storage

License

MIT License - see LICENSE for details.