> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/open-webui/open-webui/llms.txt
> Use this file to discover all available pages before exploring further.

# Memories

> Enable long-term memory storage for personalized AI interactions

Memories in Open WebUI provide long-term storage for important information, preferences, and context. This enables your AI models to remember details across conversations and provide more personalized, context-aware responses.

## Overview

Memories provide:

* Persistent user-specific storage
* Vector-based semantic search
* Automatic embedding generation
* Context retrieval for conversations
* Privacy-focused per-user isolation

<Note>
  Memories must be explicitly enabled in your Open WebUI configuration. They require a vector database and embedding function to be configured.
</Note>

## Architecture

Memories use a two-tier storage system:

1. **Database**: Stores the actual memory content and metadata
2. **Vector Store**: Stores embeddings for semantic search

When you query memories, the system:

1. Generates an embedding of your query
2. Searches the vector database for similar memories
3. Returns the most relevant memories

## Configuration

Enable memories in your environment:

```bash theme={null}
# Enable memories feature
ENABLE_MEMORIES=true

# Vector database (required)
VECTOR_DB=chroma  # or qdrant, milvus, etc.

# Embedding function (required)
EMBEDDING_FUNCTION=sentence-transformers
EMBEDDING_MODEL=all-MiniLM-L6-v2
```

<Warning>
  Memories require a configured vector database and embedding function. Without these, the feature will not work.
</Warning>

## Managing Memories

### Add Memory

Store a new memory:

```python theme={null}
import requests

url = "http://localhost:8080/api/memories/add"
payload = {
    "content": "The user prefers Python for backend development and React for frontend."
}

response = requests.post(url, json=payload)
memory = response.json()

print(f"Memory ID: {memory['id']}")
print(f"Content: {memory['content']}")
print(f"Created: {memory['created_at']}")
```

### List All Memories

Retrieve all memories for the current user:

```python theme={null}
import requests

response = requests.get("http://localhost:8080/api/memories/")
memories = response.json()

for memory in memories:
    print(f"[{memory['created_at']}] {memory['content']}")
```

### Query Memories

Search for relevant memories using semantic search:

```python theme={null}
import requests

url = "http://localhost:8080/api/memories/query"
payload = {
    "content": "What programming languages does the user like?",
    "k": 3  # Return top 3 most relevant memories
}

response = requests.post(url, json=payload)
results = response.json()

for result in results:
    print(f"Score: {result.get('score', 'N/A')}")
    print(f"Memory: {result['text']}")
    print("---")
```

### Update Memory

Modify an existing memory:

```python theme={null}
import requests

memory_id = "memory-uuid-here"
url = f"http://localhost:8080/api/memories/{memory_id}/update"
payload = {
    "content": "The user prefers Python and TypeScript for development."
}

response = requests.post(url, json=payload)
updated_memory = response.json()
```

### Delete Memory

Remove a specific memory:

```python theme={null}
import requests

memory_id = "memory-uuid-here"
response = requests.delete(f"http://localhost:8080/api/memories/{memory_id}")

if response.json():
    print("Memory deleted successfully")
```

### Delete All Memories

Clear all memories for the current user:

```python theme={null}
import requests

response = requests.delete("http://localhost:8080/api/memories/delete/user")

if response.json():
    print("All memories deleted")
```

### Reset Memory Embeddings

Regenerate all embeddings (useful after changing embedding models):

```python theme={null}
import requests

response = requests.post("http://localhost:8080/api/memories/reset")

if response.json():
    print("Memory embeddings regenerated")
```

<Warning>
  The reset operation regenerates embeddings for **all** user memories. This can take time if you have many memories.
</Warning>

## Memory Workflow

<Steps>
  <Step title="User Interaction">
    User shares information during a conversation:

    * "I prefer dark mode"
    * "My timezone is EST"
    * "I work with Python and JavaScript"
  </Step>

  <Step title="Memory Creation">
    Important information is stored as memories:

    ```python theme={null}
    memories = [
        "User prefers dark mode interface",
        "User timezone: EST (UTC-5)",
        "User works with Python and JavaScript"
    ]

    for content in memories:
        requests.post(
            "http://localhost:8080/api/memories/add",
            json={"content": content}
        )
    ```
  </Step>

  <Step title="Embedding Generation">
    System automatically generates embeddings and stores them in the vector database
  </Step>

  <Step title="Context Retrieval">
    When user asks a question, relevant memories are retrieved:

    ```python theme={null}
    response = requests.post(
        "http://localhost:8080/api/memories/query",
        json={
            "content": "What theme should I use?",
            "k": 1
        }
    )
    # Returns: "User prefers dark mode interface"
    ```
  </Step>

  <Step title="Personalized Response">
    AI uses retrieved memories to provide personalized answers
  </Step>
