> ## Documentation Index
> Fetch the complete documentation index at: https://docs.praison.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Advanced Memory System
> Multi-tiered memory with quality scoring and graph support
# Advanced Memory System
The advanced memory system provides sophisticated memory management with short-term, long-term, entity, and user-specific storage, enhanced by quality scoring and optional graph database support.
```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph TB
subgraph Memory Tiers
STM[β‘ Short-term Memory]
LTM[πΎ Long-term Memory]
ENT[π€ Entity Memory]
USR[π User Memory]
end
subgraph Quality System
SCORE[π Quality Score]
COMP[β
Completeness]
REL[π― Relevance]
CLR[π‘ Clarity]
ACC[β Accuracy]
end
subgraph Storage Backends
RAG[(ποΈ RAG/ChromaDB)]
MEM0[(βοΈ Mem0)]
SQL[(ποΈ SQLite)]
GRAPH[(πΈοΈ Graph DB)]
end
STM --> SCORE
LTM --> SCORE
ENT --> SCORE
USR --> SCORE
SCORE --> COMP
SCORE --> REL
SCORE --> CLR
SCORE --> ACC
SCORE --> RAG
SCORE --> MEM0
SCORE --> SQL
MEM0 --> GRAPH
classDef memory fill:#8B0000,stroke:#7C90A0,color:#fff
classDef quality fill:#189AB4,stroke:#7C90A0,color:#fff
classDef storage fill:#2E8B57,stroke:#7C90A0,color:#fff
class STM,LTM,ENT,USR memory
class SCORE,COMP,REL,CLR,ACC quality
class RAG,MEM0,SQL,GRAPH storage
```
## Key Features
Separate short-term and long-term memory systems
4-metric quality assessment for stored memories
User, agent, and run-specific memory scoping
Automatic entity extraction and storage
Optional Neo4j/Memgraph for relationships
Quality-based filtering and relevance ranking
## Quick Start
```python Agent with Memory theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent, AgentTeam
# Single agent with memory (simplest)
agent = Agent(
name="Assistant",
instructions="You are a helpful assistant with memory.",
memory=True # Enable with defaults
)
# Agent with memory config
agent = Agent(
name="Assistant",
instructions="You are a helpful assistant with memory.",
memory={
"backend": "rag",
"user_id": "user123",
"use_embedding": True
}
)
# Multi-agent with shared memory
agents = AgentTeam(
agents=[agent1, agent2],
memory={
"backend": "rag",
"use_embedding": True
}
)
```
```python Direct Memory Use theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Memory
# Initialise memory
memory = Memory(
config={
"provider": "rag",
"use_embedding": True,
"short_db": ".praison/short_term.db",
"long_db": ".praison/long_term.db"
}
)
# Store memories with quality
memory.store_long_term(
text="The user prefers technical explanations",
memory={"user_id": "user123"},
metadata={"type": "preference"},
quality=0.9
)
# Search memories
results = memory.search_long_term(
query="user preferences",
memory={"user_id": "user123"},
min_quality=0.7
)
```
```python Quality Metrics theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Store with individual quality metrics
memory.store_long_term(
text="Quantum computing uses qubits for computation",
completeness=0.95, # How complete is the information
relevance=0.90, # How relevant to the context
clarity=0.88, # How clear is the explanation
accuracy=0.92, # How accurate is the content
memory={"user_id": "user123"}
)
# Quality score is automatically calculated
# Overall quality = weighted average of metrics
```
## Memory Tiers
### Short-term Memory (STM)
Short-term memory is cleared between sessions and used for immediate context.
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Store temporary context
memory.store_short_term(
text="User is asking about Python programming",
memory={"user_id": "user123"},
metadata={"context": "current_conversation"}
)
# Search recent context
context = memory.search_short_term(
query="Python",
memory={"user_id": "user123"},
limit=5
)
```
### Long-term Memory (LTM)
Long-term memory persists across sessions and stores important information.
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Store persistent knowledge
memory.store_long_term(
text="User works as a data scientist at TechCorp",
memory={"user_id": "user123"},
quality=0.95,
metadata={"type": "user_info", "category": "professional"}
)
# Retrieve with quality filter
memories = memory.search_long_term(
query="user profession",
memory={"user_id": "user123"},
min_quality=0.8
)
```
### Entity Memory
Entity memory stores information about specific people, places, or things.
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Store entity information
memory.store_entity(
name="TechCorp",
text="TechCorp is a leading AI company founded in 2020",
entity_type="organization",
metadata={"industry": "technology", "size": "large"}
)
# Search entity information
entity_info = memory.search_entity(
name="TechCorp",
query="company details"
)
```
### User Memory
User memory stores personalised information and preferences.
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Store user preferences
memory.store_user_memory(
memory={"user_id": "user123"},
text="Prefers concise explanations with code examples",
extra={"preference_type": "communication_style"}
)
# Retrieve user context
user_context = memory.search_user_memory(
memory={"user_id": "user123"},
query="preferences",
limit=3
)
```
## Configuration Options
### RAG Configuration (Default)
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
memory_config = {
"provider": "rag",
"use_embedding": True,
"short_db": ".praison/short_term.db",
"long_db": ".praison/long_term.db",
"entity_db": ".praison/entity.db",
"rag_db_path": ".praison/chroma_db",
"embedding_model": "text-embedding-3-small"
}
```
### Mem0 Configuration
> Requires the optional memory extras:
>
> ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
> pip install "praisonaiagents[memory]"
> ```
>
> If the package is missing, configuring `"provider": "mem0"` raises:
>
> ```
> ImportError: mem0ai is not installed. Run: pip install 'praisonaiagents[memory]'
> ```
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
memory_config = {
"provider": "mem0",
"config": {
"api_key": "your-mem0-api-key",
"org_id": "your-org-id",
"project_id": "your-project-id"
}
}
```
### Graph Memory Configuration
> Requires the optional memory extras:
>
> ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
> pip install "praisonaiagents[memory]"
> ```
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
memory_config = {
"provider": "mem0",
"config": {
"graph_store": {
"provider": "neo4j",
"config": {
"url": "bolt://localhost:7687",
"username": "neo4j",
"password": "password"
}
},
"vector_store": {
"provider": "qdrant",
"config": {
"host": "localhost",
"port": 6333
}
},
"version": "v1.1"
}
}
```
## Quality Scoring System
### Quality Metrics
Measures how complete and comprehensive the information is
Measures how relevant the information is to the context
Measures how clear and understandable the information is
Measures the factual accuracy of the information
### Quality Calculation
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Default weights
weights = {
"completeness": 0.25,
"relevance": 0.35,
"clarity": 0.20,
"accuracy": 0.20
}
# Overall quality = weighted average
quality = (
completeness * weights["completeness"] +
relevance * weights["relevance"] +
clarity * weights["clarity"] +
accuracy * weights["accuracy"]
)
```
## Advanced Features
### Context Building
Build comprehensive context for tasks:
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Automatically merge relevant memories
context = memory.build_context_for_task(
task_descr="Write a Python tutorial",
memory={"user_id": "user123"},
additional="Focus on data science applications",
max_items=5
)
# Context includes:
# - Relevant long-term memories
# - User preferences
# - Recent short-term context
```
### Task Output Finalisation
Store task results with quality assessment:
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents.agent.task import TaskOutput
# Create task output
output = TaskOutput(
raw="Tutorial content...",
agent_name="Writer",
task_description="Write Python tutorial"
)
# Finalise with quality scoring
memory.finalize_task_output(
task_output=output,
memory={"user_id": "user123"}
)
```
### Memory Citations
Automatically cite memory sources:
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Memories include source information
result = memory.search_long_term("Python", memory={"user_id": "user123"})
# Returns: {
# 'text': 'Python is...',
# 'metadata': {'source': 'conversation_2024_01_15', ...}
# }
```
### Memory Reranking
Enhance search results with intelligent reranking based on relevance scores:
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent, AgentTeam
# Create agent
agent = Agent(
name="Researcher",
role="Research assistant"
)
# Initialize with memory enabled
agents = AgentTeam(
agents=[agent],
tasks=[],
memory=True
)
# Search with reranking for better relevance
if agents.shared_memory:
results = agents.shared_memory.search_long_term(
"quantum computing applications",
limit=10,
rerank=True, # Enable reranking
relevance_cutoff=0.7 # Minimum relevance score
)
```
#### Reranking Features
1. **Semantic Reranking**: Re-scores results based on semantic similarity
2. **Context-Aware Ranking**: Considers current context when ranking
3. **Quality-Weighted Ranking**: Combines relevance with quality scores
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Advanced reranking with multiple criteria
results = agents.shared_memory.search_long_term(
query="machine learning frameworks",
limit=20, # Retrieve more initially
rerank=True, # Enable reranking
relevance_cutoff=0.6, # Minimum relevance
rerank_config={
"method": "semantic", # or "hybrid", "quality-weighted"
"top_k": 5, # Return top 5 after reranking
"consider_recency": True, # Factor in timestamp
"boost_user_memories": True # Prioritize user-specific memories
}
)
```
#### Custom Reranking Logic
Implement custom reranking strategies:
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from datetime import datetime
from praisonaiagents import RerankStrategy
class DomainSpecificReranker(RerankStrategy):
def rerank(self, results, query, context=None):
"""Custom reranking based on domain knowledge"""
scored_results = []
for result in results:
score = result['relevance']
# Boost technical content
if 'technical' in result.get('metadata', {}).get('tags', []):
score *= 1.2
# Boost recent memories
if result.get('timestamp'):
days_old = (datetime.now() - result['timestamp']).days
recency_boost = 1.0 + (0.1 * max(0, 30 - days_old) / 30)
score *= recency_boost
scored_results.append((score, result))
# Sort by score and return top results
scored_results.sort(key=lambda x: x[0], reverse=True)
return [result for score, result in scored_results]
# Use custom reranker
# Note: Assuming 'agents' is defined from previous examples
if agents.shared_memory:
agents.shared_memory.set_rerank_strategy(DomainSpecificReranker())
```
#### Reranking Performance
Optimize reranking for large result sets:
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Efficient two-stage retrieval and reranking
# Stage 1: Fast retrieval of candidates
candidates = agents.shared_memory.search_long_term(
query="data analysis techniques",
limit=50, # Get more candidates
rerank=False # Skip reranking in first stage
)
# Stage 2: Precise reranking of top candidates
if len(candidates) > 10:
reranked = agents.shared_memory.rerank_results(
results=candidates[:20], # Rerank top 20
query="data analysis techniques",
method="hybrid",
relevance_cutoff=0.8
)
else:
reranked = candidates
```
## Performance Optimisation
```python Batch Operations theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Batch store memories
memories = [
("Fact 1", 0.9),
("Fact 2", 0.85),
("Fact 3", 0.95)
]
for text, quality in memories:
memory.store_long_term(
text=text,
quality=quality,
memory={"user_id": "user123"}
)
```
```python Quality Filtering theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Pre-filter by quality to reduce results
high_quality = memory.search_long_term(
query="important facts",
min_quality=0.8, # Only high-quality memories
limit=10
)
```
```python Scoped Search theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Scope search to improve performance
results = memory.search_long_term(
query="project details",
memory={"user_id": "user123"},
agent_id="assistant",
run_id="session_456"
)
```
## Complete Example
```python Personal Assistant with Memory theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent, Task, AgentTeam
from praisonaiagents import Memory
# Configure memory with quality scoring
memory_config = {
"provider": "rag",
"use_embedding": True,
"embedding_model": "text-embedding-3-small"
}
# Create memory instance
memory = Memory(memory_config)
# Create assistant agent
assistant = Agent(
name="Personal Assistant",
instructions="""You are a personal assistant with perfect memory.
Remember user preferences, important information, and context.
Always use your memory to provide personalised responses.""",
memory={"user_id": "john_doe"} # Memory with user isolation
)
# Create task with memory integration
task = Task(
description="Help me plan my day based on my preferences",
agent=assistant,
expected_output="Personalised daily schedule"
)
# Run the system
agents = AgentTeam(
agents=[assistant],
tasks=[task],
memory=True # Enable shared memory
)
# Memory automatically:
# 1. Retrieves user preferences
# 2. Searches relevant past interactions
# 3. Builds context for the task
# 4. Stores the interaction with quality score
result = agents.start()
# Store user feedback as high-quality memory
memory.store_long_term(
text="User preferred morning schedule with exercise first",
memory={"user_id": "john_doe"},
completeness=0.9,
relevance=1.0,
clarity=0.95,
accuracy=1.0
)
```
## Best Practices
* Set minimum quality for critical information (0.8+)
* Use lower thresholds for exploratory searches
* Regular quality audits
* Periodically review and clean old memories
* Update quality scores as information ages
* Deduplicate similar memories
* Use user\_id for personalisation
* Use agent\_id for agent-specific knowledge
* Use run\_id for session isolation
* Enable embeddings for semantic search
* Use quality filters to reduce search space
* Implement caching for frequent queries
## AutoMemory
AutoMemory automatically extracts structured information from conversations using configurable patterns β no manual `store_*` calls needed.
### How It Works
AutoMemory wraps `FileMemory` with a pattern-based extraction engine. After each agent interaction, it scans the conversation for matching patterns (preferences, facts, dates, etc.) and stores them automatically.
### Quick Start
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent, MemoryConfig
# Enable auto-memory extraction
agent = Agent(
name="Assistant",
instructions="You are a helpful assistant.",
memory=MemoryConfig(auto_memory=True, user_id="user123")
)
# Patterns are extracted automatically from conversation
agent.start("I prefer Python for data science and I'm based in London")
# AutoMemory stores: preference="Python for data science", location="London"
```
### Custom Patterns
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents.memory.auto_memory import AutoMemory
# Create with custom patterns
auto_mem = AutoMemory(
user_id="user123",
patterns={
"preference": r"(?:I prefer|I like|I love)\s+(.+)",
"location": r"(?:I'm based in|I live in|I'm from)\s+(.+)",
"name": r"(?:My name is|I'm called|call me)\s+(\w+)",
"fact": r"(?:I work at|I study at|my job is)\s+(.+)",
}
)
# Search extracted memories
results = auto_mem.search("user preferences")
```
### MemoryConfig Integration
Use `MemoryConfig.auto_memory` to enable AutoMemory as part of the consolidated memory parameter:
```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent, MemoryConfig
agent = Agent(
instructions="You are a helpful assistant.",
memory=MemoryConfig(
backend="file",
auto_memory=True, # Enable pattern-based extraction
user_id="user123",
session_id="session456",
)
)
```
| Parameter | Type | Default | Description |
| ------------- | ------ | -------- | ------------------------------------------------- |
| `auto_memory` | `bool` | `False` | Enable automatic memory extraction |
| `backend` | `str` | `"file"` | Storage backend (`file`, `sqlite`, `redis`, etc.) |
| `user_id` | `str` | `None` | User ID for scoping memories |
## Next Steps
Integrate with document knowledge bases
Learn about stateful sessions