How to Enable and Use Memory in Open WebUI

Open WebUI's memory feature lets conversations remember context across sessions, just like ChatGPT does. But memory requires active setup at three levels: admin, user, and model. Most users skip one step and wonder why their AI suddenly forgets everything. Here's the complete setup walkthrough.

What Is Memory in Open WebUI and Why Use It?

Memory in Open WebUI stores conversation context in a vector database so your AI assistant recalls previous interactions. Think of it like giving your model a persistent notepad: when you start a new conversation, the AI can reference facts you've shared before.

Why enable it? Without memory, every conversation starts fresh. Your AI doesn't know you prefer JSON outputs, that your business uses ISO date formats, or that you've already explained your company's tech stack three times. Memory fixes this friction.

Open WebUI offers two memory modes. Manual mode requires you to explicitly tell the AI to save facts. Automatic mode watches your conversation and extracts memories without prompt engineering.

Unlike ChatGPT, Open WebUI memory lives in your own database--no monthly fee, no external vendor access. This matters for teams handling confidential data or working offline.

There's a catch though: memory quality depends entirely on which model you use. Frontier models (GPT-4 Turbo, Claude 3.5) extract memories with near-perfect accuracy. Smaller open-source models (7B parameter range) struggle. They forget to save things or hallucinate memories that never existed.

How Open WebUI Memory Works: Manual vs. Automatic

Open WebUI memory has two execution paths, and understanding the difference saves hours of debugging.

Manual Memory (Settings Tab)

You navigate to Settings > Memory and explicitly save or load memories. Think of it like note-taking. You write "The customer prefers daily reports at 9 AM ET" and hit Save. In the next conversation, you load that memory by clicking it or mentioning it in your prompt.

Manual is reliable because you control what gets stored. It works with any model. But it requires discipline and wastes conversation tokens on housekeeping.

Automatic Memory (Native Tool Calling)

Automatic memory lets the model act as its own note-taker. During a conversation, the AI can invoke memory functions without you asking: it extracts facts, saves them, and retrieves them as needed.

This is faster and requires zero user intervention. But it only works if your model supports function calling (tool use). You must enable "Native Tool Calling" in the model config, and your model must be capable enough to decide when to save versus skip.

Frontier models nail this. Mistral 7B sometimes works. Llama 2 7B and smaller models rarely do--they either save everything (bloating context) or miss important facts.

There's also a third-party automatic mode: nokodo and other community filters. These scripts watch your conversations and extract memories using external LLMs (like GPT-4) in the background. They're more reliable than model-native tool calling but add latency and cost.

For a small team on a budget, start with manual mode. Once you understand the workflow, try automatic with a frontier model.

Step 1: Admin Enablement (Enable MEMORIES Globally)

Before any user can save memories, you must enable the feature at the admin level.

Option A: Environment Variable (Recommended for Self-Hosted)

If you're running Open WebUI in Docker or on bare metal, add this to your .env file:

ENABLE_MEMORIES=true

Then restart Open WebUI:

docker restart open-webui

Or if you're running it natively, just restart the process.

Option B: Admin Panel

1. Log in as an admin
2. Navigate to Settings > Admin Panel (top-right menu)
3. Find the "Memories" toggle under Features or Experimental Features
4. Enable it
5. The UI may ask you to set a vector database path (default is usually fine)

Granular Permissions (Critical for Multi-User Teams)

Once enabled globally, you control who can use memory:

1. Go to Admin Panel > Users
2. For each user, check "Allow Memory Access"
3. You can also set global memory limits: "Each user can save up to X memories" or "Memories expire after Y days"

If you skip this step, all users will see each other's memories by default--a privacy disaster.

Verify It Worked

Log out of the admin account. Log in as a regular user. Navigate to Settings > Memory. If you see a Memory tab with an "Add Memory" button, step 1 is complete.

Step 2: User Configuration (Enable Memory in Personalization)

Each user must opt into memory themselves. This prevents forced data storage and respects privacy.

Enable Memory in Your Personal Settings

1. Log in as your user account (not admin)
2. Click Settings (bottom of left sidebar)
3. Find Personalization or Memory Settings
4. Toggle "Enable Memories" to ON
5. Choose where memories show: in the Settings tab only, or in the chat UI as a sidebar

Create Your First Memory

You can preload memories before starting conversations:

1. Go to Settings > Memory
2. Click "Add Memory" or "New Memory"
3. Write a fact in the title: "Prefers CSV export"
4. Add context in the description: "Customer always asks for CSV, not JSON"
5. Save

Now start a chat. The AI can reference this memory if it supports tool calling. Or, in manual mode, you manually link the memory by typing "see my memory: Prefers CSV export" in your prompt.

