memory

package module

v0.0.0-...-da59b90 Latest Latest Go to latest Published: Sep 3, 2025 License: MIT Imports: 10 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/framehood/go-agent-memory

Links

Open Source Insights

README ¶

Go Agent Memory 🧠

A modular, production-ready memory system for AI agents with multiple deployment modes. Supports session-only (zero dependencies), persistent (PostgreSQL + pgvector), and hybrid (Redis + PostgreSQL) configurations.

Features ✨

🚀 Multiple Modes: Session-only, Persistent, or Hybrid deployment
📝 Session Memory: Fast retrieval of recent conversation history
🔍 Semantic Search: Find relevant past conversations using vector similarity
💾 Flexible Storage: In-memory, PostgreSQL, or Redis + PostgreSQL
🎯 Auto-Summarization: Compress old conversations to save tokens
🔧 Feature Flags: Enable/disable features as needed
🔌 Zero Dependencies: Start with session-only mode, add features later
⚡ Production Ready: Connection pooling, error handling, and graceful degradation

Documentation 📚

📚 Complete Documentation - All guides and references
🚀 Quick Start Guide - Zero to running in 5 minutes
🏗️ Architecture Overview - System design and data flow
📖 Examples - 7 complete examples from simple to production

Repository Structure 📁

go-agent-memory/
├── memory.go           # Core interfaces and types
├── session_only.go     # In-memory implementation (zero deps)
├── supabase.go        # PostgreSQL + pgvector implementation
├── hybrid.go          # Redis + PostgreSQL hybrid
├── docs/              # Documentation
│   ├── IMPLEMENTATION_GUIDE.md
│   ├── ARCHITECTURE.md
│   ├── INTEGRATE_WITH_AGENT.md
│   └── SUMMARY.md
├── tests/             # Test files
│   └── memory_test.go
├── examples/          # Complete examples (7 modes)
│   ├── 01-session-only/
│   ├── 02-persistent-basic/
│   ├── 03-hybrid-mode/
│   ├── 04-semantic-search/
│   ├── 05-auto-summarization/
│   ├── 06-event-streaming/
│   ├── 07-agent-integration/
│   └── integration.go
├── scripts/           # Utility scripts
│   └── quickstart.sh
└── deployment/        # Deployment configs
    ├── docker-compose.yml
    └── init.sql

Quick Start 🚀

1. Install the Package

go get github.com/framehood/go-agent-memory

2. Choose Your Mode

Option A: Zero Dependencies (Session-Only)

mem, _ := memory.NewWithConfig(memory.Config{
    Mode: memory.SESSION_ONLY,
})
// No database or Redis needed!

Option B: Persistent (PostgreSQL)

mem, _ := memory.NewWithConfig(memory.Config{
    Mode:        memory.PERSISTENT,
    DatabaseURL: "postgresql://user:pass@host:5432/dbname",
    OpenAIKey:   "sk-...", // For semantic search
})

Option C: Hybrid (Redis + PostgreSQL)

mem, _ := memory.NewWithConfig(memory.Config{
    Mode:        memory.HYBRID,
    DatabaseURL: "postgresql://user:pass@host:5432/dbname",
    RedisAddr:   "localhost:6379",
    OpenAIKey:   "sk-...",
})

3. Basic Usage

package main

import (
    "context"
    "fmt"
    "log"
    
    memory "github.com/framehood/go-agent-memory"
)

func main() {
    // Initialize memory (auto-detects mode from config)
    mem, err := memory.NewWithConfig(memory.Config{
        Mode:           memory.PERSISTENT,
        DatabaseURL:    "postgresql://user:pass@host:5432/dbname",
        OpenAIKey:      "your-openai-key",
        EmbeddingModel: "text-embedding-3-small",
    })
    if err != nil {
        log.Fatal(err)
    }
    defer mem.Close()
    
    // Add a message
    err = mem.AddMessage(context.Background(), memory.Message{
        ID:      "msg-123",
        Role:    "user",
        Content: "What's the weather like?",
        Metadata: memory.Metadata{
            SessionID: "session-456",
            UserID:    "user-789",
        },
    })
    
    // Get recent messages
    messages, _ := mem.GetRecentMessages(context.Background(), "session-456", 10)
    
    // Semantic search
    results, _ := mem.Search(context.Background(), 
        "weather forecast", 5, 0.7)
    
    for _, result := range results {
        fmt.Printf("Found: %s (score: %.2f)\n", 
            result.Message.Content, result.Score)
    }
}

