OpenClaw Wiki — Glossary, Configuration, Commands & Troubleshooting Reference Guide [2026]
Comprehensive reference guide for OpenClaw. Covers glossary, system requirements, command reference, MCP integration, troubleshooting, FAQs, and more.
What is OpenClaw? Overview
OpenClaw is an open-source AI agent platform provided under the MIT License. Organizations and individuals can deploy it locally in their own environments, enabling task automation, multi-channel support (Slack/Discord/LINE, etc.), and knowledge base integration (RAG). By integrating with local LLMs like Ollama, it enables complete offline operation without cloud API dependency. It's an ideal solution for privacy-conscious enterprises, organizations seeking cost reduction, and developers requiring custom implementations. It offers enterprise-grade features including external tool integration via MCP protocol, multimodal support, and workflow automation.
OpenClaw Glossary
Essential terminology for mastering OpenClaw.
| Term | Description |
|---|---|
| Agent | An autonomous agent that executes AI tasks with specific skills and prompt templates |
| Task | A unit of work assigned to an agent; can be one-off or part of a workflow |
| Knowledge Base | Internal document database referenced by RAG; supports PDF/Markdown/CSV imports |
| MCP (Model Context Protocol) | External tool integration protocol standardizing file operations, web search, database access, etc. |
| Modelfile | Custom configuration file for Ollama models defining temperature, top-p, system prompt |
| Channel | Messaging platform integration (Slack/Discord/LINE, etc.) |
| Skill | Specific capabilities/tools an agent possesses (search, calculation, image generation, etc.) |
| RAG (Retrieval Augmented Generation) | Method where LLM generates answers by searching external knowledge; effective against hallucinations |
| Workflow | Automated execution sequence of multiple tasks supporting conditional branching, loops, parallel execution |
| Prompt Template | Template defining agent behavior including role, constraints, output format |
System Configuration and Requirements
OpenClaw runs on a wide range of hardware environments. Recommended configurations by use case:
| Configuration | CPU | Memory | Storage | GPU | Target Users |
|---|---|---|---|---|---|
| Minimum | M4/i5 equivalent | 16GB | 256GB SSD | Not required | Individual/Testing |
| Recommended | M4 Pro/i7 equivalent | 32GB | 512GB SSD | 8GB+ VRAM | SMB/Team use |
| Enterprise | M4 Max/Xeon | 64GB+ | 1TB+ NVMe | 24GB+ VRAM | Large-scale production |
Mac mini (M4/M4 Pro) offers excellent cost-performance for small to medium-scale deployments. GPU is optional but essential for image generation and multimodal tasks.
Installation Methods Summary
OpenClaw supports multiple platforms. For Mac (macOS): ```bash brew install openclaw openclaw init openclaw start ``` For Linux: ```bash curl -fsSL https://openclaw.sh | bash openclaw init sudo systemctl enable openclaw sudo systemctl start openclaw ``` Docker environment: ```bash docker pull openclaw/openclaw:latest docker run -d -p 3000:3000 -v ./data:/data openclaw/openclaw ``` Windows (WSL2): ```bash wsl --install wsl curl -fsSL https://openclaw.sh | bash openclaw init && openclaw start ``` After installation, access `http://localhost:3000` in your browser and run the initial setup wizard. Ollama installation and initial model download takes 10-30 minutes.
Main Configuration File Reference
OpenClaw's behavior is primarily controlled by `config.yaml` and `Modelfile`. Key parameters in config.yaml: ```yaml server: port: 3000 host: 0.0.0.0 max_concurrency: 5 llm: provider: ollama model: qwen3.5:9b temperature: 0.7 max_tokens: 4096 rag: enabled: true chunk_size: 512 chunk_overlap: 64 vector_db: qdrant embedding_model: mxbai-embed-large channels: slack: enabled: true bot_token: ${SLACK_BOT_TOKEN} discord: enabled: false ``` Modelfile example: ``` FROM qwen3.5:9b PARAMETER temperature 0.7 PARAMETER top_p 0.9 SYSTEM You are a helpful and accurate AI assistant. ``` Key environment variables: - `OPENCLAW_HOME`: Installation directory (default: ~/.openclaw) - `OPENCLAW_PORT`: Server port (default: 3000) - `OLLAMA_HOST`: Ollama server address - `SLACK_BOT_TOKEN`: Slack integration token - `DISCORD_BOT_TOKEN`: Discord integration token
Frequently Used Commands
Comprehensive list of OpenClaw CLI commands.
| Command | Description |
|---|---|
| `openclaw start` | Start OpenClaw server |
| `openclaw stop` | Stop OpenClaw server |
| `openclaw restart` | Restart server |
| `openclaw status` | Check operational status and service health |
| `openclaw agent create <name>` | Create new agent |
| `openclaw agent list` | List registered agents |
| `openclaw task run <agent> <task>` | Execute task with specified agent |
| `openclaw kb import <dir>` | Import documents to knowledge base |
| `openclaw kb search <query>` | Search knowledge base |
| `openclaw channel add <type>` | Add messaging channel (slack/discord/line) |
| `openclaw logs` | Display server logs in real-time |
| `openclaw logs --tail 100` | Display last 100 log lines |
| `openclaw update` | Update OpenClaw to latest version |
| `openclaw config edit` | Open configuration file in editor |
| `openclaw model list` | List available LLM models |
| `openclaw model pull <name>` | Download new model |
All commands support `--help` option for detailed help.
MCP (Model Context Protocol) Integration Guide
MCP is a protocol for LLMs to integrate with external tools in a standardized manner. OpenClaw supports the following MCP servers. Main MCP tools: - File operations: Local file read/write, directory operations - Web search: Google/Bing search, specific site crawling - Database access: PostgreSQL, MySQL, SQLite query execution - API calls: REST/GraphQL API invocation - Code execution: Safe execution of Python/JavaScript/Bash code - Browser automation: Automated browsing via Puppeteer MCP configuration example (config.yaml): ```yaml mcp: servers: - name: filesystem enabled: true config: allowed_paths: - /data - /workspace - name: web_search enabled: true config: api_key: ${GOOGLE_SEARCH_API_KEY} - name: database enabled: true config: connection_string: postgresql://user:pass@localhost/db ``` MCP servers run as independent processes, and OpenClaw communicates via HTTP/WebSocket. Allowlist-based access control is recommended for security.
Knowledge Base Construction Process
How to build a knowledge base for RAG (Retrieval Augmented Generation). 1. Document preparation: Supported formats: PDF, Markdown, CSV, DOCX, TXT. Place internal wikis, manuals, FAQs in `/data/kb/` directory. 2. Execute import: ```bash openclaw kb import /data/kb/ --recursive ``` 3. Optimize chunk settings: Adjust in `config.yaml`: - `chunk_size`: 512-1024 (512 for short docs, 1024 for long) - `chunk_overlap`: 10-20% of chunk_size - `embedding_model`: Recommend `multilingual-e5-large` or `mxbai-embed-large` for Japanese 4. Vector DB (Qdrant) configuration: Qdrant is embedded by default, but external Qdrant server is recommended for large-scale operations. ```yaml rag: vector_db: qdrant qdrant_url: http://localhost:6333 collection_name: openclaw_kb ``` 5. Verify search accuracy: ```bash openclaw kb search "delivery timeline" --top-k 5 ``` Regular re-imports and index optimization are key to maintaining accuracy.
Multi-Channel Integration
OpenClaw integrates with major messaging platforms. Slack integration: 1. Obtain Bot Token from Slack App 2. Set in `SLACK_BOT_TOKEN` environment variable 3. Execute `openclaw channel add slack` 4. Invite bot to Slack channel Discord integration: 1. Create Bot in Discord Developer Portal 2. Set in `DISCORD_BOT_TOKEN` environment variable 3. Execute `openclaw channel add discord` 4. Invite to server via OAuth2 URL LINE integration: 1. Enable Messaging API in LINE Developers Console 2. Obtain Channel Secret and Access Token 3. Set Webhook URL to `https://your-domain.com/webhook/line` 4. Configure with `openclaw channel add line` Microsoft Teams integration: 1. Configure Bot Framework in Teams App 2. Obtain App ID and Password 3. Add to teams section in `config.yaml` Email integration: Receive via IMAP, send via SMTP. Useful for automated inquiry responses and report distribution. Supports mentions, thread replies, and file attachments in each channel.
LLM Model Selection Guide
Comparison of major LLM models available for OpenClaw.
| Model | Parameters | Required VRAM | Japanese Quality | Recommended Use |
|---|---|---|---|---|
| Qwen3.5-9B | 9B | 6GB | Excellent | General/Business. Extremely high Japanese accuracy, best value |
| Gemma 4 E4B | 4.5B | 4GB | Good | Lightweight tasks, real-time responses |
| Gemma 4 31B | 31B | 20GB+ | Good | High-quality reasoning, complex logic |
| Llama 4 Scout | 17B (active) | 24GB+ | Fair | Long context (128K), large document processing |
| DeepSeek R1 8B | 8B | 6GB | Fair | Reasoning-focused, mathematical problem solving |
| Mistral Nemo | 12B | 8GB | Good | Multilingual, code generation |
| Phi-4 | 14B | 10GB | Good | Microsoft, compact high-performance |
Selection tips: - For Japanese-focused work: Qwen3.5-9B is optimal - Limited memory: Gemma 4 E4B - Highest quality: Gemma 4 31B or Llama 4 Scout - Code generation: Mistral Nemo or DeepSeek R1 Download models with `openclaw model pull <name>` and switch in `config.yaml`.
Security Configuration
Security settings for safely operating OpenClaw in enterprise environments. 1. Access control: ```yaml security: auth: enabled: true method: oauth2 # or jwt, basic allowed_users: - user@example.com allowed_groups: - engineering - support ``` 2. API authentication: Set Bearer token authentication for REST API. ```bash openclaw api create-token --name "external-service" --expires 90d ``` 3. Data encryption: - Data at rest: Encrypt knowledge base and logs with AES-256 - Communication: TLS 1.3 required (automatic cert via Let's Encrypt) ```yaml security: encryption: at_rest: true key_file: /secure/encryption.key tls: enabled: true cert_file: /etc/letsencrypt/live/domain/fullchain.pem key_file: /etc/letsencrypt/live/domain/privkey.pem ``` 4. Audit logging: Record all API calls, agent executions, configuration changes. ```yaml logging: audit: enabled: true output: /var/log/openclaw/audit.log rotation: daily retention: 90d ``` 5. Network isolation: Restrict management ports to internal network with firewall, expose via Reverse Proxy (Nginx/Caddy). Regular vulnerability scanning and updates are recommended.
Troubleshooting
Common issues and solutions during OpenClaw operation.
| Symptom | Possible Cause | Solution |
|---|---|---|
| Server won't start | Port 3000 already in use | Check with `lsof -i :3000`, stop process or change port in `config.yaml` |
| Extremely slow LLM responses | Memory shortage, swapping | Reduce model size (9B→4.5B), change quantization to Q4 |
| Low RAG search accuracy | Inappropriate chunk settings | Increase `chunk_size` 512→1024, change `embedding_model` |
| Channel connection error | Token expired | Re-authenticate in Slack/Discord, update token |
| Disk space warning | Model and log bloat | Delete unused models with `openclaw model prune`, configure log rotation |
| GPU at 100% constantly | Too many concurrent requests | Reduce `max_concurrency` from 5→3 in `config.yaml` |
| Can't connect to Ollama | Ollama service not running | Verify startup with `ollama serve` or `systemctl start ollama` |
| Knowledge Base search returns 0 | Index not created | Rebuild with `openclaw kb rebuild-index` |
| Suspected memory leak | Accumulation from long uptime | Periodically `openclaw restart` or `systemctl restart openclaw` |
| Task timeout | Task too complex | Increase `max_tokens` and `timeout`, split task |
Log checking: ```bash openclaw logs --level error --tail 50 journalctl -u openclaw -f # systemd environments ``` If issues persist, ask on GitHub Issues or official Discord.
Version History and Latest Updates
Major version update history for OpenClaw. v1.0.0 (March 2024) - Initial release - Basic agent execution functionality - Ollama integration - Slack/Discord support v1.2.0 (July 2024) - RAG features - Knowledge base integration - Qdrant vector database support - PDF/Markdown import v1.5.0 (November 2024) - MCP support - Model Context Protocol implementation - File operations, web search tools added - Workflow enhancements v2.0.0 (February 2025) - Multimodal support - Image/audio input support - LINE/Teams integration added - Major performance improvements v2.3.0 (September 2025) - Enterprise features - OAuth2 authentication - Audit logging - Multi-tenant support v2.5.0 (January 2026 - Current) - Expanded LLM options - Qwen3.5, Gemma 4, Llama 4 Scout support - GPU efficiency (30% VRAM reduction) - WebUI refresh Upcoming v3.0 (Q3 2026) will feature autonomous agent collaboration, multi-agent orchestration, real-time voice interaction.
Community Resources
Resources for learning and utilizing OpenClaw. Official resources: - GitHub Repository: https://github.com/openclaw/openclaw - Source code, Issues, Pull Requests - Official Documentation: https://docs.openclaw.io - Detailed API specs, tutorials - Discord Server: 5,000+ member community for questions, information exchange, latest updates - YouTube Channel: Demo videos, webinars, case studies Third-party tools: - OpenClaw Studio: GUI configuration tool (VSCode extension) - openclaw-docker-compose: Easy Docker setup templates - openclaw-templates: Industry-specific agent templates (sales support, customer support, data analysis, etc.) - openclaw-monitoring: Metrics exporter for Prometheus/Grafana Japanese resources: - Technical articles on Qiita/Zenn (search "OpenClaw tutorial") - Japanese Discord channel (#japan) - Monthly online meetup by Japanese user community Learning path: 1. Official tutorial (Getting Started) 2. Run sample agents 3. Practice knowledge base construction 4. Custom agent development 5. Production deployment Community contributions (bug reports, feature requests, documentation improvements) are welcome.
FAQ (Frequently Asked Questions)
Q1: Is OpenClaw free to use? A: Yes. Provided under MIT License, free for personal and commercial use. Source code is public, allowing custom modifications and redistribution. Q2: Does it work on hardware other than Mac mini? A: Yes. Runs on Linux (Ubuntu/Debian/RHEL), Windows (via WSL2), Docker environments. Supports both x86_64 and ARM64 (Apple Silicon) architectures. Q3: Is Ollama required? Can other LLM runtimes be used? A: Ollama is recommended, but also supports vLLM, llama.cpp, LocalAI, and others. Switch providers in `config.yaml`. Q4: Is internet connection always required? A: Only needed for initial setup and model downloads. Complete offline operation is possible afterward. Connection only needed for web search or cloud API integration features. Q5: How many users can use it simultaneously? A: Depends on hardware specs. Approximately 3-5 users with 16GB memory, 10-15 with 32GB, 30+ with 64GB. Concurrent requests controlled by `max_concurrency`. Q6: Can it work alongside cloud APIs like Claude/ChatGPT/Gemini? A: Yes. Parallel integration with Anthropic Claude API, OpenAI API, Google Gemini API alongside local LLMs is supported. Enables cost savings and high-quality reasoning tradeoffs. Q7: Is there official support? A: Community support (Discord/GitHub) is primary, but in Japan, Olight provides paid implementation support including setup, customization, and operations. Q8: Are UI and documentation available in Japanese? A: UI and documentation are currently English only, but unofficial translations exist from Japanese community. For LLM responses, using Qwen3.5-9B provides excellent Japanese quality. Q9: Is data privacy guaranteed? A: Yes. All data is stored in your own environment and not sent externally (in offline operation). Knowledge base and conversation history are fully locally managed. Q10: Are there license fees for commercial use? A: No. MIT License means no license fees for commercial use. However, individual LLM model licenses must be checked separately (most like Qwen, Gemma allow commercial use).
Olight's Implementation Support Service
Olight provides comprehensive support services for enterprises struggling with OpenClaw deployment and operations. Service offerings: 1. Initial Setup Support - One-stop service from hardware selection, OS configuration, OpenClaw installation, Ollama setup, to initial model selection. 2. Knowledge Base Construction - Import your company's internal documents, manuals, FAQs in optimal format to build high-accuracy RAG environment. Includes chunk optimization, embedding selection, search accuracy tuning. 3. Custom Agent Development - Develop agents specialized for your business: sales support, customer support, data analysis. Includes API integration with existing systems and business workflow automation. 4. Multi-Channel Integration Setup - Configure integration with messaging tools you use: Slack, Teams, LINE, etc. 5. Security Configuration Support - Implement enterprise-grade access control, encryption, audit logging. Support compliance with information security policies. 6. Operations and Maintenance - Continuous provision of monitoring, troubleshooting, regular maintenance, version upgrade support. Pricing guide: - Initial setup: From USD 3,000 (varies by scale) - Custom agent development: From USD 5,000 per agent - Monthly operations support: From USD 1,000 Implementation track record: Wide range of implementations from SMBs to enterprises across industries. Manufacturing manual auto-response, real estate inquiry handling, SaaS customer support automation, and diverse use cases. Start with free consultation to diagnose your challenges and OpenClaw compatibility. Details at Olight's Implementation Support Service page. Contact us: Enterprises considering OpenClaw implementation, please contact us freely. We'll propose the optimal configuration for your environment.
Feel free to contact us
Contact Us