Features¶

🧠 Conscious Ingestion System¶

AI-Powered Memory Management¶

Background Analysis: Automatic analysis of conversation patterns every 6 hours
Essential Memory Promotion: Key personal facts promoted for instant access
Smart Context Injection: 3-5 most relevant memories automatically included
Continuous Learning: System adapts to preferences and conversation patterns

Three-Layer Intelligence¶

graph TD
    A[Retrieval Agent] --> B[Selects Context]
    C[Conscious Agent] --> D[Promotes Essentials]
    E[Memory Agent] --> F[Processes Conversations]

    B --> G[Context Injection]
    D --> G
    F --> H[Structured Storage]

🗄️ Memory Types & Categories¶

Automatic Categorization¶

Category	Description	Examples
Facts	Objective information	"I use PostgreSQL for databases"
Preferences	Personal choices	"I prefer clean, readable code"
Skills	Abilities & expertise	"Experienced with FastAPI"
Context	Project information	"Working on e-commerce platform"
Rules	Guidelines & constraints	"Always write tests first"

Retention Policies¶

Short-term: Recent activities, temporary information (7 days)
Long-term: Important information, learned skills, preferences
Permanent: Critical rules, core preferences, essential facts

🔌 Universal Integration¶

Works with ANY LLM Library¶

LiteLLM (Recommended)OpenAIAnthropic

from litellm import completion
from memori import Memori

memori = Memori(conscious_ingest=True)
memori.enable()

# Automatic context injection
response = completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Help me code"}]
)

import openai
from memori import Memori

memori = Memori(conscious_ingest=True)
memori.enable()

client = openai.OpenAI()
# All conversations automatically recorded
response = client.chat.completions.create(...)

import anthropic
from memori import Memori

memori = Memori(conscious_ingest=True)
memori.enable()

client = anthropic.Anthropic()
# All conversations automatically recorded
response = client.messages.create(...)

🏗️ Production Architecture¶

Modular Design¶

memori/
├── core/              # Main Memori class, database manager
├── agents/            # AI-powered memory processing
├── database/          # Multi-database support
├── integrations/      # LLM provider integrations
├── config/            # Configuration management
├── utils/             # Helpers, validation, logging
└── tools/             # Memory search and retrieval

Database Support¶

SQLite: Perfect for development and small applications
PostgreSQL: Production-ready with full-text search
MySQL: Enterprise database support
Connection Pooling: Optimized performance with connection management

⚡ Performance Features¶

Token Optimization¶

Essential Memory Priority: Most important info always included
Smart Limits: Maximum 5 memories to prevent token overflow
Structured Outputs: Pydantic models reduce parsing overhead
Background Processing: Analysis doesn't block conversations

Efficiency Metrics¶

Traditional Context Injection:
❌ 2000+ tokens of conversation history

Conscious Ingestion:
✅ 200-500 tokens of essential + relevant facts

🛡️ Security & Reliability¶

Data Protection¶

Input Sanitization: Protection against injection attacks
Credential Safety: Secure handling of API keys and secrets
Error Context: Detailed logging without exposing sensitive data
Graceful Degradation: Continues operation when components fail

Production Ready¶

Connection Pooling: Automatic database connection management
Resource Cleanup: Proper cleanup of resources and connections
Error Handling: Comprehensive exception handling with context
Monitoring: Built-in logging and performance metrics

🎯 Developer Experience¶

Simple Setup¶

# One line to enable memory
memori = Memori(conscious_ingest=True)
memori.enable()

# No more repeating context!

Advanced Configuration¶

# Production configuration
memori = Memori(
    database_connect="postgresql://user:pass@localhost/memori",
    conscious_ingest=True,
    namespace="production_app",
    verbose=True
)

Memory Tools¶

from memori.tools import create_memory_tool

# Function calling integration
memory_tool = create_memory_tool(memori)
tools = [memory_tool]

completion(model="gpt-4", messages=[...], tools=tools)

📊 Memory Analytics¶

Real-time Statistics¶

# Get memory insights
stats = memori.get_memory_stats()
essential = memori.get_essential_conversations()

# Trigger manual analysis
memori.trigger_conscious_analysis()

# Search by category
skills = memori.search_memories_by_category("skill")

Debug Mode¶

# See what's happening behind the scenes
memori = Memori(
    conscious_ingest=True,
    verbose=True  # Shows agent activity
)

🚀 Extensibility¶

Custom Agents¶

Create specialized agents for specific domains
Extend memory processing capabilities
Custom categorization logic
Domain-specific entity extraction

Plugin Architecture¶

Memory processing plugins
Custom database adapters
Integration with external systems
Event-driven architecture

📈 Scalability¶

Enterprise Features¶

Multi-tenant Support: Separate memory spaces with namespaces
Horizontal Scaling: Distributed database support
Load Balancing: Multiple Memori instances
Monitoring: OpenTelemetry integration for observability

Performance Optimization¶

Indexed Search: Full-text search with proper indexing
Memory Compression: Intelligent consolidation over time
Adaptive Analysis: Dynamic frequency based on usage patterns
Caching: Smart caching for frequently accessed memories

🔄 Future Roadmap¶

Planned Features¶

Multi-model Support: Claude, Gemini structured outputs
Vector Search: Semantic similarity search
Memory Relationships: Understanding connections between facts
Team Memory: Shared memory spaces for collaborative AI
Memory Migration: Easy import/export of memory data