Integration with Your Agent 🤖

Here's how to add memory to your existing agent:

// In your agent/main.go

package main

import (
    "context"
    "os"
    
    memory "github.com/framehood/go-agent-memory"
    "github.com/openai/openai-go/v2"
)

var mem memory.Memory // Optional memory instance

func initMemory() {
    // Only initialize if environment variables are set
    dbURL := os.Getenv("DATABASE_URL")
    if dbURL == "" {
        fmt.Println("Memory disabled: DATABASE_URL not set")
        return
    }
    
    var err error
    mem, err = memory.NewWithConfig(memory.Config{
        Mode:        memory.HYBRID, // Or PERSISTENT, SESSION_ONLY
        DatabaseURL: dbURL,
        OpenAIKey:   os.Getenv("OPENAI_API_KEY"),
        
        // Optional Redis for faster session access
        RedisAddr:     os.Getenv("REDIS_URL"), // e.g., "localhost:6379"
        RedisPassword: os.Getenv("REDIS_PASSWORD"),
        
        // Feature flags
        EnableSemanticSearch: true,
        EnableAutoSummarize:  true,
        
        // Settings
        MaxSessionMessages: 50,
        SessionTTL:        24 * time.Hour,
    })
    
    if err != nil {
        fmt.Printf("Warning: Memory initialization failed: %v\n", err)
        mem = nil
    }
}

func main() {
    // Initialize memory (optional)
    initMemory()
    if mem != nil {
        defer mem.Close()
    }
    
    // Your existing agent code...
    
    // When processing messages:
    handleUserMessage := func(sessionID, content string) {
        // Store user message if memory is enabled
        if mem != nil {
            mem.AddMessage(context.Background(), memory.Message{
                ID:      generateID(),
                Role:    "user",
                Content: content,
                Metadata: memory.Metadata{
                    SessionID: sessionID,
                },
            })
        }
        
        // Get context from memory
        var contextMessages []openai.ChatCompletionMessageParamUnion
        if mem != nil {
            // Get recent conversation
            recent, _ := mem.GetRecentMessages(context.Background(), sessionID, 10)
            
            // Search for relevant past conversations
            similar, _ := mem.Search(context.Background(), content, 3, 0.75)
            
            // Add to context (you'd format this appropriately)
            for _, msg := range recent {
                // Add to contextMessages...
            }
        }
        
        // Continue with OpenAI call...
    }
}

Configuration Options 🔧

Session-Only Mode (Zero Dependencies)

memory.Config{
    Mode: memory.SESSION_ONLY,
    MaxSessionMessages: 50, // Optional: default 50
}

Persistent Mode (PostgreSQL)

memory.Config{
    Mode:        memory.PERSISTENT,
    DatabaseURL: "postgresql://...",  // Required
    OpenAIKey:   "sk-...",           // Optional: for semantic search
    
    // Feature flags
    EnableSemanticSearch: true,  // Enable vector search
    EnableAutoSummarize:  true,  // Enable summarization
}

Hybrid Mode (Redis + PostgreSQL)

memory.Config{
    Mode:        memory.HYBRID,
    DatabaseURL: "postgresql://...",  // Required
    RedisAddr:   "localhost:6379",   // Required
    OpenAIKey:   "sk-...",           // Optional: for semantic search
    
    // Feature flags
    EnableSemanticSearch: true,
    EnableAutoSummarize:  true,
    
    // Performance settings
    MaxSessionMessages: 30,           // Messages in Redis cache
    SessionTTL:        2 * time.Hour, // Redis cache expiry
    
    // Summarization settings
    SummarizeThreshold: 50,          // Messages before summarization
    SummarizeMaxTokens: 500,         // Target summary length
    SummarizeModel:     "gpt-3.5-turbo",
    
    // Search settings
    DefaultSearchLimit:     5,
    DefaultSearchThreshold: 0.7,
}

