OpenClaw inside Ollama Docker: simpler networking, brutal RAM usage
I put OpenClaw inside the Ollama container to avoid host access/networking issues. It works, but RAM usage is brutal
I tried this setup for one specific reason:
I did not want OpenClaw running in a separate container and needing access back to the host machine just to reach Ollama.
Most Docker setups put OpenClaw and Ollama in separate places:
- Ollama on the host and OpenClaw in Docker
- Ollama in one container and OpenClaw in another container
- OpenClaw reaching Ollama through `host.docker.internal`
- OpenClaw reaching Ollama through a Docker network hostname
- OpenClaw needing extra host/network configuration
That works, but it adds friction and can expand what OpenClaw needs to reach.
In this setup, I do the opposite:
- start from the official `ollama/ollama` Docker image
- install OpenClaw inside that same container
- let OpenClaw talk to Ollama through `127.0.0.1:11434`
- expose only the ports I need from the container
The main benefit is simple:
OpenClaw does not need to call back into the host machine to talk to Ollama. The model endpoint is local inside the same container.
This is not a full security-hardening guide, but it keeps the setup more contained and avoids a lot of the usual Docker networking confusion around `host.docker.internal`, container hostnames, and Ollama bind addresses.
The tradeoff:
RAM usage can get heavy very quickly. OpenClaw prompts can be large, and small local models may struggle with context/tool use. So this setup is cleaner from a networking/container isolation perspective, but it is not magically lightweight.
## What this setup gives you
- Ollama running in Docker
- OpenClaw installed inside the same Ollama container
- GPU support enabled through Docker
- persistent Ollama model storage
- local Qwen models pulled through Ollama
- OpenClaw gateway running on port `18789`
- OpenClaw dashboard available through the gateway
- no `host.docker.internal` needed for OpenClaw to reach Ollama
Local services:
- Ollama API: `http://localhost:11434\`
- OpenClaw gateway/dashboard: `http://localhost:18789\`
## 1. Start the Ollama container from the host
Run this in PowerShell or your host terminal.
This creates the container, mounts persistent Ollama storage, enables GPU support, and opens ports `11434` and `18789`.
```bash
docker run -d \
--name ollamaopenclaw \
--gpus=all \
-v ollama_docker:/root/.ollama \
-p 11434:11434 \
-p 18789:18789 \
ollama/ollama
If you do not want the ports exposed on all host interfaces, bind them to localhost instead:
docker run -d \
--name ollamaopenclaw \
--gpus=all \
-v ollama_docker:/root/.ollama \
-p 127.0.0.1:11434:11434 \
-p 127.0.0.1:18789:18789 \
ollama/ollama
- Open a shell inside the container
docker exec -it ollamaopenclaw sh
- Install OpenClaw inside the Ollama container
Run this inside the container.
apt-get update && apt-get install -y curl git bash ca-certificates
curl -fsSL --proto '=https' --tlsv1.2 https://openclaw.ai/install-cli.sh | bash
export PATH="$HOME/.openclaw/bin:$PATH"
Check that OpenClaw is available:
openclaw --version
- Pull Ollama models
Run this inside the container.
Use whichever model fits your hardware. I tested with small Qwen models first because the goal was to verify the setup.
ollama pull qwen3.5:0.8b
ollama pull qwen3.5:2b
ollama pull qwen3.5:4b
Check that Ollama sees the models:
ollama list
- Configure OpenClaw to use the local gateway
Run this inside the container.
export OLLAMA_API_KEY="ollama-local"
openclaw config set gateway.bind lan
openclaw config set gateway.port 18789
openclaw config set gateway.controlUi.allowedOrigins '["http://localhost:18789","http://127.0.0.1:18789"\]' --strict-json
- Start the OpenClaw gateway
Run this inside the same container shell.
Important: this terminal stays open. Do not close it while using the gateway.
openclaw gateway run --bind lan --port 18789 --allow-unconfigured
- Open a second shell inside the same container
Open a second terminal/PowerShell window on the host and run:
docker exec -it ollamaopenclaw sh
Then set the OpenClaw path again:
export PATH="$HOME/.openclaw/bin:$PATH"
export OLLAMA_API_KEY="ollama-local"
- Run OpenClaw onboarding
Because OpenClaw and Ollama are inside the same container, the Ollama base URL is:
Do not use:
http://host.docker.internal:11434
And do not use the OpenAI-compatible /v1 endpoint unless you specifically know you need it:
Use the model you want.
Small model:
openclaw onboard --non-interactive \
--auth-choice ollama \
--custom-base-url "http://127.0.0.1:11434" \
--custom-model-id "qwen3.5:0.8b" \
--accept-risk
Medium model:
openclaw onboard --non-interactive \
--auth-choice ollama \
--custom-base-url "http://127.0.0.1:11434" \
--custom-model-id "qwen3.5:2b" \
--accept-risk
Larger model:
openclaw onboard --non-interactive \
--auth-choice ollama \
--custom-base-url "http://127.0.0.1:11434" \
--custom-model-id "qwen3.5:4b" \
--accept-risk
- Open the dashboard
Run:
openclaw dashboard
Open the URL it prints.
Expected local access:
Useful checks
Check running containers:
docker ps
Check container logs:
docker logs ollamaopenclaw
Enter the container again:
docker exec -it ollamaopenclaw sh
Check Ollama models:
ollama list
Check OpenClaw version:
openclaw --version
Check that Ollama responds from inside the container:
curl http://127.0.0.1:11434/api/tags
Restart
If the container is stopped:
docker start ollamaopenclaw
Then enter it again:
docker exec -it ollamaopenclaw sh
Re-export the path:
export PATH="$HOME/.openclaw/bin:$PATH"
Restart the gateway:
openclaw gateway run --bind lan --port 18789 --allow-unconfigured
Stop and remove
Stop the container:
docker stop ollamaopenclaw
Remove the container:
docker rm ollamaopenclaw
The Ollama models remain in the Docker volume:
ollama_docker
If you also want to remove the model volume:
docker volume rm ollama_docker
Notes and tradeoffs
This setup is mainly about containment and simpler networking.
It avoids the common situation where OpenClaw has to reach back into the host or across containers just to talk to Ollama.
Instead:
OpenClaw → 127.0.0.1:11434 → Ollama
all inside the same container.
But there are tradeoffs:
RAM usage can be high.
OpenClaw prompts can be large.
Small local models may struggle with tool use.
Larger models need serious RAM/VRAM.
The gateway terminal must stay running.
This is not a production hardening guide.
Do not expose 18789 publicly without authentication, firewalling, or a secure tunnel/VPN.
If you want a cleaner long-term deployment, a proper Docker Compose setup with separate services may still be better. But for local testing, this one-container approach avoids a lot of host/networking confusion.