Example Memories to Create

• Company info: "Acme Corp runs on PostgreSQL 14, 50 employees, in Austin TX"
• Personal preferences: "Prefers bullet points, hates markdown tables"
• Project context: "Q4 roadmap includes API redesign and auth migration"
• Rules: "Never suggest proprietary tools, only open-source alternatives"

Tips for Effective Memories

Keep them short and specific. "Remembers user prefers bullet points" beats "General preferences." Short memories load faster and the AI recalls them more reliably.

Test memory recall by asking questions in a new conversation. If the AI can't answer, the memory either wasn't saved or the model isn't trained to use it.

Step 3: Model Configuration (Activate Native Tool Calling)

This is where most setups fail. Memory only works automatically if your model supports function calling and you've explicitly enabled it.

Which Models Support Memory?

Frontier models (GPT-4 Turbo, Claude 3.5, Gemini Pro) reliably extract and recall memories. Open-source models that work include Mistral 7B Instruct (decent memory with occasional errors), Qwen 2.5 7B (good extraction, slower recall), and Llama 3.1 8B (acceptable memory, less reliable than Mistral).

Models that struggle include Llama 2 7B (memory rarely works), Phi 3 (tool calling is unreliable), and any model under 7B parameters. Don't expect memory to work with those.

Enable Tool Calling in Open WebUI

1. Go to Admin Panel > Model Management or Settings > Models
2. Find your model in the list
3. Click Edit or Configure
4. Look for "Function Calling," "Tool Use," or "Native Tools"
5. Toggle ON
6. Save

Test It

Start a conversation with a question that requires memory: "Create a task to remind me to email the design team." If the model invokes memory functions, you'll see a notification like "Memory saved: design team email" or a function call in the logs. If nothing happens, tool calling isn't working.

If Tool Calling Isn't Available

Some models list no tool calling option in the UI. This means the model itself doesn't support it, the model is served via an API that Open WebUI hasn't configured yet, or you're using an older Open WebUI version. In this case, fall back to manual memory mode or switch to a model that supports tools.

Use API Models Instead

If you're running Open WebUI but using OpenAI, Anthropic, or other API backends, go to Settings > Connections or Model Integrations, add your API key for GPT-4 or Claude, and memory will work out of the box. This costs more per message but is guaranteed to work.

Troubleshooting: Why Memory Stops Working (Blank Replies, Lost Memories)

Memory failures are common. Here are the patterns and fixes.

Symptom: Memory Saved, But AI Doesn't Recall It

Likely cause: The model doesn't support function calling. Check the Admin Panel > Model Details. If "Function Calling" is OFF or missing, enable it. If it stays missing, the model genuinely doesn't support it. Switch to a model like Mistral 7B or upgrade to a frontier model via API.

Symptom: Memory Tab Shows Saved Memories, But Conversations Have Blank Replies

Likely cause: The model is trying to use memory, failing silently, and producing incomplete output. This happens when the vector database is misconfigured, your context window is too small, or the model invokes memory, gets an error, and doesn't recover.

Check Admin Logs: Open WebUI Admin Panel > Logs or System Health and look for errors like "Failed to query memories" or "Vector DB timeout."

Restart the Vector DB:

docker restart milvus

Reduce Conversation Context: If the model's context is nearly full, memory retrieval fails. In Admin Panel > Model Settings, set Context Length to 2048 or 4096 and test memory again.

Symptom: "Memory Tool Not Found" Error in Logs

Likely cause: Memory feature isn't enabled globally. Run the setup from Step 1 again and restart Open WebUI after enabling ENABLE_MEMORIES=true.

Symptom: Multiple Users' Memories Visible to Each Other

Likely cause: Admin didn't configure memory permissions. Go to Admin Panel > Users and ensure each user has memory isolation enabled. This is a security issue--fix it immediately.

Symptom: Memory Works for 30 Minutes, Then Stops

Likely cause: The vector database filled up or crashed. Check your server's disk space with df -h. If the disk is full, clear old logs or increase disk space.

Privacy & Security for Teams

Memory stores sensitive data. A single memory about a client's financial projections or an employee's health issue can become a liability.

Memory is user-scoped--each Open WebUI user has their own memory space. User A cannot see User B's memories. However, admins can see all memories. If you have 3 admins and one leaves the company, their access isn't automatically revoked. They could log in and browse all team memories forever.

Governance Rules for Teams

1. Limit Memory to a Need-to-Know Basis: Not every user should save memories. If your team has 50 people but only 5 need memory for client context, disable it for the other 45. This reduces your exposure.