Environment Variables 🌍

# Required
export DATABASE_URL="postgresql://postgres:password@db.supabase.co:5432/postgres"
export OPENAI_API_KEY="sk-..."

# Optional (for Redis caching)
export REDIS_URL="localhost:6379"
export REDIS_PASSWORD=""

# Optional Supabase (if using REST APIs)
export SUPABASE_URL="https://xxx.supabase.co"
export SUPABASE_ANON_KEY="eyJ..."

Features in Detail 📚

1. Session Memory

Recent messages cached in Redis (if available)
Falls back to PostgreSQL if Redis is unavailable
Automatic TTL and size limits

2. Semantic Search

Uses OpenAI embeddings (text-embedding-3-small/large)
HNSW index for fast similarity search
Configurable similarity threshold

3. Auto-Summarization

Compress old conversations to save context tokens
Summaries stored in separate table
Cached in Redis for fast access

4. Graceful Degradation

Works without Redis (Supabase only)
Continues if embedding generation fails
Non-blocking background operations

Performance 🏎️

With Redis + Supabase (Hybrid)

Session retrieval: ~2-5ms
Message storage: ~10ms
Semantic search: ~50-100ms

Session-Only Mode

Session retrieval: ~1μs (in-memory)
Message storage: ~1μs (in-memory)
Search: ~1ms (basic text matching)

Persistent Mode (PostgreSQL)

Session retrieval: ~20-50ms
Message storage: ~20-30ms
Semantic search: ~50-100ms

Database Schema 📊

The package automatically creates these tables:

-- Messages table
CREATE TABLE agent_messages (
    id SERIAL PRIMARY KEY,
    message_id TEXT UNIQUE,
    session_id TEXT,
    user_id TEXT,
    role TEXT,
    content TEXT,
    metadata JSONB,
    embedding vector(1536),
    created_at TIMESTAMPTZ,
    updated_at TIMESTAMPTZ
);

-- Summaries table  
CREATE TABLE agent_summaries (
    id SERIAL PRIMARY KEY,
    session_id TEXT,
    summary TEXT,
    message_count INT,
    token_count INT,
    start_time TIMESTAMPTZ,
    end_time TIMESTAMPTZ,
    created_at TIMESTAMPTZ
);

Advanced Usage 🎓

Custom Embedding Models

mem, _ := memory.NewWithConfig(memory.Config{
    Mode:            memory.PERSISTENT,
    DatabaseURL:     dbURL,
    OpenAIKey:       apiKey,
    EmbeddingModel:  "text-embedding-3-large",
    VectorDimension: 3072, // Large model dimension
})

Search with Pre-computed Embeddings

// If you already have an embedding
embedding := []float32{0.1, 0.2, ...} // 1536 dimensions
results, _ := mem.SearchWithEmbedding(ctx, embedding, 10, 0.8)

Get Memory Statistics

stats, _ := mem.GetStats(ctx, "session-123")
fmt.Printf("Total messages: %d\n", stats.TotalMessages)
fmt.Printf("Total tokens: %d\n", stats.TotalTokens)
fmt.Printf("Has summary: %v\n", stats.HasSummary)
fmt.Printf("Active tokens: %d\n", stats.ActiveTokens)

Get Conversation Summary

summary, _ := mem.GetSummary(ctx, "session-123")
fmt.Printf("Summary: %s\n", summary.Content)
fmt.Printf("Covers %d messages\n", summary.MessageCount)

Cache Management (Hybrid Mode)

if hybridMem, ok := mem.(*memory.HybridMemory); ok {
    // Clear cache for session
    hybridMem.ClearCache(ctx, "session-123")
    
    // Get cache statistics
    stats, _ := hybridMem.GetCacheStats(ctx)
    fmt.Printf("Cache hit rate: %.1f%%\n", 
        float64(stats.Hits)/(stats.Hits+stats.Misses)*100)
}

Examples 📖

The repository includes 7 complete examples showing different configurations:

Example	Description	Dependencies	Difficulty
01-session-only	In-memory only, no persistence	None	⭐ Beginner
02-persistent-basic	PostgreSQL persistence	PostgreSQL	⭐⭐ Easy
03-hybrid-mode	Redis + PostgreSQL	Redis, PostgreSQL	⭐⭐⭐ Intermediate
04-semantic-search	Vector search with pgvector	PostgreSQL, OpenAI	⭐⭐⭐ Intermediate
05-auto-summarization	Automatic conversation summaries	PostgreSQL, OpenAI	⭐⭐⭐ Intermediate
06-event-streaming	Redis Streams for event sourcing	Redis	⭐⭐⭐⭐ Advanced
07-agent-integration	Complete AI agent with memory	All optional	⭐⭐⭐⭐ Advanced

Each example includes:

Complete runnable code
Detailed README with setup instructions
Performance benchmarks and usage patterns
Migration guides to more advanced configurations

Testing 🧪

# Run tests
go test ./...

# Run with race detection
go test -race ./...

# Run benchmarks
go test -bench=. ./...

Contributing 🤝

PRs welcome! Please ensure:

Tests pass
Code is formatted (go fmt)
No linting issues (golangci-lint run)

License 📄

MIT License - feel free to use in your projects!

Support 💬

Issues: GitHub Issues
Discussions: GitHub Discussions

Documentation ¶

Overview ¶

Package memory provides a modular conversation memory system for AI agents. It supports both short-term session memory (via Redis) and long-term semantic memory (via Supabase pgvector).

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type CacheStats ¶

type CacheStats struct {
	Hits         int64
	Misses       int64
	SessionCount int64
	MemoryUsage  int64
}

CacheStats represents cache statistics

type Config ¶

type Config struct {
	// Mode Selection
	Mode MemoryMode `json:"mode,omitempty"` // SESSION_ONLY, PERSISTENT, HYBRID

	// Feature Flags
	EnablePersistence    bool `json:"enable_persistence,omitempty"`
	EnableSemanticSearch bool `json:"enable_semantic_search,omitempty"`
	EnableAutoSummarize  bool `json:"enable_auto_summarize,omitempty"`

	// Database Configuration
	SupabaseURL string `json:"supabase_url,omitempty"`
	SupabaseKey string `json:"supabase_key,omitempty"`
	DatabaseURL string `json:"database_url,omitempty"` // Direct PostgreSQL connection

	// Redis Configuration (optional for fast session cache)
	RedisAddr     string `json:"redis_addr,omitempty"` // e.g., "localhost:6379"
	RedisPassword string `json:"redis_password,omitempty"`
	RedisDB       int    `json:"redis_db,omitempty"`

	// OpenAI Configuration (for embeddings)
	OpenAIKey      string `json:"openai_key,omitempty"`
	EmbeddingModel string `json:"embedding_model,omitempty"` // default: "text-embedding-3-small"

	// Memory Settings
	MaxSessionMessages int           `json:"max_session_messages,omitempty"` // default: 50
	SessionTTL         time.Duration `json:"session_ttl,omitempty"`          // default: 24h
	AutoSummarize      bool          `json:"auto_summarize,omitempty"`       // auto-summarize old messages
	VectorDimension    int           `json:"vector_dimension,omitempty"`     // default: 1536

	// Summarization Settings
	SummarizeThreshold int    `json:"summarize_threshold,omitempty"`  // Messages before summarization
	SummarizeMaxTokens int    `json:"summarize_max_tokens,omitempty"` // Target summary length
	SummarizeModel     string `json:"summarize_model,omitempty"`      // Model for summarization
	ArchiveOldMessages bool   `json:"archive_old_messages,omitempty"` // Keep originals

	// Search Settings
	DefaultSearchLimit     int     `json:"default_search_limit,omitempty"`
	DefaultSearchThreshold float32 `json:"default_search_threshold,omitempty"`
}

Config holds configuration for memory initialization

type HybridMemory ¶

type HybridMemory struct {
	// contains filtered or unexported fields
}

HybridMemory combines Redis for fast session memory and Supabase for semantic search

func (*HybridMemory) AddMessage ¶