</Steps>

## Use Cases

### User Preferences

Store user preferences for personalized experiences:

```python theme={null}
import requests

preferences = [
    "User prefers concise responses",
    "User wants code examples in Python",
    "User is interested in machine learning",
    "User works in healthcare industry"
]

for pref in preferences:
    requests.post(
        "http://localhost:8080/api/memories/add",
        json={"content": pref}
    )
```

### Project Context

Remember ongoing project details:

```python theme={null}
project_info = [
    "Current project: Building a REST API for inventory management",
    "Tech stack: FastAPI, PostgreSQL, Docker",
    "Deployment target: AWS ECS",
    "Team size: 3 developers"
]

for info in project_info:
    requests.post(
        "http://localhost:8080/api/memories/add",
        json={"content": info}
    )
```

### Learning Progress

Track learning journey and achievements:

```python theme={null}
learning_memories = [
    "Completed Python basics course on 2024-01-15",
    "Struggling with async/await concepts",
    "Built first REST API successfully",
    "Next goal: Learn Docker containerization"
]

for memory in learning_memories:
    requests.post(
        "http://localhost:8080/api/memories/add",
        json={"content": memory}
    )
```

## Vector Database Integration

Memories are stored in user-specific collections:

```python theme={null}
# Collection naming pattern
collection_name = f"user-memory-{user_id}"

# Example: user-memory-123e4567-e89b-12d3-a456-426614174000
```

Supported vector databases:

* ChromaDB (default)
* Qdrant
* Milvus
* Elasticsearch
* OpenSearch
* Pinecone
* PGVector
* S3Vector
* Oracle 23ai

## Privacy and Security

<Note>
  Memories are **user-isolated**. Each user has their own private memory collection that other users cannot access.
</Note>

### Best Practices

1. **Sensitive Data**: Avoid storing passwords or API keys in memories
2. **PII**: Be cautious with personally identifiable information
3. **Retention**: Implement a memory lifecycle policy
4. **Encryption**: Use encrypted vector databases for production
5. **Access Control**: Ensure memories feature is permission-gated

## Performance Considerations

### Embedding Generation

Embeddings are generated asynchronously to avoid blocking:

```python theme={null}
# Adding memory doesn't block on embedding generation
vector = await EMBEDDING_FUNCTION(memory.content, user=user)
```

### Bulk Operations

When adding many memories, consider batching:

```python theme={null}
import requests
import asyncio

async def add_memories_bulk(memories):
    tasks = []
    for content in memories:
        task = requests.post(
            "http://localhost:8080/api/memories/add",
            json={"content": content}
        )
        tasks.append(task)
    
    return await asyncio.gather(*tasks)
```

### Vector Search Optimization

Adjust `k` parameter based on your needs:

```python theme={null}
# Fewer results = faster search
response = requests.post(
    "http://localhost:8080/api/memories/query",
    json={"content": "query", "k": 3}
)

# More results = better context
response = requests.post(
    "http://localhost:8080/api/memories/query",
    json={"content": "query", "k": 10}
)
```

## Integration Example

### Memory-Augmented Chat

```python theme={null}
import requests

def chat_with_memory(user_message):
    # 1. Query relevant memories
    memory_response = requests.post(
        "http://localhost:8080/api/memories/query",
        json={"content": user_message, "k": 3}
    )
    relevant_memories = memory_response.json()
    
    # 2. Build context from memories
    context = "\n".join([
        f"- {mem['text']}" for mem in relevant_memories
    ])
    
    # 3. Send to chat with context
    system_prompt = f"""
    You have access to the following memories about the user:
    {context}
    
    Use this information to provide personalized responses.
    """
    
    # Send to chat API with enhanced context
    chat_response = requests.post(
        "http://localhost:8080/api/chat",
        json={
            "messages": [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_message}
            ]
        }
    )
    
    return chat_response.json()
```

## Troubleshooting

### Memories Not Saving

* Verify `ENABLE_MEMORIES=true` in configuration
* Check vector database is running and accessible
* Ensure embedding function is configured
* Review user permissions for `features.memories`

### Search Returns No Results

* Confirm memories exist for the user
* Try broader search queries
* Check embedding model compatibility
* Verify vector database collection exists

### Slow Performance

* Reduce `k` parameter in queries
* Consider faster embedding models
* Optimize vector database configuration
* Use local embedding models instead of API calls

## Next Steps

* Learn about [Artifacts](/advanced/artifacts) for persistent storage
* Explore [Skills](/advanced/skills) for reusable capabilities
* Configure [Functions](/advanced/functions) for custom logic