OpenClaw Unraid Setup: A Practical Guide

How I built a self-hosted AI assistant infrastructure, with model recommendations and hard-earned lessons from the setup process. This guide walks through everything from initial deployment to advanced configuration, based on months of running OpenClaw in production on Unraid.

Why OpenClaw on Unraid

OpenClaw is an autonomous AI assistant framework that runs on your infrastructure. Unlike cloud-based AI assistants, it gives you complete control over your data, models, and capabilities. Running it on Unraid combines the flexibility of self-hosted AI with the user-friendly container management that makes homelab administration sustainable.

The combination is particularly powerful because Unraid's Docker management makes it easy to deploy and update OpenClaw, while its flexible storage system handles the persistent data that OpenClaw needs. If you're already running an Unraid server, adding OpenClaw is a natural extension that transforms your NAS into an AI-powered infrastructure management system.

Here's how I set it up in Docker, configured cloud models, and integrated it with my homelab services. This guide is based on months of production use, including all the mistakes and fixes I discovered along the way. My goal is to save you the troubleshooting time I spent and get you to a working system as quickly as possible.

Step 1: Docker Deployment

Deploy OpenClaw as a Docker container. In Unraid, this is straightforward through the Docker tab in the web UI. Key configuration: set persistent volume mappings for /workspace and /config, configure environment variables for API keys and database connections, set the container to auto-start, and map port 3000 for the web interface.

The most important configuration decision is your volume mappings. The /workspace directory contains all your configuration files, memory data, and custom scripts. The /config directory stores the core OpenClaw configuration. Both need to be on persistent storage that survives container updates. I recommend using Unraid's share system with a dedicated share for OpenClaw data, which makes backups and migrations straightforward.

One mistake I made initially was not mapping enough persistent storage. OpenClaw accumulates log files, memory data, and cached responses over time. Make sure your volume mappings cover all the directories that store persistent data, or you'll lose configuration and memory on container updates. The Docker image documentation lists all the directories that should be persistent—read it carefully before deploying.

Step 2: Model Configuration

This is where most people get stuck. The model configuration determines which AI models your assistant uses for different tasks, and getting it wrong means either poor performance or excessive costs. Here's what worked for me after extensive experimentation.

Edit openclaw.json in your workspace to configure your models. The configuration lets you specify a default model and a list of available models that can be selected for specific tasks. Here's my current configuration:

{"models": {"default": "ollama/qwen3.5:cloud", "available": [{"id": "ollama/qwen3.5:cloud", "name": "Qwen 3.5"}, {"id": "ollama/devstral-small-2:cloud", "name": "Devstral Small 2"}, {"id": "ollama/glm-5:cloud", "name": "GLM-5"}, {"id": "ollama/ministral-3:8b-cloud", "name": "Ministral 3"}]}}

Model recommendations based on months of testing: Use the most capable model you can afford for complex tasks like coding and analysis. Use smaller, cheaper models for routine tasks like health checks and formatting. Qwen 3.5 is an excellent default that balances capability and cost. Ministral 3 is ideal for simple cron jobs and heartbeat checks. Devstral Small 2 works well for code-related tasks. GLM-5 is the most capable but also the most expensive per token.

If you have a GPU with 24GB+ VRAM, you can run smaller models locally: docker exec openclaw ollama pull llama3.2:3b, then update your config to use ollama/llama3.2:3b for simple tasks. This eliminates API costs for routine operations and gives you complete independence from cloud providers. The tradeoff is that local models are typically less capable than cloud models, so use them selectively.

Step 3: Neo4j Memory Configuration

OpenClaw uses Neo4j as its primary memory store. This is what transforms it from a stateless chatbot into a system that actually remembers your projects, people, and context. The memory system is powerful but requires proper configuration to work well.

Deploy Neo4j as a separate Docker container on your Unraid server. Configure the connection in TOOLS.md with the Neo4j bolt connection URL, credentials, and database name. The memory system automatically ingests data from markdown files in your workspace and creates graph nodes for people, projects, goals, services, and events.

The automated ingestion process means your documentation doubles as AI memory. When you write a note about a new project in your workspace, it gets parsed and stored in Neo4j automatically. This is a powerful pattern—every markdown file you write contributes to the AI's understanding of your infrastructure and work. The key is to be consistent about documentation: if it's not written down, the AI doesn't know about it.

For backup, I recommend regularly exporting the Neo4j database. The graph contains all your accumulated memory, and rebuilding it from scratch is painful. I have a weekly cron job that exports the database to a file on my Unraid array, which then gets backed up with the rest of my data.

Step 4: Discord Integration

Discord is OpenClaw's primary interface for alerts, commands, and daily summaries. The integration is straightforward but requires creating a Discord bot and configuring the appropriate permissions.

In the OpenClaw config, add your Discord bot token and server ID. Create a dedicated bot user through the Discord Developer Portal, generate a token, and invite the bot to your server. Configure the channels you want OpenClaw to use for different purposes: a main channel for interactive commands, an alerts channel for automated notifications, and a logs channel for detailed debugging output.