func (hm *HybridMemory) AddMessage(ctx context.Context, msg Message) error

AddMessage adds a message to both Redis (for fast access) and Supabase (for persistence)

func (*HybridMemory) ClearCache ¶

func (hm *HybridMemory) ClearCache(ctx context.Context, sessionID string) error

ClearCache clears Redis cache for a specific session

func (*HybridMemory) ClearSession ¶

func (hm *HybridMemory) ClearSession(ctx context.Context, sessionID string) error

ClearSession clears messages from both Redis and Supabase

func (*HybridMemory) Close ¶

func (hm *HybridMemory) Close() error

Close closes all connections

func (*HybridMemory) GetCacheStats ¶

func (hm *HybridMemory) GetCacheStats(ctx context.Context) (*CacheStats, error)

GetCacheStats returns Redis cache statistics

func (*HybridMemory) GetRecentMessages ¶

func (hm *HybridMemory) GetRecentMessages(ctx context.Context, sessionID string, limit int) ([]Message, error)

GetRecentMessages retrieves recent messages from Redis first, falls back to Supabase

func (*HybridMemory) GetStats ¶

func (hm *HybridMemory) GetStats(ctx context.Context, sessionID string) (*Stats, error)

GetStats returns statistics about memory usage

func (*HybridMemory) GetSummary ¶

func (hm *HybridMemory) GetSummary(ctx context.Context, sessionID string) (*Summary, error)

GetSummary retrieves a summary for the session (delegates to Supabase)

func (*HybridMemory) Search ¶

func (hm *HybridMemory) Search(ctx context.Context, query string, limit int, threshold float32) ([]SearchResult, error)

Search performs semantic search (delegates to Supabase)

func (*HybridMemory) SearchWithEmbedding ¶

func (hm *HybridMemory) SearchWithEmbedding(ctx context.Context, embedding []float32, limit int, threshold float32) ([]SearchResult, error)

SearchWithEmbedding searches using a pre-computed embedding (delegates to Supabase)

func (*HybridMemory) Store ¶

func (hm *HybridMemory) Store(ctx context.Context, msg Message) error

Store saves a message for long-term memory (delegates to Supabase)

func (*HybridMemory) Summarize ¶

func (hm *HybridMemory) Summarize(ctx context.Context, sessionID string, maxTokens int) (string, error)

Summarize creates a summary of session messages

type Memory ¶

type Memory interface {
	// Session Memory (fast, recent messages)
	AddMessage(ctx context.Context, msg Message) error
	GetRecentMessages(ctx context.Context, sessionID string, limit int) ([]Message, error)
	ClearSession(ctx context.Context, sessionID string) error

	// Semantic Memory (long-term, searchable)
	Store(ctx context.Context, msg Message) error
	Search(ctx context.Context, query string, limit int, threshold float32) ([]SearchResult, error)
	SearchWithEmbedding(ctx context.Context, embedding []float32, limit int, threshold float32) ([]SearchResult, error)

	// Management
	Summarize(ctx context.Context, sessionID string, maxTokens int) (string, error)
	GetSummary(ctx context.Context, sessionID string) (*Summary, error)
	GetStats(ctx context.Context, sessionID string) (*Stats, error)
	Close() error
}

Memory interface defines the contract for memory implementations

func New ¶

func New(cfg Config) (Memory, error)

New creates a new memory instance based on configuration (legacy)

func NewHybridMemory ¶

func NewHybridMemory(cfg Config) (Memory, error)

NewHybridMemory creates a memory system with both Redis and Supabase

func NewSessionOnlyMemory ¶

func NewSessionOnlyMemory(cfg Config) (Memory, error)

NewSessionOnlyMemory creates a new session-only memory instance

func NewSupabaseMemory ¶

func NewSupabaseMemory(cfg Config) (Memory, error)

NewSupabaseMemory creates a new Supabase-based memory instance

func NewWithConfig ¶

func NewWithConfig(cfg Config) (Memory, error)

NewWithConfig creates a new memory instance with explicit configuration

type MemoryMode ¶

type MemoryMode string

MemoryMode represents the type of memory implementation