2. Set Memory Expiration: Configure memories to auto-delete after 30 or 90 days. Go to Admin Panel > Memory Settings and set "Expiration." Old memories are just cruft anyway.

3. Audit Trails: Check if Open WebUI logs who saved what memory and when. If your setup doesn't log memory operations, request this feature.

4. Encrypt Memories at Rest: If Open WebUI stores memories in a file or database on your server, ensure the filesystem or database is encrypted (LUKS, TDE, etc.).

5. GDPR and Data Subject Requests: If an employee or customer exercises GDPR rights, you must delete their memories within 30 days. Set up a process: Admin Panel > Users > [Person] > Delete All Memories, and log the deletion date.

6. Never Store PII in Memory: Don't save credit card numbers, SSNs, passwords, or API keys. If a memory must reference a secret, use a masked reference: "API key on file" instead of the key itself.

Example Privacy-Conscious Setup

Enable memory for customer success and product teams (need context). Disable for HR and finance (sensitive, not needed). Set expiration to 60 days. Audit memory access monthly. Train users to avoid PII.

Advanced: Auto-Memory Functions (Nokodo and Extraction Filters)

If manual memory feels tedious and your model's native tool calling is unreliable, consider auto-memory filters. These are scripts that monitor conversations and extract memories automatically using a separate LLM.

nokodo: Community-Maintained Auto-Memory

The nokodo project watches Open WebUI conversations and invokes memory functions through Open WebUI's API. It runs as a separate service.

How it works: You run nokodo in parallel with Open WebUI. nokodo polls your conversation history every 30 seconds. When it detects new messages, it sends them to GPT-4 or another frontier model with a prompt like "Extract key facts from this conversation." GPT-4 returns structured memories. nokodo saves them to Open WebUI.

Pros: Works with any model (doesn't require tool calling support). More reliable than small models trying to extract their own memories. You control exactly what gets extracted.

Cons: Adds latency (30-second delay before memories are saved). Costs money (every memory extraction hits an external LLM). Extra deployment complexity (another service to monitor).

Alternative: rollecode/open-webui-memory

On GitHub, rollecode maintains a simpler auto-memory filter (20 stars) that watches conversations and calls Open WebUI's memory API. It's lighter weight but less actively maintained.

Should You Use Auto-Memory?

Only if your self-hosted models don't support function calling, you're willing to pay per memory extraction, you need 100% reliable memory extraction, or your team is large enough that manual memory is too slow. For a solo user or small team, manual memory or native tool calling is simpler and cheaper.

Frequently Asked Questions

How do you enable memory in Open WebUI?

Memory requires three steps: (1) Admin enables it globally via ENABLE_MEMORIES=true or Admin Panel, (2) user turns it on in Personalization settings, (3) model has function calling enabled. Skip any step and memory fails.

What is the difference between manual and automatic memory?

Manual memory requires you to save facts explicitly via the Settings > Memory tab. Automatic memory lets the model invoke memory functions during conversation without your input. Automatic only works if your model supports function calling.

Why does memory stop working or show blank replies?

Blank replies usually mean the model tried to use memory, failed, and couldn't recover. Check: (a) is function calling enabled for this model? (b) is the vector database running? (c) is context length too short? Restart the vector DB service and test again.

Which models work best with memory?

Frontier models (GPT-4, Claude 3.5) are reliable. Mistral 7B and Qwen 2.5 7B work but are less consistent. Llama 2 7B and smaller models rarely work. Test before deploying to your team.

Is memory private in multi-user Open WebUI?

Each user's memories are scoped to their account--User A cannot see User B's memories. However, admins have access to all memories. Configure memory permissions in Admin Panel > Users to enforce isolation.

Can you automatically extract memories like ChatGPT?

Yes, via community projects like nokodo or rollecode/open-webui-memory. These run as side services and extract memories using GPT-4. They add latency and cost, so only use them if native tool calling doesn't work.

How much disk space do memories use?

Memories are typically tiny (100 bytes to 1 KB each). 10,000 memories might use 10-100 MB. On most setups, disk space isn't a constraint. Watch your vector database size if you have millions of memories.

The Bottom Line

Memory in Open WebUI transforms your AI assistant from a one-trick tool into a team resource that remembers context. But it's three separate configurations: admin global toggle, user personalization, and model function calling. If you skip one, memory silently fails and you're left wondering why your AI has amnesia.

Start with manual memory for a day. Once you understand the workflow, enable tool calling on a frontier model (or Mistral 7B). For teams, configure memory permissions and expiration immediately. The upside--no monthly ChatGPT bill, full data control--is worth the setup time.

When you're ready to stop managing infrastructure, Opsily's managed Open WebUI hosting handles deployment so you focus on memory configuration and team workflows.