Ollama runs AI models locally. But its interface is a terminal — fine for developers, not great for teams, clients, or students. Open WebUI gives you a ChatGPT-like web interface that anyone can use from their browser.

This guide covers installation, multi-user setup, system prompts, security, and everything you need to run Open WebUI for a team or school.

What Open WebUI Gives You

• ChatGPT-like interface — familiar chat UI in the browser
• Multi-user support — individual accounts with conversation history
• System prompts — control what the AI can and can’t do
• Model switching — users can switch between installed models
• Conversation history — saved per user, searchable
• Admin panel — manage users, models, and settings
• No internet required — runs entirely on your network

Prerequisites

• Ollama installed and running with at least one model
• Docker installed (recommended) or Python 3.11+
• A machine with enough RAM for your model (8GB minimum)

Installation

Option 1: Docker (Recommended)

# Basic install — Ollama on same machine
docker run -d \
  --name open-webui \
  --restart always \
  -p 3000:8080 \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  ghcr.io/open-webui/open-webui:main

Access at http://localhost:3000. The first user to sign up becomes the admin.

Option 2: Ollama on a Different Machine

If Ollama runs on a separate server:

docker run -d \
  --name open-webui \
  --restart always \
  -p 3000:8080 \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://192.168.1.100:11434 \
  ghcr.io/open-webui/open-webui:main

Replace 192.168.1.100 with your Ollama server’s IP. Make sure Ollama is configured to accept remote connections:

# On the Ollama server
OLLAMA_HOST=0.0.0.0 ollama serve

Option 3: With GPU Support

docker run -d \
  --name open-webui \
  --restart always \
  --gpus all \
  -p 3000:8080 \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  ghcr.io/open-webui/open-webui:main

Option 4: Without Docker (Python)

pip install open-webui
open-webui serve --port 3000

Less isolated than Docker but simpler if you don’t want containers.

First-Time Setup

1. Create Admin Account

Open http://localhost:3000 and create the first account. This becomes the admin. Choose a strong password — this account controls everything.

2. Configure Models

Go to Admin → Settings → Models. Open WebUI auto-detects models from Ollama. You should see every model you’ve pulled. You can:

• Set a default model for new conversations
• Hide models you don’t want users to access
• Set per-model system prompts

3. Set Up User Registration

Go to Admin → Settings → General:

• Open registration — anyone can create an account (good for internal teams)
• Admin approval required — users sign up but need admin approval (good for schools)
• Disabled — only admin can create accounts (most secure)

For schools: use admin approval. For company teams: open registration is usually fine if it’s only accessible on your internal network.

System Prompts

System prompts control the AI’s behavior. Set them at the model level (applies to everyone) or let users set their own.

For a Business Team

You are a professional AI assistant for [company name]. 
You help with writing, analysis, brainstorming, and research.

Guidelines:
- Be concise and direct
- Use professional language
- If you're not sure about something, say so
- Don't make up statistics or data
- Respect confidentiality — never reference other users' conversations

For a School (Elementary)

You are a friendly learning helper for [school name] students.

Rules:
- Explain things simply, like you're talking to a 10-year-old
- Never give direct answers to homework. Ask guiding questions instead.
- If a student asks something inappropriate, say "Let's focus on 
  your schoolwork! What subject are you working on?"
- Never pretend to be a real person
- Always encourage students to check with their teacher
- Use encouraging language

For a School (High School)

You are an educational assistant for [school name].

Rules:
- Help students understand concepts, don't do their work for them
- For essays: give feedback and suggestions, don't write it for them
- For math: show the approach, let them do the calculation
- For research: help them find angles and structure arguments
- No inappropriate content
- If unsure about something, say so and suggest they verify with their teacher
- You can discuss complex topics (history, science, ethics) at an 
  age-appropriate level

For Customer Support

You are a customer support assistant for [company].

Our products: [list products]
Our policies: [key policies — returns, refunds, SLA]
Our tone: [friendly, professional, empathetic]

Rules:
- Answer questions about our products and policies
- If you don't know the answer, say "I'll need to check with the team 
  on that. Can I get back to you?"
- Never make promises about pricing, timelines, or features
- Escalate complaints to a human: "Let me connect you with someone 
  who can help with this directly."

Multi-User Management

Creating Users

Admin → Users → Add User

For teams: create accounts manually or enable self-registration.

For schools: bulk create accounts using class codes (e.g., student-math-101-01 through student-math-101-30). This avoids collecting student emails.

User Roles

Role	Can chat	Can change settings	Can manage users	Can see all conversations
User	✅	Own settings only	❌	❌
Admin	✅	✅	✅	✅

Monitoring Conversations

Admins can view all conversations in Admin → Conversations. Use this for:

• Schools: Monitor student usage, identify struggling students, catch misuse
• Teams: Review how the AI is being used, identify common tasks for prompt templates
• Support: Quality check AI responses before they go to customers

Performance Tuning

For Small Teams (5-10 users)

Default settings work fine. A machine with 16GB RAM and llama3:8b handles 5-10 concurrent users without issues.

For Larger Groups (20+ users)

# Run with resource limits
docker run -d \
  --name open-webui \
  --restart always \
  -p 3000:8080 \
  --memory=4g \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  -e OLLAMA_NUM_PARALLEL=4 \
  ghcr.io/open-webui/open-webui:main

On the Ollama side, set parallel request handling:

OLLAMA_NUM_PARALLEL=4 ollama serve

This lets Ollama process 4 requests simultaneously. Increase based on your RAM:

• 16GB RAM: OLLAMA_NUM_PARALLEL=2
• 32GB RAM: OLLAMA_NUM_PARALLEL=4
• 64GB RAM: OLLAMA_NUM_PARALLEL=8

If It’s Still Slow

• Use a smaller model (llama3:8b instead of qwen2.5:14b)
• Add a GPU — even a used RTX 3060 dramatically improves throughput
• Set a max response length in the model settings to prevent long-running generations
• Queue requests rather than rejecting them (Open WebUI handles this automatically)

Security Configuration

Network Access

Only expose Open WebUI on your internal network:

# Bind to internal IP only (not 0.0.0.0)
docker run -d \
  --name open-webui \
  -p 192.168.1.50:3000:8080 \
  ...

Or use a firewall:

# Linux: only allow internal network
sudo iptables -A INPUT -p tcp --dport 3000 -s 192.168.1.0/24 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 3000 -j DROP

HTTPS (Recommended for Production)

Put a reverse proxy in front of Open WebUI:

# Nginx config
server {
    listen 443 ssl;
    server_name ai.internal.company.com;
    
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;
    
    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Data Backup

# Backup Open WebUI data
docker cp open-webui:/app/backend/data ./backup-$(date +%Y%m%d)

# Or backup the Docker volume
docker run --rm -v open-webui:/data -v $(pwd):/backup \
  alpine tar czf /backup/open-webui-backup.tar.gz /data

Schedule this weekly with cron.

Data Retention

For schools (FERPA compliance) or regulated industries:

• Set conversation auto-delete after your retention period
• Export logs before deletion if needed for compliance
• Document your retention policy

Updating

# Pull latest image
docker pull ghcr.io/open-webui/open-webui:main

# Restart with new image
docker stop open-webui
docker rm open-webui

# Re-run with same settings (data persists in the volume)
docker run -d \
  --name open-webui \
  --restart always \
  -p 3000:8080 \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  ghcr.io/open-webui/open-webui:main

Your data, users, and conversations are preserved in the Docker volume.

Troubleshooting

“Can’t connect to Ollama”

• Check Ollama is running: ollama ps
• If Ollama is on a different machine, make sure it’s listening on 0.0.0.0: OLLAMA_HOST=0.0.0.0 ollama serve
• Check the OLLAMA_BASE_URL environment variable matches your setup
• On macOS with Docker Desktop, use http://host.docker.internal:11434

“No models showing up”

• Pull at least one model: ollama pull llama3:8b
• Refresh the Open WebUI models page
• Check the Ollama connection in Admin → Settings → Connections

“Slow responses with multiple users”

• Check RAM usage — if the system is swapping, responses will be very slow
• Reduce OLLAMA_NUM_PARALLEL if you’re running out of memory
• Use a smaller model for multi-user scenarios
• Consider adding a GPU

“Users can’t access the interface”

• Check firewall rules allow traffic on port 3000
• Verify the Docker container is running: docker ps
• Check the bind address — 0.0.0.0:3000 for all interfaces, 192.168.x.x:3000 for specific interface

Related resources

• Ollama vs llama.cpp vs vLLM — Which Should You Use?
• How to Sandbox Local AI Models
• Best Local AI Models by Task
• Local AI vs ChatGPT — Quality Comparison
• Docker cheat sheet

Setting up AI for a business or school? See How to Set Up AI for Free — A Guide for Every Profession and Local AI for Schools.