const (
	SESSION_ONLY MemoryMode = "session_only" // In-memory only, no persistence
	PERSISTENT   MemoryMode = "persistent"   // PostgreSQL only
	HYBRID       MemoryMode = "hybrid"       // Redis + PostgreSQL
)

Memory mode constants

type Message ¶

type Message struct {
	ID        string    `json:"id"`
	Role      string    `json:"role"` // "user", "assistant", "system"
	Content   string    `json:"content"`
	Metadata  Metadata  `json:"metadata"`
	Timestamp time.Time `json:"timestamp"`
	Embedding []float32 `json:"embedding,omitempty"`
}

Message represents a single conversation message

type Metadata ¶

type Metadata struct {
	SessionID   string                 `json:"session_id"`
	UserID      string                 `json:"user_id,omitempty"`
	TokenCount  int                    `json:"token_count,omitempty"`
	Model       string                 `json:"model,omitempty"`
	Temperature float64                `json:"temperature,omitempty"`
	Extra       map[string]interface{} `json:"extra,omitempty"`
}

Metadata contains additional message information

type SearchResult ¶

type SearchResult struct {
	Message  Message `json:"message"`
	Score    float32 `json:"score"`
	Distance float32 `json:"distance"`
}

SearchResult represents a semantic search result

type SessionOnlyMemory ¶

type SessionOnlyMemory struct {
	// contains filtered or unexported fields
}

SessionOnlyMemory implements in-memory session storage with no persistence

func (*SessionOnlyMemory) AddMessage ¶

func (sm *SessionOnlyMemory) AddMessage(ctx context.Context, msg Message) error

AddMessage adds a message to the session

func (*SessionOnlyMemory) ClearSession ¶

func (sm *SessionOnlyMemory) ClearSession(ctx context.Context, sessionID string) error

ClearSession removes all messages from a session

func (*SessionOnlyMemory) Close ¶

func (sm *SessionOnlyMemory) Close() error

Close cleans up resources (no-op for session-only)

func (*SessionOnlyMemory) GetRecentMessages ¶

func (sm *SessionOnlyMemory) GetRecentMessages(ctx context.Context, sessionID string, limit int) ([]Message, error)

GetRecentMessages retrieves recent messages from the session

func (*SessionOnlyMemory) GetStats ¶

func (sm *SessionOnlyMemory) GetStats(ctx context.Context, sessionID string) (*Stats, error)

GetStats returns session statistics

func (*SessionOnlyMemory) GetSummary ¶

func (sm *SessionOnlyMemory) GetSummary(ctx context.Context, sessionID string) (*Summary, error)

GetSummary returns a basic summary structure

func (*SessionOnlyMemory) Search ¶

func (sm *SessionOnlyMemory) Search(ctx context.Context, query string, limit int, threshold float32) ([]SearchResult, error)

Search performs basic text search (no semantic search in session-only mode)

func (*SessionOnlyMemory) SearchWithEmbedding ¶

func (sm *SessionOnlyMemory) SearchWithEmbedding(ctx context.Context, embedding []float32, limit int, threshold float32) ([]SearchResult, error)

SearchWithEmbedding is not supported in session-only mode

func (*SessionOnlyMemory) Store ¶

func (sm *SessionOnlyMemory) Store(ctx context.Context, msg Message) error

Store is a no-op for session-only memory (same as AddMessage)

func (*SessionOnlyMemory) Summarize ¶

func (sm *SessionOnlyMemory) Summarize(ctx context.Context, sessionID string, maxTokens int) (string, error)

Summarize creates a simple summary (no LLM in session-only mode)

type Stats ¶

type Stats struct {
	SessionID       string     `json:"session_id"`
	TotalMessages   int        `json:"total_messages"`
	SessionMessages int        `json:"session_messages"`
	TotalTokens     int        `json:"total_tokens"`
	ActiveTokens    int        `json:"active_tokens,omitempty"` // Tokens after summarization
	OldestMessage   *time.Time `json:"oldest_message,omitempty"`
	LatestMessage   *time.Time `json:"latest_message,omitempty"`
	UniqueUsers     int        `json:"unique_users,omitempty"`
	StorageSize     int64      `json:"storage_size,omitempty"`
	HasSummary      bool       `json:"has_summary,omitempty"` // Whether session has summary
}