Create channels for: general interaction (where you talk to the assistant), alerts (automated notifications about system status), logs (detailed operational logs for debugging), and summaries (daily status reports). Separating these channels keeps your Discord organized and makes it easy to find specific information when you need it.

The Discord integration transforms how you interact with your infrastructure. Instead of logging into a dashboard to check status, you simply read your Discord channels. Instead of manually running health checks, you ask the assistant in Discord. The chat interface is natural, always available on your phone, and provides a searchable history of all interactions and alerts.

Step 5: Cron Jobs and Scheduled Tasks

OpenClaw includes a cron system for scheduled tasks. This is what makes it truly autonomous—the assistant doesn't just respond to your messages, it proactively performs tasks on a schedule. Here are the essential jobs I configured, along with why each one matters.

Hourly Health Check

{"name": "hourly-alive-check", "schedule": "0 * * * *", "model": "ministral-3:8b-cloud", "task": "Check system health and post to Discord"}

This is the most important cron job. Every hour, the assistant checks all Docker containers, disk usage, network connectivity, and critical service endpoints. Results are posted to the alerts channel. If anything is wrong, you know within minutes, not hours. Using the cheapest model keeps costs down since this is a relatively simple task.

Media Manager (Every 30 Minutes)

{"name": "media-manager", "schedule": "*/30 * * * *", "model": "ministral-3:8b-cloud", "task": "Check for completed downloads, organize files, trigger searches"}

Automates the entire media management workflow. Checks for completed downloads, organizes files according to naming conventions, triggers searches for missing watchlist content, and cleans up temporary files. This alone saves hours of manual work weekly.

Daily Summary

{"name": "daily-summary", "schedule": "0 7 * * *", "model": "qwen3.5:cloud", "task": "Generate and post daily summary to Discord"}

At 7 AM every day, the assistant compiles a summary of overnight events, current system status, upcoming calendar events, and weather. This is posted to the summaries channel and serves as a morning briefing. Using a more capable model here produces better-quality summaries.

Step 6: Node Configuration

OpenClaw supports distributed nodes for tasks that require access to other machines. In my setup, my Windows gaming PC runs an OpenClaw Node that provides browser automation capabilities. The node connects to the main OpenClaw instance and registers its available tools.

Node setup is straightforward: install the OpenClaw Node agent on the target machine, configure it with the main server's connection details, and specify which tools to expose. The node will connect automatically on startup and reconnect if the connection drops. This resilience is important for machines that might be rebooted or powered off regularly.

The browser automation capability is particularly valuable. It allows the AI to interact with websites that don't have APIs, fill out forms, download files, and perform visual testing. I use it for tasks like checking website uptime from an external perspective, downloading statements from financial institutions, and interacting with web services that require authentication.

Lessons Learned

After months of running OpenClaw on Unraid, I've collected a set of hard-earned lessons that would have saved me significant time if I'd known them from the start.

Start Small and Iterate

Don't try to configure everything at once. Start with the basic deployment, get it working, and add features one at a time. Each new integration—Neo4j, Discord, cron jobs, nodes—introduces potential failure points. Adding them one at a time makes troubleshooting much easier than deploying everything at once and trying to figure out which component is broken.

Monitor Your Costs

Autonomous AI tasks can burn through API credits quickly. Implement cost monitoring from day one—track token usage per task, set daily budgets, and alert on unusual spending. The horror stories of runaway API bills are real, and they happen because people didn't implement basic cost controls until it was too late.

Document Everything

Every configuration change, every new cron job, every model swap—document it. Not just for future-you, but because OpenClaw ingests documentation into its memory. When you write things down, the AI knows about them too. This creates a virtuous cycle where better documentation makes the AI more capable.

Test Your Backups

Having backups isn't enough—you need to verify that they work. After a database corruption issue that required restoring from backup, I discovered that my backup process was capturing incomplete data. Now I test restores monthly. A backup you haven't tested is just a hope, not a backup.

Use the Right Model for Each Task

Model selection has a huge impact on both quality and cost. Don't use your most expensive model for simple tasks, and don't use a cheap model for complex reasoning. The configuration system lets you specify models per task—take advantage of it. The right model selection can cut your API costs by 50% or more without sacrificing quality.

Next Steps

Once you have the basic setup working, there are many directions to explore. Adding more integrations—calendar, email, smart home controls—extends what your assistant can do. Building custom tools for your specific workflows makes the assistant more valuable for your particular use case. And contributing back to the OpenClaw community helps make the platform better for everyone.

The journey from basic deployment to a fully integrated AI assistant is iterative. Each step builds on the previous one, and each new capability reveals new possibilities. The key is to keep experimenting, keep documenting, and keep automating. Before you know it, your Unraid server won't just be a NAS—it'll be the brain of your entire digital infrastructure.