The practical way to run a private, browser-based ChatGPT-style service on a VPS is to separate the chat interface from the model runtime. Run Open WebUI in Docker for accounts, conversations, settings, and the browser experience; connect it to Ollama, vLLM, or a hosted OpenAI-compatible endpoint for inference. This design lets a modest CPU server host the interface while a GPU server, local workstation, or cloud API does the computationally expensive work.
Need a server to try this on? Antihost offers Linux VPS plans with NVMe storage, full root access and a 14-day free trial.
The deployment can be running in minutes, but a public service needs more than a successful container launch. Use a long random secret, persistent storage, HTTPS, authentication, backups, monitoring, and a plan for model licenses before allowing other people to sign in.
As an Amazon Associate I earn from qualifying purchases.
Recommended Free Tools
What you are actually deploying
A “ChatGPT clone” is not one program. It is a web application connected to a large-language-model inference service:
- Web interface: Open WebUI provides the browser chat, user accounts, conversation storage, model selection, and administration. It is self-hosted and can operate offline when the model is local.
- Inference backend: Ollama is the simplest local runtime. vLLM is intended for an OpenAI-compatible serving endpoint and higher concurrent throughput. A hosted endpoint is another option when your VPS should not download or execute models.
- Persistent data: The WebUI volume contains users, chats, and settings. The model runtime has a separate volume for downloaded model files.
- Network edge: A reverse proxy terminates HTTPS and forwards browser traffic to Open WebUI. The model API should remain on localhost or a private Docker network instead of being exposed to the internet.
Open WebUI’s provider architecture is deliberately separate from its interface. You can change the model backend without rebuilding the chat application, which is useful when a CPU deployment later moves to a GPU server or an API service.
#1 Best Overall
- 16,384 NVIDIA CUDA Cores
- Supports 4K 120Hz HDR, 8K 60Hz HDR and variable refresh rate as indicated in HDMI 2.1A
- New streaming multiprocessors: up to 2x power and power efficiency
- Fourth generation tensor cores: up to 2x AI power
- Third-generation RT cores: up to 2x ray tracing performance
Choose the deployment shape before renting a server
| Option | What runs on the VPS | Privacy and data path | Latency and scale | Operational effort |
|---|---|---|---|---|
| CPU-only VPS | Open WebUI and a small local model | Prompts stay on infrastructure you control | Lowest performance; larger models and long contexts become slow | Lowest infrastructure complexity |
| GPU VPS | Open WebUI plus a GPU-backed Ollama or vLLM server | Prompts can remain within your cloud account | Better response time and capacity for larger models; billed GPU time is a major cost factor | Requires GPU drivers, image updates, and capacity planning |
| Local GPU machine | Open WebUI and inference on hardware you own | Data can remain entirely on your network | Good performance without per-hour cloud GPU charges, limited by your hardware and internet connection | You maintain power, cooling, drivers, and physical access |
| Hosted model API | Open WebUI only, connected to an OpenAI-compatible provider | Prompts and outputs traverse that provider’s service | Usually easiest to scale; latency depends on the provider and network | Least model maintenance, usage-based billing |
Compare these choices on four questions: where data travels, how quickly responses must arrive, what recurring compute and storage costs you accept, and how much maintenance you want. A small VPS can still provide a polished private interface if inference runs elsewhere.
Prerequisites and a safe baseline
Server and domain
- A Linux VPS with enough disk for Docker images, logs, the WebUI database, and model files. Model files can consume tens or hundreds of gigabytes, so check free space before downloading anything.
- A domain name whose DNS record points to the VPS if the service will be accessed outside your private network.
- Administrative access for installing Docker and, for GPU inference, the vendor’s driver and container toolkit.
- A backup destination separate from the VPS. A snapshot on the same provider is not a complete disaster-recovery plan.
Network and account controls
- Permit SSH only as needed, preferably with keys and a non-root administrator.
- Allow TCP ports 80 and 443 at the public firewall for the reverse proxy. Do not publish the model API port to the internet.
- Generate a long, random value for
WEBUI_SECRET_KEY. Do not commit it to a shell history file, image, or public repository. - Decide whether registration is open, invite-only, or limited to an existing identity system before sharing the URL.
Model and licensing checks
Model licenses and acceptable-use terms differ across the available catalog. Read the license for every model before commercial use or before giving access to a team. A self-hosted interface does not make a model’s restrictions disappear.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchInstall Docker and start Open WebUI
Install Docker using the package instructions for your Linux distribution, enable the Docker service, and verify that your administrator can run containers. Then create a random secret and start the documented Open WebUI image:
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data -e WEBUI_SECRET_KEY=your-secret-key --name open-webui --restart always ghcr.io/open-webui/open-webui:mainReplace your-secret-key with the random value you generated. The mapping means that port 3000 on the VPS forwards to port 8080 inside the container. The named volume at /app/backend/data preserves chats, users, and settings when the container is recreated. --restart always brings the service back after a reboot or Docker restart.
Check that the container is running with docker ps and inspect startup messages with docker logs open-webui. From a temporary browser test, visit http://server-address:3000. Complete the first-account setup, then remove direct public access once the reverse proxy is ready. The port is an installation test, not the final production URL.
Connect a local Ollama backend
Ollama is the simplest local runtime for a first deployment. Its REST API listens on port 11434 and downloaded models are stored in an Ollama volume.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →CPU-only Ollama
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollamaThis keeps inference on the host CPU. It is appropriate for a lightweight model or occasional use, but generation speed declines as model size and context length increase.
NVIDIA GPU Ollama
Install the NVIDIA Container Toolkit on the host first, verify that the driver can see the GPU, and then run:
Rank #2
- TRI FROZR 3-Stay cool and quiet. MSI’s TRI FROZR 3 thermal design enhances heat dissipation all around the graphics card.
- TORX FAN 5.0-Fan blades linked by ring arcs and a fan cowl work together to stabilize and maintain high-pressure airflow.
- Copper Baseplate-Heat from the GPU and memory modules is captured by a copper baseplate and then rapidly transferred to Core Pipes.
- Core Pipe-Precision-machined heat pipes ensure max contact and spread heat along the full length of the heatsink.
- Airflow Control-Sections of different heatsink fins disrupt unwanted airflow harmonics and reduce noise.
docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollamaThe ollama volume prevents model downloads from disappearing when the container is replaced. Keep port 11434 private; Open WebUI should be the public-facing application.
Install Ollama directly on Linux
If you prefer a host service instead of a container, Ollama’s Linux installer is:
curl -fsSL https://ollama.com/install.sh | shThe installer does not change the hardware requirement: model speed still depends on available CPU, RAM, GPU memory, and storage. A large model can be technically runnable yet unpleasantly slow without a strong GPU.
Point Open WebUI at Ollama
- Open the administrator area in Open WebUI and locate the connections or model-provider settings.
- Add an Ollama connection using the address reachable from the WebUI container. For a host service, the supplied container command creates the
host.docker.internalhost name; for two containers on one private Docker network, use the Ollama service or container name instead. - Save the connection and refresh the model list. If no models appear, test reachability from the Docker network and inspect both containers’ logs.
- Download a model through your Ollama workflow, then select it in a new chat. Keep model files on the persistent Ollama volume.
Use vLLM when concurrency and API compatibility matter
vLLM is a serving layer built around an OpenAI-compatible API. It is a better fit when several people will generate responses at once, when an existing application already expects OpenAI-style endpoints, or when you need a dedicated serving process rather than a single-user local runtime.
vLLM publishes the vllm/vllm-openai Docker image. Configure the server’s host and port, select the model and its supported context length, and then enter that OpenAI-compatible base URL in Open WebUI’s provider settings. Keep the endpoint on a private network and protect any API key used between services.
The vLLM Docker guidance recommends host IPC or an explicitly sized shared-memory segment because PyTorch uses shared memory for tensor-parallel inference. Without enough shared memory, a container may start but fail when loading or splitting a model. GPU drivers, compatible CUDA components, model VRAM requirements, and the chosen context window must all fit the machine before you increase concurrency.
Free tools Windows power users keep installed
One-click scans. No signup required.
Put HTTPS and authentication in front of the interface
Do not leave port 3000 as the permanent public endpoint. Place a reverse proxy in front of Open WebUI, point your domain’s DNS record at the VPS, and issue a certificate for the domain. Forward HTTPS traffic to 127.0.0.1:3000 or the private Docker network address.
- Create a virtual host for the chosen domain and proxy WebSocket-capable connections as well as ordinary HTTP requests.
- Obtain and automatically renew a TLS certificate through your certificate authority or proxy provider.
- Redirect HTTP to HTTPS and add a request-size and timeout policy appropriate for chat uploads and long generations.
- Close public access to ports 3000 and 11434 at the cloud firewall after the proxy works. Expose only the proxy’s HTTPS port, plus SSH administration as required.
- Keep Open WebUI authentication enabled. Before inviting users, test account creation, password reset or administrator recovery, and logout from a separate browser.
Authentication, persistence, backups, and monitoring are not optional finishing touches for a multi-user deployment; they are part of the initial production design.
Rank #3
- NVIDIA Ada Lovelace Streaming Multiprocessors: Up to 2x performance and energy efficiency
- Tensor Cores of the 4th Generation: up to 2x AI performance
- RT-cores of the 3rd Generation: up to 2x raytracing performance
- OC mode: Boost clock 2595 MHz (OC mode) / 2565 MHz (gaming mode)
- Axial Tech fans deliver up to 23% higher airflow
Storage, backups, and upgrades
What must be backed up
- The
open-webuivolume, which contains chats, users, and settings. - The
ollamavolume or the model directory used by another backend. Re-downloading models is possible, but it can take substantial time and bandwidth. - Reverse-proxy configuration, DNS records, environment files, and the secret-management procedure. Never put the actual secret in an unencrypted backup that everyone can read.
Test a restore on a separate container or server before an upgrade. A backup that has never been restored is only an assumption.
Upgrade procedure
- Record the currently running image tags, model versions, and configuration.
- Back up both persistent volumes and verify that the backup completed.
- Pull the new image, stop and remove the old container, and recreate it with the same volume, secret, port, and restart settings.
- Check logs, sign in, open an existing conversation, and run a short generation before allowing users back in.
- Keep the previous image available for rollback until the new version has passed those checks.
How much hardware does inference need?
There is no universal “VPS size” for a model. The required memory is driven by parameter count, quantization, context window, runtime overhead, and the number of simultaneous requests. CPU RAM can run a model that does not fit in GPU memory, but generation may be much slower. A GPU helps only when its VRAM and software stack can hold the selected workload.
One concrete performance reference is Ollama’s 2025 scheduler example: Gemma 3 12B with a 128k context generated 85.54 tokens per second on one NVIDIA RTX 4090, using 21.4 GiB of VRAM with all 49 of 49 layers on the GPU. That is a single published measurement under its stated test conditions, not a universal requirement or promise for every VPS.
- Occasional personal use: start with a CPU VPS and a lightweight model, then measure response time before increasing size.
- Long contexts or larger models: plan for a GPU whose VRAM comfortably exceeds model weights plus runtime and context overhead.
- Several active users: favor a GPU-backed server and a serving layer such as vLLM; test concurrent requests rather than relying on single-user speed.
- Uncertain demand: keep Open WebUI on a small VPS and connect it to a hosted endpoint, accepting that prompts and outputs leave your infrastructure.
Troubleshoot the common failure modes
The browser cannot open the site
- Confirm
docker psshows Open WebUI as running. - Read
docker logs open-webuifor a failed migration, permission error, or invalid environment value. - Verify that the proxy targets port 3000 and that the cloud firewall allows HTTPS.
- Test locally on the VPS before debugging DNS or certificates.
Open WebUI cannot see Ollama
- Check that Ollama is running and listening on port 11434.
- Use an address reachable from the WebUI container, not an address that exists only inside your laptop’s browser.
- If the containers are separate, place them on the same private Docker network and use the service name.
- Keep the API private; do not “fix” connectivity by opening 11434 to the entire internet.
The model is slow or runs out of memory
- Reduce model size or context length, and verify whether layers are actually running on the GPU.
- Check host RAM, GPU VRAM, shared memory, and disk space while loading the model.
- On a CPU-only VPS, expect larger models to have materially higher latency.
- For concurrent users, move from a single local runtime to a properly sized vLLM server or a hosted endpoint.
Chats disappeared after a restart
The container was probably recreated without the open-webui volume, or the volume was deleted. Recreate the container with the same mount and restore the latest backup. Model downloads have the analogous issue if the Ollama volume was omitted.
GPU acceleration is unavailable
Verify the host driver first, then confirm the NVIDIA Container Toolkit is installed and that the container was started with --gpus=all. A GPU shown by the host is not proof that the container can access it; inspect container logs and runtime diagnostics.
Operate it responsibly for multiple users
Set expectations about model behavior, retention, and availability. Tell users whether prompts are processed locally or sent to a provider, how long conversations are retained, and who can administer the server. Monitor disk usage, RAM and VRAM consumption, container restarts, request latency, and error rates. Alert before storage fills, because a full disk can corrupt logs and prevent new conversations.
Schedule operating-system, Docker, GPU-driver, reverse-proxy, and image updates. Review access logs for unexpected traffic, rotate credentials when administrators change, and remove inactive accounts. If the service is exposed to the public internet, rate limiting and a clear abuse-response process become important as usage grows.
A practical decision sequence
- Deploy Open WebUI on a Linux VPS with its persistent volume.
- For private, low-volume use, add Ollama on the same machine and begin with a model that fits available memory.
- If latency, context length, or concurrent users exceed CPU capacity, move inference to a GPU VPS or local GPU without changing the interface.
- If you do not want to operate model hardware, connect Open WebUI to a hosted OpenAI-compatible endpoint and document the resulting data path.
- Before sharing access, put the interface behind HTTPS, verify authentication, back up both volumes, and test recovery.
The result is a maintainable ChatGPT-style service rather than a fragile demo: the UI, model runtime, storage, and public network boundary each have a clear responsibility and can be scaled or replaced independently.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