Stats provides memory usage statistics

type Summary ¶

type Summary struct {
	SessionID    string    `json:"session_id"`
	Content      string    `json:"content"`
	TokenCount   int       `json:"token_count"`
	MessageCount int       `json:"message_count"`
	StartTime    time.Time `json:"start_time"`
	EndTime      time.Time `json:"end_time"`
	Created      time.Time `json:"created"`
}

Summary represents a conversation summary

type SupabaseMemory ¶

type SupabaseMemory struct {
	// contains filtered or unexported fields
}

SupabaseMemory implements Memory using Supabase PostgreSQL with pgvector

func (*SupabaseMemory) AddMessage ¶

func (sm *SupabaseMemory) AddMessage(ctx context.Context, msg Message) error

AddMessage adds a message to session memory

func (*SupabaseMemory) ClearSession ¶

func (sm *SupabaseMemory) ClearSession(ctx context.Context, sessionID string) error

ClearSession removes all messages for a session

func (*SupabaseMemory) Close ¶

func (sm *SupabaseMemory) Close() error

func (*SupabaseMemory) GetRecentMessages ¶

func (sm *SupabaseMemory) GetRecentMessages(ctx context.Context, sessionID string, limit int) ([]Message, error)

GetRecentMessages retrieves recent messages for a session

func (*SupabaseMemory) GetStats ¶

func (sm *SupabaseMemory) GetStats(ctx context.Context, sessionID string) (*Stats, error)

GetStats returns statistics about memory usage

func (*SupabaseMemory) GetSummary ¶

func (sm *SupabaseMemory) GetSummary(ctx context.Context, sessionID string) (*Summary, error)

Close closes database connections GetSummary retrieves a summary for the session

func (*SupabaseMemory) Search ¶

func (sm *SupabaseMemory) Search(ctx context.Context, query string, limit int, threshold float32) ([]SearchResult, error)

Search performs semantic search on messages

func (*SupabaseMemory) SearchWithEmbedding ¶

func (sm *SupabaseMemory) SearchWithEmbedding(ctx context.Context, embedding []float32, limit int, threshold float32) ([]SearchResult, error)

SearchWithEmbedding searches using a pre-computed embedding

func (*SupabaseMemory) Store ¶

func (sm *SupabaseMemory) Store(ctx context.Context, msg Message) error

Store saves a message for long-term semantic memory

func (*SupabaseMemory) Summarize ¶

func (sm *SupabaseMemory) Summarize(ctx context.Context, sessionID string, maxTokens int) (string, error)

Summarize creates a summary of a session's messages

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
examples
01-session-only command Session-Only Memory Example This example demonstrates the simplest memory configuration with no external dependencies.	Session-Only Memory Example This example demonstrates the simplest memory configuration with no external dependencies.
02-persistent-basic command Persistent Basic Memory Example Demonstrates database persistence with PostgreSQL for long-term memory storage.	Persistent Basic Memory Example Demonstrates database persistence with PostgreSQL for long-term memory storage.
03-hybrid-mode command Hybrid Mode Memory Example Combines Redis for fast session caching with PostgreSQL for persistence.	Hybrid Mode Memory Example Combines Redis for fast session caching with PostgreSQL for persistence.
04-semantic-search command Semantic Search Memory Example Demonstrates vector embeddings and similarity search using OpenAI and pgvector.	Semantic Search Memory Example Demonstrates vector embeddings and similarity search using OpenAI and pgvector.
05-auto-summarization command Auto-Summarization Memory Example Demonstrates automatic conversation compression to optimize token usage.	Auto-Summarization Memory Example Demonstrates automatic conversation compression to optimize token usage.
06-event-streaming command Event Streaming Memory Example Demonstrates Redis Streams for event sourcing and audit trails.	Event Streaming Memory Example Demonstrates Redis Streams for event sourcing and audit trails.
07-agent-integration command Complete Agent Integration Example Production-ready AI agent with configurable memory system.	Complete Agent Integration Example Production-ready AI agent with configurable memory system.

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL