---
title: "QwenPaw Setup-Guide: Self-Hosted Multi-Channel-KI-Assistent"
description: "QwenPaw Setup-Guide (ehemals CoPaw): Installation per pip, Skript oder Docker, Modelle konfigurieren (Cloud oder lokal) und Discord, Telegram, DingTalk sowie QQ anbinden."
date: 2026-03-05
categories: ["ai"]
tags: ["qwenpaw","copaw","ai-tools"]
---

*Hinweis: Dieser Guide enthält Referral-Links. Wenn du darüber kaufst, bekomme ich eventuell eine Provision – ohne Mehrkosten für dich.*

Dieser **QwenPaw Setup-Guide** (ehemals CoPaw) führt dich durch die Installation des Self-Hosted Multi-Channel-KI-Assistenten per pip, Ein-Zeilen-Skript oder Docker, durch die Einbindung von Cloud- oder lokalen Modellen und durch die Anbindung von Discord, Telegram, DingTalk und mehr. QwenPaw kommt vom AgentScope-Team bei Alibaba, läuft komplett auf deiner eigenen Maschine oder deinem Server und steht bei 37.784 GitHub-Stars (Stand November 2026). Was mich überzeugt hat, ist die eingebaute Web-Console für die Konfiguration und die Tatsache, dass lokale Modellunterstützung direkt mitgeliefert wird. Ich betreibe ihn neben meinen anderen self-gehosteten Assistenten – dazu siehe meinen [OpenClaw Setup-Guide](/clawdbot-setup-guide/) und den [NanoBot Setup-Guide](/nanobot-setup-guide/).

*Geschrieben gegen QwenPaw v2.3.0 (2026-11-11). Wenn du das später liest, prüfe die [Release Notes](https://github.com/agentscope-ai/QwenPaw/releases) – das Projekt released wöchentlich.*

[QwenPaw GitHub](https://github.com/agentscope-ai/QwenPaw)

**CoPaw heißt jetzt QwenPaw**

Das Projekt wurde mit v1.1.0 am 2026-04-12 umbenannt. Gleiches Team, gleicher Code, neuer Name. Das GitHub-Repo ist jetzt `agentscope-ai/QwenPaw`, das pip-Paket heißt `qwenpaw` (das alte `copaw`-Paket ist bei 1.0.2 eingefroren und hat seit dem 2026-04-09 keine Updates mehr bekommen), und das Docker-Image ist `agentscope/qwenpaw`. Der Befehl `copaw` funktioniert weiterhin als CLI-Alias. Wenn du noch unter dem alten Namen installiert hast, spring zu [Upgrade von CoPaw auf QwenPaw](#upgrade-von-copaw-auf-qwenpaw) weiter unten.

**Was dieser Guide abdeckt**

- Installation per pip, Ein-Zeilen-Skript oder Docker

- 14+ Cloud-Provider konfigurieren (DashScope, OpenAI, Anthropic, Gemini, DeepSeek, Kimi, OpenRouter)

- Lokale Modelle mit QwenPaw-Flash, Ollama und LM Studio betreiben

- Kanäle anbinden: Discord, Telegram, DingTalk, Lark, WeChat, iMessage und QQ

- Skills, der Plugin Market und die MCP-Integration

- Dreischichtiges Memory mit einer per Hand editierbaren Markdown-Wissensdatenbank

- Geplante Tasks, Heartbeat-Check-ins, Security-Sandbox und Backups

Wenn du Self-Hosted-KI-Assistenten vergleichst, deckt unsere [OpenClaw-Alternativen](/openclaw-alternatives/)-Zusammenstellung mehrere Projekte ab, darunter nanobot, NanoClaw und PicoClaw. Für eine leichtere Go-basierte Option, die zu einer einzigen Binary kompiliert, siehe den [PicoClaw Setup-Guide](/picoclaw-setup-guide/).

## Was QwenPaw macht

QwenPaw ist ein Self-Hosted-KI-Assistent, der auf [AgentScope](https://github.com/agentscope-ai/agentscope) und [ReMe](https://github.com/agentscope-ai/ReMe) für das Memory-Management aufbaut. Der Name steht für Qwen Personal Agent Workstation. Das Versprechen hat sich seit der ersten Version nicht geändert: ein Assistent, der sich mit deinen Messaging-Apps verbindet und Tasks zeitgesteuert erledigt, ohne dass du fragen musst.

Was sich seit meiner ersten Vorstellung geändert hat: Es gibt jetzt eine Plugin-Architektur mit Marketplace, eine MCP-Integration zum Anflanschen externer Tools, Multi-Agent-Support über ACP zum Spawnen von Sub-Agenten, eine Fullscreen-Terminal-UI und eine Desktop-App in Beta. Die Web-Console unter `http://127.0.0.1:8088/` ist weiterhin der empfohlene Ort, um alles zu konfigurieren, statt Config-Dateien blind zu editieren.

Die Architektur:

  
    
      
    
  
  
  Kanäle
  Discord, Telegram
  DingTalk, Lark
  WeChat, QQ
  iMessage
  TUI, Desktop-App
  
- 
  Nachrichten
  
  QwenPaw-Server
  läuft auf deinem VPS
  oder lokaler Maschine
  Web-Console :8088
  Memory + Scheduler
  Sandbox + Guards
  
- 
  Prompts
  
  LLM-Provider
  Cloud: DashScope,
  OpenAI, Anthropic,
  Gemini, DeepSeek,
  Kimi, OpenRouter
  lokal: QwenPaw Local,
  Ollama, LM Studio
  QwenPaw-Flash-Modelle
  2B bis 27B
  
- 
  Tools
  
  Skills und
  Plugins
  cron, Dateien,
  PDF, Office,
  Browser
  Plugin Market
  MCP-Server

QwenPaw-Architektur: Nachrichten kommen aus den Chat-Kanälen herein, der Server routet sie an das von dir gewählte LLM, und das Modell nutzt Skills und Plugins, um die Arbeit zu erledigen. Alles wird in der Web-Console auf Port 8088 konfiguriert.

### QwenPaw vs OpenClaw vs nanobot

Wenn du dich zwischen den dreien entscheidest, so stehen sie zueinander. Die OpenClaw- und nanobot-Spalten spiegeln den Stand bei meinem letzten Check wider; auch diese Projekte bewegen sich, also behandle diese Zellen als Snapshot.

| Funktion | QwenPaw | OpenClaw | nanobot |
|---|---|---|---|
| **Sprache** | Python | TypeScript | Python |
| **Entwickelt von** | AgentScope (Alibaba) | Community | HKUDS |
| **Installation** | pip / Skript / Docker / Desktop / Hosted | curl-One-Liner | pip |
| **Web-Console** | Ja (eingebaut auf :8088) | Nein (Third-Party-Dashboards) | Nein |
| **Kanäle** | DingTalk, Lark, WeChat, Discord, Telegram, iMessage, QQ | Telegram, WhatsApp, Slack, Discord | Telegram, Discord, WhatsApp, Slack, Feishu, DingTalk, E-Mail, QQ |
| **Lokale Modelle** | QwenPaw Local (llama.cpp), Ollama, LM Studio | Ollama | vLLM |
| **Memory** | Dreischichtig: Working Context, history.db + FTS5, ReMe-Wissensdatenbank | Dateibasiert + semantische Suche | Dateibasiert |
| **Skills & Plugins** | Eingebaute Skills, Plugin Market, MCP | Community-Skills | Eingebaut |
| **Geplante Tasks** | Cron + Heartbeat | Cron | Cron |
| **Zusätzliche Oberflächen** | TUI, Desktop-App, REST-API, Multi-Agent (ACP) | Keine | Keine |
| **Lizenz** | Apache 2.0 | MIT | MIT |

Wo QwenPaw vorne liegt: Die eingebaute Web-Console bedeutet, dass du keine Third-Party-Dashboards brauchst, DingTalk-/Lark-/WeChat-Support ist First-Class statt angeflanscht, und der Security-Stack (Sandbox, Tool Guard, File Guard) ist der vollständigste der drei (siehe [Sicherheit](#sicherheit-sandbox-tool-guard-und-file-guard) unten). OpenClaw gewinnt weiterhin bei westlichen Messaging-Apps wie WhatsApp und Slack. Wenn dein Team in DingTalk oder Lark lebt, spart dir QwenPaw eine Menge Config-Kopfschmerzen.

## Voraussetzungen

Vor Schritt 1 brauchst du Folgendes:

- Eine Linux-, macOS- oder Windows-Box oder einen VPS. 2 vCPU / 4 GB RAM reichen für Cloud-Modelle; lokale Modelle wollen mehr (siehe [beste Mini-PCs für lokale LLMs](/best-mini-pc-local-llm/))

- Python 3.11 bis 3.13 für den pip-Pfad oder einfach Docker (kein Python nötig)

- Einen API-Key für mindestens einen Cloud-Provider oder Hardware für lokale Modelle

- Einen Discord-, Telegram- oder DingTalk-Account, wenn du aus Chat-Apps mit ihm reden willst

- Port 8088/tcp frei auf localhost für die Web-Console

Alles andere (uv, Node.js für manche Plugins, Dependencies) erledigen die Installer.

## Installation

QwenPaw bietet sieben Wege zum Laufen: pip, das Ein-Zeilen-Skript, Docker, ein Alibaba-Cloud-ECS-One-Click-Deploy (ComputeNest), die kostenlose gehostete AgentScope Platform, einen ModelScope-Studio-Fork (den solltest du nicht-öffentlich halten) und eine [Desktop-App in Beta](https://github.com/agentscope-ai/QwenPaw/releases) für Windows 10+ und macOS 14+. Ich behandle die drei, die für Self-Hoster relevant sind.

### pip install

Der sauberste Weg, wenn du schon Python hast:

```bash
pip install qwenpaw          # requires Python >= 3.11, < 3.14
qwenpaw init --defaults
qwenpaw app
```

Öffne `http://127.0.0.1:8088/` und du siehst die Console. Das ist ein funktionierendes Basis-Setup.

Für die interaktive Konfiguration, bei der du LLM-Provider und Kanäle direkt zu Beginn auswählst:

```bash
qwenpaw init
```

Das führt dich durch Heartbeat-Intervall, Zielkanal, aktive Stunden und optionales Skill-Setup. Zwei Dinge, die es zu wissen lohnt: Der Befehl `copaw` funktioniert weiterhin als Alias für `qwenpaw`, und `init --defaults` akzeptiert die anonyme Nutzungstelemetrie automatisch, während das interaktive `init` dich fragt (Details im [FAQ](#faq)).

### One-Liner

Kein Python nötig. Der Installer erledigt alles über [uv](https://docs.astral.sh/uv/).

**macOS / Linux:**

```bash
curl -fsSL https://qwenpaw.agentscope.io/install.sh | bash
```

**Windows (PowerShell):**

```powershell
irm https://qwenpaw.agentscope.io/install.ps1 | iex
```

Öffne nach der Installation ein neues Terminal (PATH-Änderungen greifen nur in neuen Shells), dann:

```bash
qwenpaw init --defaults
qwenpaw app
```

Nützliche Installer-Flags:

```bash
# pin a version
curl -fsSL https://qwenpaw.agentscope.io/install.sh | bash -s -- --version 2.3.0

# install from source
curl -fsSL https://qwenpaw.agentscope.io/install.sh | bash -s -- --from-source

# extras: local, whisper, channels, full
# channels/full apply the channel plugin preset offline during install
curl -fsSL https://qwenpaw.agentscope.io/install.sh | bash -s -- --extras channels,whisper
```

Um später zu upgraden, führe den Installer einfach erneut aus. Er führt `qwenpaw plugins prepare-upgrade` für dich aus. Wenn du noch die alten `copaw.agentscope.io`-URLs in Skripten hast, ersetze sie: Diese Domain resolved nicht mehr.

### Docker

Das QwenPaw-Docker-Image liegt unter `agentscope/qwenpaw` (99 Tags; `latest` ist stabil, `pre` ist Pre-Release). Anders als das 1.x-Image nutzt es jetzt drei Volumes:

```bash
docker pull agentscope/qwenpaw:latest

docker run -d --name qwenpaw --restart unless-stopped \
  -p 127.0.0.1:8088:8088 \
  -v qwenpaw-data:/app/working \
  -v qwenpaw-secrets:/app/working.secret \
  -v qwenpaw-backups:/app/working.backups \
  -e DASHSCOPE_API_KEY=your_key_here \
  agentscope/qwenpaw:latest
```

- `qwenpaw-data:/app/working`: Config, Memory, Skills
- `qwenpaw-secrets:/app/working.secret`: Modell-Provider-Einstellungen und API-Keys
- `qwenpaw-backups:/app/working.backups`: Backup-Archive

Pinne `agentscope/qwenpaw:v2.3.0`, wenn du langweilige Deploys willst; `latest` bewegt sich wöchentlich. Für Nutzer in China gibt es einen ACR-Mirror: `agentscope-registry.ap-southeast-1.cr.aliyuncs.com/agentscope/qwenpaw`. Das Upstream-[docker-compose.yml](https://github.com/agentscope-ai/QwenPaw/blob/main/docker-compose.yml) ist einen Blick wert; es ergänzt `restart: always` und `init: true` sowie Console-Auth-Env-Vars.

Wenn QwenPaw in Docker Ollama auf dem Host erreichen muss:

```bash
docker run -p 127.0.0.1:8088:8088 \
  --add-host=host.docker.internal:host-gateway \
  -v qwenpaw-data:/app/working \
  -v qwenpaw-secrets:/app/working.secret \
  agentscope/qwenpaw:latest
```

Dann setze die Ollama-Base-URL in der Console auf `http://host.docker.internal:11434/v1`. Für LM-Studio-Nutzer: `http://host.docker.internal:1234/v1`. Unter Linux funktioniert auch `--network=host` (kein `-p` nötig).

**Wenn du die Console freigibst**

Der Container bindet absichtlich `127.0.0.1:8088`. Wenn du die Console je per Reverse Proxy ins Internet stellst, setze `QWENPAW_AUTH_ENABLED=true`, `QWENPAW_AUTH_USERNAME` und `QWENPAW_AUTH_PASSWORD` oder leg sie hinter die Auth deines Proxys. Besser: Gib sie gar nicht erst frei und erreich sie über einen Tunnel wie im [SSH-Port-Forwarding-Guide](/ssh-tunneling-linux/) beschrieben.

### Installation verifizieren

Geh nicht weiter, bis das alles passt:

- curl -sI http://127.0.0.1:8088 liefert HTTP 200 auf dem Host

- Die Console lädt im Browser unter http://127.0.0.1:8088/

- qwenpaw --help funktioniert in einer frischen Shell

- Settings → Models zeigt eine Provider-Karte mit Status Available und einem ausgewählten Modell

- Schick eine Testnachricht in deinem ersten Kanal und bekomme eine Antwort

Unter Docker prüfe `docker logs -f qwenpaw` beim Start und nach jedem Restart. Wenn die Console nicht lädt, läuft der Server nicht. Siehe [Troubleshooting](#troubleshooting).

### Installation auf einem Hetzner-VPS

Wenn QwenPaw 24/7 auf einem VPS laufen soll, reicht eine kleine Box. Ich nutze einen Hetzner CX22 (2 vCPU, 4 GB RAM). Aktuelle Preise stehen in meinem [Hetzner-Cloud-Review](/hetzner-cloud-review/), seit [die VPS-Preise 2026 gestiegen sind](/vps-price-increases/).

**Mit Hetzner starten**

[Hol dir 20 € Hetzner-Guthaben](https://go.bitdoze.com/hetzner) oder einen [Hostinger-VPS](https://go.bitdoze.com/hostinger-vps), wenn du dich über unsere Referral-Links anmeldest. Das deckt ein paar Monate QwenPaw-Betrieb ab.

Log dich per SSH auf deinem Server ein und führe aus:

```bash
ssh root@YOUR_SERVER_IP
apt update && apt upgrade -y
curl -fsSL https://qwenpaw.agentscope.io/install.sh | bash
```

Öffne eine neue Shell-Session, dann:

```bash
qwenpaw init --defaults
qwenpaw app
```

Damit es nach dem Schließen der SSH-Session weiterläuft, nutze systemd (eine tmux-Session geht auch, aber systemd überlebt Reboots). Finde den Binary-Pfad mit `which qwenpaw` und erstelle dann `/etc/systemd/system/qwenpaw.service`:

```ini
[Unit]
Description=QwenPaw assistant
After=network.target

[Service]
WorkingDirectory=/root/.qwenpaw
ExecStart=/root/.local/bin/qwenpaw app
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
```

```bash
systemctl daemon-reload
systemctl enable --now qwenpaw
systemctl status qwenpaw
curl -sI http://127.0.0.1:8088
```

Der letzte Befehl sollte HTTP 200 zurückgeben. Die Console bindet nur auf localhost, also verwalte sie über einen Tunnel wie im [SSH-Port-Forwarding-Guide](/ssh-tunneling-linux/): `ssh -L 8088:127.0.0.1:8088 root@YOUR_SERVER_IP`. Wenn du sie stattdessen hinter einen Reverse Proxy legst, lies die Console-Auth-Warnung im Docker-Tab oben.

### Deinstallation

```bash
qwenpaw uninstall          # keeps config and data
qwenpaw uninstall --purge  # removes everything
```

Gleiche Semantik wie früher, nur umbenannt. Unter Docker entfernt Purge die Volumes nicht. Das ist deine Aufgabe:

```bash
docker volume rm qwenpaw-data qwenpaw-secrets qwenpaw-backups
```

## Upgrade von CoPaw auf QwenPaw

Wenn du den Assistenten noch aus der Zeit unter dem alten Namen installiert hast, hier ist die Migration an einem Ort. Die Umbenennung kam mit v1.1.0 am 2026-04-12 ([Release Note](https://github.com/agentscope-ai/QwenPaw/releases/tag/v1.1.0)).

Was sich für dich ändert, lässt sich auf fünf Dinge runterbrechen. Installiere `qwenpaw`; das alte `copaw`-Paket ist bei 1.0.2 eingefroren und hat seit dem 2026-04-09 keine Updates bekommen – es wird also keine 2.x-Features erhalten. Der Befehl heißt jetzt `qwenpaw`, wobei `copaw` als Alias auf denselben Entry Point zeigt – Muskelgedächtnis funktioniert also weiter. Das Docker-Image ist von `agentscope/copaw` auf `agentscope/qwenpaw` umgezogen, und das Daten-Layout ging von einem Volume auf drei über (`working`, `working.secret`, `working.backups`). Alles lebt unter `qwenpaw.agentscope.io`; die alte Domain `copaw.agentscope.io` ist tot, aktualisiere also alle Skripte oder Cron-Jobs, die sie aufrufen. Lokale Daten liegen jetzt in `~/.qwenpaw/` (plus `~/.qwenpaw.secret/`). Wenn du Daten unter `~/.copaw` hast, geh nicht davon aus, dass sie automatisch migriert werden. Prüfe die [QwenPaw-Docs](https://qwenpaw.agentscope.io/docs), kopiere das Verzeichnis selbst rüber und bestätige, dass Memory und Config laden, bevor du irgendetwas löschst. Ich habe keinen automatischen Migrationspfad verifiziert.

## Modell-Konfiguration

Bevor QwenPaw etwas Sinnvolles tun kann, konfiguriere ein LLM. Öffne die Console unter `http://127.0.0.1:8088/` und geh zu **Settings → Models**.

### Cloud-Provider

QwenPaw funktioniert out of the box mit 14+ Cloud-Providern: DashScope/Qwen, OpenAI, Anthropic, Google Gemini, DeepSeek, Kimi, OpenRouter und mehr. Für jeden davon:

1. Geh in der Console zu **Settings → Models**
2. Finde die Provider-Karte und klick **Settings**
3. Gib deinen API-Key ein und klick **Save**
4. Der Kartenstatus wechselt zu **Available**. Das ist dein Verifizierungsschritt
5. Wähl im Abschnitt **LLM Configuration** oben Provider und Modell aus und klick **Save**

API-Keys kannst du auch als Umgebungsvariablen setzen. Für DashScope:

```bash
export DASHSCOPE_API_KEY=your_key_here
```

Oder leg sie in eine `.env`-Datei im Working Directory (`~/.qwenpaw/` bei nativen Installs, `/app/working` in Docker). Tool-Keys (z. B. ein Web-Search-Key wie `TAVILY_API_KEY`) lassen sich ebenfalls unter **Console → Settings → Environment variables** setzen.

### OpenAI oder Azure OpenAI nutzen

Alles mit einer OpenAI-kompatiblen API läuft über das Custom-Provider-System:

1. Klick auf der Models-Seite auf **Add provider**
2. Gib eine Provider-ID (z. B. `openai`) und einen Anzeigenamen ein
3. Klick **Settings**, gib die Base URL (`https://api.openai.com/v1` für OpenAI) und den API-Key ein
4. Klick **Models** und füg die Modell-ID hinzu, auf die dein Account Zugriff hat
5. Wähl es im LLM-Configuration-Dropdown aus

### Lokale Modelle: QwenPaw-Flash, Ollama und LM Studio

Lokale Backends brauchen keine API-Keys. Die alten pip-Extras pro Backend sind weg; lokale Modellunterstützung ist eingebaut.

| Backend | Am besten für | Setup |
|---|---|---|
| **QwenPaw Local** (eingebaute llama.cpp-Runtime) | Plattformübergreifend, null Config | Klick **Download** in der Web-UI; sie gibt hardwarebewusste Modell-Empfehlungen |
| **Ollama** | Alle, die Ollama schon laufen haben | Ollama installieren, Modell pullen, Kontextlänge auf mindestens 32k setzen |
| **LM Studio** | Desktop-Nutzer mit LM Studio | Den Local Server aktivieren; Base URL `http://localhost:1234/v1` (`http://host.docker.internal:1234/v1` aus Docker) |

**Ollama-Kontextlänge**

Setze Ollamas Kontextlänge für das verbundene Modell auf 32k oder mehr. Darunter bekommst du abgeschnittene Antworten und seltsame Mitten-im-Satz-Abbrüche, die wie Modellqualitätsprobleme aussehen, aber keine sind.

Die empfohlenen lokalen Modelle sind jetzt **QwenPaw-Flash** – zwecktrainierte Agenten-Modelle in den Größen 2B / 4B / 9B / 35B-A3B / 27B mit Q4- und Q8-Quantisierungen, veröffentlicht auf ModelScope und Hugging Face unter der Org `agentscope-ai/models`. Die 2B- und 4B-Varianten laufen auf bescheidener Hardware, das 9B will etwa 16 GB RAM, und das MoE 35B-A3B ist die Qualitätswahl, wenn du den Speicher hast. Für Hardware, die diese Modelle gut fährt, siehe [beste Mini-PCs für lokale LLMs](/best-mini-pc-local-llm/). Wenn du lieber eine leise Box zu Hause stehen hast statt einen VPS zu mieten: Etwas wie der [ASUS DC510 Mini-PC](https://go.bitdoze.com/asus-dc510) fährt die kleinen Modelle bequem.

v2.3.0 brachte außerdem **Piccolo**-Entscheidungsmodelle (4B/9B/27B) für optionales Tool-Review und Context Compaction. Nett zu haben, kein Setup-Blocker.

Modell-Downloads laufen in der Web-UI: **Settings → Models**, dann **Download** auf der QwenPaw-Local-Karte. Für Ollama pullst du Modelle wie gewohnt über Ollama (`ollama pull qwen3:4b`), und QwenPaw synct sich mit allem Verfügbaren. Siehe das [Ollama-Docker-Compose-Setup mit Open WebUI](/ollama-docker-install/), wenn du Ollama im Container fährst.

### Kostenvergleich

Ich drucke hier keine Dollarbeträge ab. Provider-Preise bewegen sich zu schnell, um sie ehrlich abzudrucken, und die alten Zahlen in diesem Guide sind schlecht gealtert. Was wahr bleibt:

| Weg | Beispiel | Kostenprofil |
|---|---|---|
| DashScope | Qwen-Modelle | Günstigster Cloud-Einstieg bei den meisten Workloads |
| OpenAI / Anthropic / Gemini | Frontier-Modelle | Höher pro Token, beste Rohqualität |
| Lokal (QwenPaw-Flash) | QwenPaw-Flash 4B oder 9B | Null API-Kosten, nur Strom und Hardware |
| Lokal (Ollama / LM Studio) | Qwen3 4B und Freunde | Null API-Kosten, derselbe Vorbehalt |

Wenn dein Assistent eine Handvoll geplanter Jobs fährt und ein paar Mal am Tag chattet, bleiben Cloud-Rechnungen im einstelligen Dollar-Bereich pro Monat. Wenn er den ganzen Tag Dokumente verarbeitet, geh lokal.

## Channel-Setup: Discord, Telegram, DingTalk und mehr

Kanäle sind der Weg, wie du aus deinen Messaging-Apps mit QwenPaw redest. Seit v2.3.0 sind Kanäle Plugins: Die Installer-Extras `channels` und `full` führen `qwenpaw plugins preset apply channels-full --offline` aus, und die Console (**Control → Channels**) ist der Ort, an dem du sie aktivierst und konfigurierst.

*Config-Key-Namen können sich zwischen Releases verschieben. Speichere den Kanal zuerst in der Console und schau dann in die `config.json` in deinem Working Directory, um die aktuelle Form zu sehen. Die Snippets unten zeigen das 2.x-Layout, keinen Vertrag.*

### Discord

1. Erstelle eine Discord-Application unter [discord.com/developers](https://discord.com/developers/applications)
2. Geh zum **Bot**-Tab, klick **Reset Token** und kopier das Bot-Token
3. Aktiviere unter **Privileged Gateway Intents** den **Message Content Intent**
4. Generier eine OAuth2-Einladungs-URL mit `bot`-Scope und den Permissions `Send Messages` + `Read Message History`
5. Lad den Bot auf deinen Server ein
6. Geh in der QwenPaw-Console zu **Control → Channels**, klick **Discord**, aktiviere ihn und füg das Token ein

```json
{
  "channels": {
    "discord": {
      "enabled": true,
      "token": "YOUR_DISCORD_BOT_TOKEN"
    }
  }
}
```

Verifizieren: Schick dem Bot eine DM und erwarte eine Antwort. Keine Antwort plus stilles Log bedeutet meist, dass der Message Content Intent aus ist.

### Telegram

1. Öffne Telegram, such nach **@BotFather**, schick `/newbot`
2. Wähl Name und Username, kopier das Token
3. Aktiviere in der Console Telegram und füg das Token ein

```json
{
  "channels": {
    "telegram": {
      "enabled": true,
      "token": "YOUR_TELEGRAM_BOT_TOKEN"
    }
  }
}
```

Verifizieren: Schreib deinem Bot und bestätige, dass die erste Antwort ankommt.

### DingTalk

Das DingTalk-Setup umfasst das Erstellen einer Custom App in der DingTalk-Developer-Console. QwenPaw hat einen eingebauten Skill namens `dingtalk_channel_connect`, der dich durch Credential-Lookup, Client-ID/Secret-Konfiguration und die manuellen Schritte führt. Aktiviere den DingTalk-Kanal in der Console und folge den geführten Prompts.

### Feishu (Lark)

Gleiche Idee wie DingTalk. Erstelle eine App in der Lark- (Feishu-)Open-Platform, hol dir App-ID und App-Secret und trag sie in der Console ein. QwenPaw unterstützt für Lark auch einen SOCKS-Proxy, falls du hinter einer Firmen-Firewall sitzt.

### WeChat und QQ

WeChat ist eine neuere Ergänzung der Channel-Reihe, und QQ ist von Anfang an dabei. Das Setup unterscheidet sich je nach Region und Plattform-Policy, also werde ich nicht so tun, als wären die Schritte stabil. Die [Channel-Docs](https://qwenpaw.agentscope.io/docs/channels) haben den aktuellen Flow. Erwarte, dass du eine plattformseitige App erstellst und Credentials in die Console einfügst wie bei den anderen Kanälen.

### iMessage (nur macOS)

Wenn du QwenPaw auf einem Mac fährst, funktioniert iMessage als Kanal. Das ist immer noch einer der wenigen Self-Hosted-Assistenten mit nativem iMessage-Support.

### Mehrere Kanäle gleichzeitig

QwenPaw kann sich mit mehreren Kanälen gleichzeitig verbinden. Nachrichten gehen an den Kanal, in dem du zuletzt geredet hast, oder du zielst geplante Nachrichten auf bestimmte Kanäle.

## Skills und Plugins

Skills sind der Weg, wie QwenPaw mehr kann als chatten. Einige sind eingebaut, und seit 2.x gibt es eine Plugin-Architektur mit Marketplace und MCP-Integration. Diese Erweiterbarkeit ist jetzt das Headline-Feature.

### Eingebaute Skills

Core-Skills ab v2.3.0:

| Skill | Was er tut |
|---|---|
| **cron** | Geplante Jobs: erstellen, auflisten, pausieren, fortsetzen, löschen |
| **file_reader** | Textdateien lesen und zusammenfassen (.txt, .md, .json, .csv, .py usw.) |
| **pdf** | PDFs lesen, extrahieren, mergen, splitten, rotieren, mit Wasserzeichen versehen, OCR |
| **docx** | Word-Dokumente erstellen, lesen und bearbeiten |
| **xlsx** | Spreadsheets lesen, bearbeiten und erstellen |
| **pptx** | PowerPoint-Dateien erstellen, lesen und bearbeiten |
| **news** | Aktuelle News aus konfigurierten Quellen holen und zusammenfassen |
| **browser_visible** | Einen sichtbaren Browser für Demos oder CAPTCHA-Szenarien starten |

v2.1.0 bis v2.3.0 ergänzten browser-use, computer-use und den Code Mode obendrauf.

### Skills in der Console verwalten

Geh in der Console zu **Agent → Skills**, um alle geladenen Skills zu sehen, sie ein- oder auszuschalten, eigene Skills zu erstellen oder bestehende zu bearbeiten.

### Skills aus Hubs importieren

Der offizielle Plugin Market (vereinheitlichter Marketplace seit v2.2.0) ist die erste Anlaufstelle. Community-Hubs wie `skills.sh`, `clawhub.ai` und `skillsmp.com` funktionierten mit 1.x, und der zugrunde liegende Mechanismus ist der Import aus jedem GitHub-Repo mit einer `SKILL.md`-Datei. Was das aktuelle Release offiziell unterstützt, steht in den [Skills-Docs](https://qwenpaw.agentscope.io/docs/skills).

**Nicht vertrauenswürdige Skills laufen auf deiner Box**

Ein Skill ist Code und Instruktionen, die mit den Berechtigungen deines Agenten ausgeführt werden. Fahr Tool Guard im STRICT-Modus, während du Third-Party-Skills evaluierst, und nutze den Skill Scanner (siehe [Sicherheit](#sicherheit-sandbox-tool-guard-und-file-guard) unten).

### Eigene Skills erstellen

Leg einen Ordner mit einer `SKILL.md`-Datei in `~/.qwenpaw/customized_skills/` ab (der Pfad folgt dem Working Directory, in Docker also unter `/app/working`):

```
~/.qwenpaw/
  customized_skills/
    my_research_skill/
      SKILL.md
```

Die `SKILL.md` ist schlichtes Markdown, das beschreibt, was der Skill tut:

```markdown
---
name: my_research_skill
description: Research a topic and summarize findings
---

# Research Skill

When asked to research something:
1. Search the web for current information
2. Summarize key findings in bullet points
3. List sources
```

QwenPaw pickt neue Skills beim Restart auf. Eigene Skills haben Vorrang vor eingebauten, wenn Namen kollidieren. Für ein Praxisbeispiel, wie ein eigener Skill aussieht, siehe meinen [Docker-AI-Deploy-Skill-Guide](/ai-docker-deploy-skill/).

### Plugins, der Marketplace und MCP

Seit v2.3.0 sind Kanäle selbst Plugins, und **Settings → Plugins** ist der Hub: aus dem Plugin Market installieren, Presets verwalten und **MCP-Server** als Tool-Provider anbinden. Wenn du anderswo in deinem Stack MCP-Tools nutzt, so verwendest du sie in deinem Assistenten wieder.

Zwei Plugins sind relevant, wenn du Coding-Agenten fährst: Die **Codex**- und **Qoder**-Backends sind optionale Installs über **Settings → Plugins** (das Installer-Extra `full` schließt ihre SDKs aus, installiere sie also explizit). Es gibt [Migrationshinweise für die optionalen Codex- und Qoder-Backends](https://qwenpaw.agentscope.io/docs/plugins#optional-codex-and-qoder-backends) in den Docs. Wenn ein Plugin-Install abbricht, sieh unten in [Troubleshooting](#abgebrochene-plugin-oder-skill-installation) nach, bevor du blind neu ausführst.

## Memory-System

QwenPaws Memory ist der Teil, der ihn eher wie einen Assistenten statt wie einen Chatbot wirken lässt. Seit v2.0.0 läuft es auf drei Schichten:

1. Der **Live-Working-Context** ist die aktuelle Konversation und was der Agent gerade tut.
2. Die **vollständige wörtliche History** ist eine SQLite-`history.db` mit FTS5-Volltextsuche, 30-Tage-Standard-Retention und usage-bewusstem Ranking (Recency plus Frequency). Alte Turns lassen sich über die `recall_history_python`-REPL abrufen. v2.2.1 brachte Auto Fin, einen proaktiven Memory-Review-Pass; v2.3.0 ergänzte Bild-Memory und Tag-Browsing.
3. Die **sich selbst weiterentwickelnde Wissensdatenbank** wird von [ReMe](https://github.com/agentscope-ai/ReMe) v0.4.0 gestützt. Sie schreibt Memory während des Betriebs (turn-basiert, nicht am Session-Ende) und speichert sie als Markdown, das du per Hand lesen und editieren kannst.

Die letzte Schicht ist die, die es zu kennen lohnt. Sie sieht so aus:

```
~/.qwenpaw/
  MEMORY.md                    # Long-term facts, preferences, decisions
  memory/
    2026-11-15.md              # Daily log
    2026-11-14.md
    ...
```

`MEMORY.md` hält persistente Informationen: Dinge wie „Ich bevorzuge Python 3.12" oder „Mein Team nutzt Slack für Standups". Daily Logs erfassen, was in jeder Konversation passiert ist. Die Suche über alles ist hybrid: vektor-semantische Suche plus Volltext, und seit v2.0.0 wird das Embedding-Modell in der Config-UI ausgewählt statt über einen Haufen Umgebungsvariablen.

Sag ihm direkt, was er sich merken soll:

> „Merke dir: Ich deploye immer zuerst auf Staging, dann auf Production."

Das schreibt er in `MEMORY.md`. Du kannst die Dateien selbst editieren, wann immer der Agent etwas falsch bekommt:

```bash
nano ~/.qwenpaw/MEMORY.md
```

## Geplante Tasks und Heartbeat

QwenPaw führt Dinge auf zwei Arten zeitgesteuert aus: Cron-Jobs für spezifische Befehle und Heartbeat für periodische Check-ins.

### Cron-Jobs

```bash
# Create a job that runs at 9am every day
qwenpaw cron create --type agent --name "morning-digest" --cron "0 9 * * *" --message "Summarize my pending tasks and calendar for today"

# List all jobs
qwenpaw cron list

# Check a job's state
qwenpaw cron state <job_id>
```

Cron-Jobs kannst du auch in der Console unter **Control → Cron Jobs** verwalten. Die volle Flag-Liste deiner Version zeigt `qwenpaw cron --help`. Verifizieren: `qwenpaw cron list` zeigt den Job nach dem Erstellen.

### Heartbeat

Heartbeat ist der geplante Check-in. Du schreibst einen Block von Fragen in eine Markdown-Datei, und QwenPaw geht sie zeitgesteuert durch und schickt die Antworten an deinen zuletzt genutzten Kanal. Richte es während `qwenpaw init` ein oder editiere `HEARTBEAT.md` im Working Directory.

Beispiel-`HEARTBEAT.md`:

```markdown
Check the following and report back:
- Any new emails from clients?
- What meetings do I have today?
- Summarize overnight GitHub notifications
```

Intervall und aktive Stunden liegen in den Console-Settings oder in `config.json` (Key-Namen haben sich zwischen Releases verschoben, bestätige die Form also in deiner eigenen Datei, nachdem du es in der UI gesetzt hast):

```json
{
  "heartbeat": {
    "enabled": true,
    "interval": "2h",
    "active_hours": "08:00-22:00"
  }
}
```

Verifizieren: Warte, bis der erste Heartbeat in deinem Kanal landet. Wenn nichts ankommt, prüfe, ob ein Zielkanal konfiguriert ist und die aktiven Stunden die aktuelle Zeit abdecken.

## Sicherheit: Sandbox, Tool Guard und File Guard

Ein Agent, der Tools auf deiner Box ausführt, ist zuerst eine Blast-Radius-Frage. QwenPaw liefert einen fünfschichtigen Security-Stack. Er ist das stärkste Argument, ihn statt der Alternativen zu wählen, wenn du Third-Party-Skills laufen lassen willst:

| Schicht | Was sie tut |
|---|---|
| **Sandbox** | Isolation auf Kernel-Ebene für Tool-Ausführung: Seatbelt auf macOS, Bubblewrap + Landlock auf Linux, AppContainer auf Windows |
| **Tool Guard** | YAML-Regeln mit Genehmigungsstufen: STRICT / SMART / AUTO / OFF |
| **File Guard** | Schützt standardmäßig `~/.qwenpaw.secret/` und `~/.ssh` vor Skill- und Plugin-Zugriff |
| **Skill Scanner** | Prüft Skills vor dem Ausführen: block / warn / off |
| **Access Policy** | Beschränkt, was der Agent überhaupt erreichen kann |

Praktische Defaults, die ich nutzen würde: Fahr Tool Guard auf STRICT, solange du Skills evaluierst, die du nicht selbst geschrieben hast, halte API-Keys im geschützten Secrets-Verzeichnis (das Docker-Layout trennt `working.secret` genau aus diesem Grund in ein eigenes Volume) und lass den Skill Scanner auf block. Für das breitere Threat-Model nicht vertrauenswürdiger Skills in Self-Hosted-Agenten deckt mein [OpenClaw-Security-Guide](/openclaw-security-guide/) dasselbe Blast-Radius-Framing aus dem Blickwinkel des anderen Projekts ab.

## Backups, Updates und Day-2-Betrieb

**Sichere drei Dinge**

Config, Memory und Skills liegen in working. API-Keys und Provider-Einstellungen liegen in working.secret. Backup-Archive liegen in working.backups. Diese drei zählen.

Unter Docker schnappst du alle drei Volumes in einem Tar:

```bash
docker run --rm \
  -v qwenpaw-data:/data \
  -v qwenpaw-secrets:/secrets \
  -v qwenpaw-backups:/backups \
  -v "$PWD":/backup alpine \
  tar czf /backup/qwenpaw-$(date +%F).tar.gz data secrets backups
```

Nativ:

```bash
tar czf qwenpaw-$(date +%F).tar.gz ~/.qwenpaw ~/.qwenpaw.secret
```

Die offiziellen [Backup-Docs](https://qwenpaw.agentscope.io/docs/backup) decken den Restore ab. Plane das Tar per cron und push es auf S3 oder welches Offsite-Ziel du schon vertraust.

Updates: `pip install -U qwenpaw` für pip-Installs, Installer erneut ausführen für den Skript-Pfad (er handhabt Plugin-Upgrades) oder Image neu pullen für Docker. Pinne `agentscope/qwenpaw:v2.3.0` in der Compose-Datei, wenn du Release Notes vor dem Umstieg lesen willst. `latest` ändert sich wöchentlich, und dieses Projekt ging in vier Monaten von 2.0.0 auf 2.3.0, mit wöchentlichen Betas dazwischen. Lies die [Release Notes](https://github.com/agentscope-ai/QwenPaw/releases), bevor du eine Minor-Version überspringst.

Eine Offenlegung für die Ops-Crowd: `qwenpaw init --defaults` akzeptiert anonyme Nutzungstelemetrie automatisch (einmal pro Version, keine persönlichen Daten). Das interaktive `init` fragt zuerst. Details im FAQ.

## CLI-Referenz

| Befehl | Beschreibung |
|---|---|
| `qwenpaw init` | Interaktiver Setup-Wizard |
| `qwenpaw init --defaults` | Schnell-Setup mit Defaults |
| `qwenpaw app` | Server und Web-Console starten |
| `qwenpaw cron list` | Geplante Jobs auflisten |
| `qwenpaw cron create` | Neuen geplanten Job erstellen |
| `qwenpaw cron state ` | Status eines Jobs prüfen |
| `qwenpaw plugins` | Plugins und Presets verwalten |
| `qwenpaw plugins prepare-upgrade` | Ein Upgrade vorbereiten (der Installer führt das aus) |
| `qwenpaw uninstall` | QwenPaw entfernen (behält Daten) |
| `qwenpaw uninstall --purge` | QwenPaw und alle Daten entfernen |

Der `copaw`-Alias zeigt weiterhin auf dieselbe CLI. `qwenpaw --help` zeigt die volle Befehlsliste deiner Version.

## Troubleshooting

### Console lädt nicht / QwenPaw reagiert nicht

Wenn `http://127.0.0.1:8088/` nicht lädt:

1. Läuft der Prozess? (`systemctl status qwenpaw` oder `docker ps`)
2. Ist der Port belegt? `ss -ltnp | grep 8088`. Ein übrig gebliebener Prozess oder ein `--network=host`-Run kann ihn besetzen
3. Prüfe die Terminal-Ausgabe oder `docker logs qwenpaw` auf Startfehler
4. Wenn die Console lädt, aber nichts funktioniert, geh zu **Settings → Models** und verifiziere, dass ein Provider **Available** ist und ein Modell ausgewählt ist

### API-Key-Probleme

Wenn du Authentifizierungsfehler siehst:

- Prüfe den API-Key unter **Settings → Models** doppelt
- Für DashScope verifiziere den Key unter [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com/)
- Versuch, den Key als Umgebungsvariable zu setzen: `export DASHSCOPE_API_KEY=xxx`
- Denk dran: Docker-Env-Vars greifen nur, wenn sie bei `docker run` oder in der Compose-Datei gesetzt sind

### Docker erreicht Ollama nicht

Innerhalb eines Containers zeigt `localhost` auf den Container, nicht auf den Host. Nutze `--add-host=host.docker.internal:host-gateway` und setze die Ollama-Base-URL auf `http://host.docker.internal:11434/v1`.

Unter Linux kannst du auch `--network=host` nutzen:

```bash
docker run --network=host \
  -v qwenpaw-data:/app/working \
  -v qwenpaw-secrets:/app/working.secret \
  agentscope/qwenpaw:latest
```

Und setze Ollamas Kontextlänge auf mindestens 32k, sonst triffst du das Abschneide-Problem unten.

### Kanal empfängt keine Nachrichten

- Verifiziere, dass der Kanal unter **Control → Channels** aktiviert ist
- Prüfe, ob Tokens und Credentials korrekt sind
- Bei Discord stell sicher, dass **Message Content Intent** im Developer-Portal aktiviert ist
- Starte QwenPaw nach Channel-Config-Änderungen neu

### Abgeschnittene oder seltsame Antworten lokaler Modelle

Wenn lokale Modell-Antworten mitten im Satz abbrechen oder den Faden einer langen Anfrage verlieren, ist die übliche Ursache eine Ollama- oder LM-Studio-Kontextlänge unter 32k. Prüfe die Kontext-Einstellungen des Modells auf der Serving-Seite, nicht in QwenPaw.

### Windows-Eigenheiten

Auf LTSC-Editionen oder mit Constrained Language Mode aktualisiert der Installer eventuell den PATH nicht. Füg `%USERPROFILE%\.qwenpaw\bin` und das uv-Verzeichnis manuell hinzu. Der erste Start der Desktop-App dauert 10 bis 60 Sekunden. Das ist normal, kein Hänger.

### Abgebrochene Plugin- oder Skill-Installation

Wenn ein Plugin- oder Skill-Install auf halbem Weg stirbt, führe den Installer erneut aus (er fährt `qwenpaw plugins prepare-upgrade` beim Upgrade) oder wende das Preset von Hand erneut an:

```bash
qwenpaw plugins preset apply channels-full --offline
```

Dann neu starten und in **Settings → Plugins** nach den erwarteten Einträgen schauen.

## FAQ

**Häufig gestellte Fragen**

**Was ist mit CoPaw passiert?**

Das Projekt wurde mit v1.1.0 am 2026-04-12 in QwenPaw umbenannt. Gleiches Team (AgentScope, Alibaba), gleiche Codebasis, neuer Name. Das pip-Paket heißt jetzt `qwenpaw` (das alte ist bei 1.0.2 eingefroren), das Docker-Image ist `agentscope/qwenpaw`, und der Befehl `copaw` funktioniert weiterhin als CLI-Alias. Alte GitHub-Links redirecten. Die URL dieses Guides hat den Original-Slug behalten, deshalb steht dort immer noch `copaw-setup-guide`.

**Muss ich Python können?**

Nein. Der Ein-Zeilen-Installer, Docker und die Desktop-App brauchen kein Python. Nur der Pfad `pip install qwenpaw` tut es, und der will Python 3.11 bis 3.13. Python-Kenntnisse sind nur relevant, wenn du eigene Skills schreibst oder aus dem Source installierst.

**Mit welchem Cloud-Provider sollte ich anfangen?**

DashScope ist der Default und meist der günstigste Einstieg. Wenn du schon einen OpenAI-, Anthropic- oder Gemini-Key hast, füg ihn hinzu und leg los. Für null API-Kosten nutze QwenPaw Local oder Ollama mit einem lokalen Modell.

**Läuft es auf einem Raspberry Pi?**

Als Relay zu Cloud-Modellen auf einem Pi 4 oder 5 mit 4 GB RAM völlig ok. Schwach bei lokalen Modellen; selbst QwenPaw-Flash 4B wird langsam sein. Ein günstiger VPS oder ein gebrauchter Mini-PC ist das bessere Erlebnis.

**Funktioniert es unter Windows?**

Ja. Nutze den PowerShell-Installer (`irm https://qwenpaw.agentscope.io/install.ps1 | iex`), Docker oder die [Desktop-App in Beta](https://github.com/agentscope-ai/QwenPaw/releases) (Windows 10+, kein Python nötig). Der pip-Pfad funktioniert auch, wenn du Python 3.11+ hast. Auf LTSC siehe die Windows-Eigenheiten-Notiz im Troubleshooting.

**Können mehrere Leute eine Instanz nutzen?**

Zwei Optionen. QwenPaw antwortet in dem Kanal, in dem du zuletzt geredet hast – Gruppenkanäle in DingTalk, Lark oder Discord funktionieren also für geteilte Nutzung. Für echte Multi-User-Isolation brachte v2.2.0 QwenPaw Hub, einen Self-Hosted-Multi-User-Modus.

**Sind meine Daten privat?**

Deine Config, dein Memory, deine Konversationen und Dateien bleiben auf deiner Maschine, und die einzigen externen Calls gehen an den LLM-Provider, den du konfiguriert hast. Mit lokalen Modellen verlässt nichts die Box. Ein ehrlicher Vorbehalt: `qwenpaw init` sendet einmal pro Version anonyme Nutzungsdaten (Version, Install-Methode, OS, Python-Version, Architektur, GPU ja/nein; keine persönlichen Daten, keine IP, keine Dateien). `init --defaults` akzeptiert automatisch; das interaktive `init` fragt dich. Prüfe die Docs fürs Opt-out, wenn dir der Prompt wichtig ist.

**Wie schlägt es sich gegen OpenClaw?**

OpenClaw hat breiteren westlichen Messaging-Support (WhatsApp, Slack). QwenPaw hat First-Class-DingTalk-, Lark- und WeChat-Support, eine eingebaute Web-Console, drei lokale Modell-Backends und einen echten Security-Stack. Beide sind Open Source und self-hosted. Für die andere Seite siehe meinen [OpenClaw Setup-Guide](/clawdbot-setup-guide/).

QwenPaw ist einen Versuch wert, wenn du einen Self-Hosted-Assistenten mit einer richtigen Web-UI willst, statt JSON-Dateien blind zu editieren. Die eingebaute QwenPaw-Local-Runtime plus Ollama- und LM-Studio-Support bedeuten, dass du es mit null API-Kosten fahren kannst – und wenn dein Team in DingTalk oder Lark lebt, ist es die ausgereifteste Option, die ich für diese Plattformen gefunden habe.

Für andere Self-Hosted-Assistenten-Optionen schau in unsere [OpenClaw-Alternativen](/openclaw-alternatives/)-Zusammenstellung. Wenn du etwas willst, das zu einer einzigen Binary kompiliert und auf einem 10-$-Board läuft, deckt das der [PicoClaw Setup-Guide](/picoclaw-setup-guide/) ab. Für einen sich selbst verbessernden Assistenten mit Voice Mode und Session-Suche siehe den [Hermes Agent Setup-Guide](/hermes-agent-setup-guide/). Und um lokale Modelle hinter einem dieser Assistenten zu fahren, hat unser [Ollama-Docker-Compose-Setup mit Open WebUI](/ollama-docker-install/) die Details.