# KI-Arbeitsplatz fürs Studium: Recherche, Lernen und mehr

**Zielgruppe:** Medizinstudenten und andere, die eine produktive Linux-Umgebung unter ChromeOS einrichten wollen. Andere Betriebssysteme wie Linux, Mac OS, Windows sind möglich, aber bisher nicht getestet.
**Stand:** 4. September 2026
**Status:** ✅ Die Installationsanleitung ist im Grunde abgeschlossen und wurde dreimal getestet. Trotzdem sind Rückmeldungen (logies@web.de) zu erfolgreichen oder problematischen Installationen ausdrücklich erwünscht! Eventuelle Installationsprobleme sollte die unten installierte KI aber selbst lösen können. Obwohl mehrfach geprüft, erfolgt das Umsetzen dieser Anleitung natürlich auf eigene Gefahr.
**System:** Debian 13 (Trixie) via ChromeOS Crostini
**Lizenz:** CC0 — frei verwendbar, ohne Namensnennung

---

## 1. Einleitung

Dieser Guide beschreibt die Einrichtung einer ChromeOS-Crostini-Linux-VM als Arbeitsplatz fürs Studium. Er ist so geschrieben, dass du ihn von Anfang bis Ende durcharbeiten kannst — am besten auf einem Chromebook mit der Linux-VM.

**Wofür sich der ganze Aufwand lohnt:** Am Ende kannst du deinem Assistenten einen kompletten Rechercheauftrag geben, den er **selbständig erfüllt** — ohne dass du irgendwo klicken musst, beispielsweise:

```
Lade mir Arbeiten zur Prüfungsangst und Bewältigungsstrategien dafür herunter, lese die Volltexte und fasse sie kritisch in einer Zotero-Notiz zusammen, konvertiere diese Notiz dann auch in eine PDF-Datei und hänge Notiz und PDF an ein erstelltes Item vom Typ Dokument an, dem du einen treffenden Titel gegeben hast.
```

Kein einziges Detail musst du dazusagen: Dass die Quellen über **OpenAlex** identifiziert werden, dass die Zusammenfassung **kritisch** gewichtet ist und welchen **Aufbau und welches Format** die Notiz hat — all das sind Konventionen aus den Memory-Dateien, die dein Assistent in §3.2 übernommen hat. Für die PDF-Konvertierung braucht er die Werkzeuge aus §6.4.

**Hinweis für andere Betriebssysteme:** Diese Anleitung ist speziell für ChromeOS Crostini geschrieben. Eine KI kann sie jedoch problemlos auf Windows, macOS oder andere Linux-Varianten übertragen — sag ihr einfach: *„Passe diese Anleitung für Windows/macOS an und arbeite sie Schritt für Schritt ab."*

**Besonderheit:** Die Einrichtung beginnt mit dem KI-Assistenten **Qwen Code**, weil er dir bei der Installation der restlichen Werkzeuge helfen kann. Sobald Qwen Code und sein Gedächtnis (Memory-MCP) laufen, kannst du ihn bitten, Zotero, Anki und die anderen Programme für dich zu installieren — und optional (§13) rclone.

**Was dich erwartet:**
- KI-Assistent (Qwen Code) mit Gedächtnis (Memory-MCP)
- Cloud-Speicher (Google Drive via rclone, optional — §13)
- Uni-VPN (Cisco Secure Client)
- Literaturverwaltung (Zotero)
- Lernkarteien (Anki) fürs Studium
- Notizen & Wissensmanagement (Zotero + Marktext)

---

## 2. Ersteinrichtung der Linux-VM

### 2.1 VM erstellen

1. ChromeOS → Terminal (Terminal-App) öffnen
2. „Linux-VM einrichten" — Debian wird automatisch bereitgestellt
3. Warten, bis die Einrichtung abgeschlossen ist

### 2.2 System aktualisieren

Öffne das Terminal. Kopiere den Befehlskasten unten **in einem Rutsch** über den **Kopieren**-Button rechts oben im Kasten und füge ihn komplett ein — die Zeilen werden der Reihe nach ausgeführt. **Welche Tastenkombination zum Einfügen funktioniert, hängt von deinem System ab** — probiere aus:
- **Strg+V** (ChromeOS-Terminal, die meisten Linux-Terminals)
- **Strg+Umschalt+V** (manche Linux-Terminals)
- Rechtsklick → Einfügen (immer)

**Gut zu wissen:** `sudo` fragt unter ChromeOS/Crostini **nicht nach einem Passwort** — die Befehle starten ohne Rückfrage.

```bash
sudo apt update
sudo apt upgrade -y
sudo apt install -y git
```

### 2.3 Standard-Programme installieren

Folgende Programme sind nützlich für den Alltag und werden auf einem frischen Crostini-System noch nicht mitgeliefert:

```bash
sudo apt install -y firefox-esr firefox-esr-l10n-de
sudo apt install -y keepassxc
sudo apt install -y doublecmd-gtk
sudo apt install -y pavucontrol
sudo apt install -y sqlite3
sudo apt install -y vim
sudo apt install -y python3-venv python3.13-venv
```

Die letzte Zeile (`python3-venv`) ist die Voraussetzung für das KI-Gedächtnis (§3.2) — auf einem frischen Debian schlägt die Einrichtung sonst mit kryptischer Meldung fehl.

**Wo findest du die installierten Programme?** Im **ChromeOS-App-Menü** (Kreis-Symbol unten links) im Ordner **Linux-Apps** — alle Programme aus der VM erscheinen dort automatisch direkt nach der Installation: die apt-Programme oben genauso wie die späteren Flatpak-Programme (Anki, Marktext, Zotero).

**Hinweis zu Double Commander:** Beim Kopieren auf das Google Drive (nativer Drive-Zugriff oder rclone-Mount, §13) erst das Zielfenster anklicken, damit es aktiv wird — dann funktioniert der Kopiervorgang.

**Google Drive in der VM nutzen — so geht es zuerst (ohne rclone):** Aktiviere in der **Dateien-App von ChromeOS** (Google-Dateimanager) in der linken Seitenleiste **Google Drive**. Klicke dann in Google Drive mit der **rechten Maustaste auf den gewünschten Ordner** und gib ihn **für Linux frei** — nur so freigegebene Ordner erscheinen in der VM unter `/mnt/chromeos/GoogleDrive/`. Damit kannst du z. B. die KeePassXC-Passwortdatei auf Google Drive ablegen und sie aus der VM zuverlässig öffnen, auf allen Geräten am gleichen Stand. **Erst wenn diese native Freigabe nicht stabil läuft** (Sync-Konflikte, hängende Zugriffe), weiche auf die komfortablere, aber aufwändigere rclone-Einbindung aus (§13).

### 2.4 Sprache auf Deutsch umstellen

```bash
sudo apt install -y locales-all
sudo update-locale LANG=de_DE.UTF-8 LANGUAGE=de_DE
sudo apt install -y manpages-de
sudo apt install --no-install-recommends -y task-german-desktop
```

**Damit die neue Sprache übernommen wird, muß die Linux-VM heruntergefahren werden:** Rechtsklick auf das Terminalsymbol → **Linux herunterfahren** — danach das Terminal wieder öffnen (es startet die VM neu). Ein bloßes Schließen und Neuöffnen des Terminal-Fensters reicht nicht: die VM liest die Spracheinstellung erst beim Start ein.

### 2.5 Speicherplatz vergrößern (empfohlen)

Die Linux-VM verwaltet ihren Speicher dynamisch, aber die Standard-Reserve ist für Studium und KI-Tools knapp bemessen. Besser 15–20 GB einstellen:

ChromeOS → Einstellungen → Linux → Speicher anpassen → 15 GB — die Vergrößerung greift **im laufenden Betrieb**; ein Neustart ist nicht nötig.

### 2.6 Zotero.org-Konto + Zotero-Cloud-API-Key (Vorbereitung)

Zwei Bausteine dieser Anleitung brauchen später deinen persönlichen Zotero-Zugang: die Zotero-Synchronisation (§6.1) und das Cloud-Backup des KI-Gedächtnisses (§12.3). Lege beides jetzt schon an — genau wie dein KI-Agenten-Key (§3.1) gehören Konto und Key zu deinen persönlichen Zugangsdaten:

1. **Konto anlegen:** kostenlos unter [zotero.org](https://www.zotero.org) (Name + E-Mail genügen).
2. **Cloud-API-Key erstellen:** eingeloggt unter [zotero.org/settings/keys/new](https://www.zotero.org/settings/keys/new): Beschreibung frei wählbar (z. B. „KI-Gedächtnis-Backup“), **Allow library access** aktivieren mit **Lese-/Schreibrecht** und **Notizenzugriff** — mehr braucht dieser Schlüssel nicht, denn er bedient nur das KI-Gedächtnis-Backup (§12.3), das ausschließlich Notizen in Zotero schreibt. Deine Zotero-Inhalte selbst — Literatur **inklusive aller PDF-Dateien** — sichert die Zotero-Synchronisation vollständig in die Cloud (§6.1): Nur damit hast du ein vollständiges Backup aller Zoteroinhalte, und genau dafür ist der Cloud-Speicher deines Kontos da. Key erzeugen und griffbereit notieren.
3. **Key ablegen:** Der Key wird später in der Datei `~/.qwen/zotero-api-key` liegen (Rechte 600) — in §12.3 bittest du deinen KI-Agenten, ihn dort abzulegen.

**Nicht verwechseln:** Diesen Cloud-Key braucht nur der Zugang zu zotero.org von außen (§12.3). Die lokale Zotero-Schnittstelle aus §6.1 arbeitet **ohne jeden Key** — dort genügen die zwei Schalter in Zoteros Konfiguration.

---

## 3. KI-Assistent (Qwen Code)

Jetzt wird es spannend: Der KI-Assistent hilft dir ab hier bei der Einrichtung deiner Lernumgebung.

**Empfohlenes Setup:** Das Modell **deepseek-v4-flash** ist eine pragmatische Entscheidung: Es ist relativ gut und günstig, wird in Qwen Code direkt angeboten, und die Installationsanleitung arbeitet es recht zuverlässig ab — nicht unbedingt perfekt im 1. Anlauf. Diese Anleitung wurde mit **glm-5.3-flash** geschrieben, das gründlicher nachdenkt und für die Installation besonders empfohlen werden kann — sofern man den Aufwand für einen weiteren API-Key und die Umstellung von Qwen Code auf OpenRouter oder z.ai als Anbieter von glm-5.3-flash schon zu Beginn nicht scheut.

### 3.1 Qwen Code installieren

Die vollständige Installationsanleitung findest du auf der folgenden Seite — **dort entlang klicken und die Anleitung befolgen**:

👉 [**www.logies.de/ki-agent-einstieg.html**](https://www.logies.de/ki-agent-einstieg.html)

Dort wird Schritt für Schritt erklärt:
1. API-Token holen (Alibaba ModelStudio)
2. Qwen Code herunterladen und installieren
3. Starten und Modell wählen
4. Gedächtnis (Memory-MCP) einrichten — **das machst du im nächsten Abschnitt**

Die Seite wird regelmäßig aktualisiert, wenn sich die Tools weiterentwickeln.

**Beim ersten Start:** Qwen Code öffnet einen Einrichtungsdialog („Connect a Provider“). Wähle dort **Alibaba ModelStudio** → **Standard API Key** → eine **Region** → und kopiere deinen API-Key hinein.

**Wichtig — die Region:** Sie muß zur Konsole passen, aus der dein Key stammt — bei der internationalen Konsole (modelstudio.console.alibabacloud.com) ist das **Singapore**, bei der chinesischen Konsole (bailian.console.aliyun.com) **Beijing**. Ein korrekter Key wird bei der falschen Region mit „API-Key falsch“ abgewiesen — die häufigste Stolperfalle. Klappt die Anmeldung nicht, gib in Qwen Code `/auth` ein und wähle die andere Region.

**Wichtig — nach der Installation das Terminal einmal neu starten:** Bevor du Qwen Code das erste Mal startest, **schließe das Terminal und öffne es erneut**. Sonst meldet das Terminal `qwen: Befehl nicht gefunden` — die Installationsroutine legt den Befehl an einem Ort ab, den das Terminal erst beim Neustart einliest. Erst danach funktioniert der Start mit `qwen` (Schritt 3).

**Wichtig, bevor du den Auftrag gibst — Yolo-Modus einschalten:** Drücke in der Qwen-Code-Oberfläche **Shift + Tab**, bis unten die Anzeige auf **yolo** springt, und tippe dann `/approval-mode yolo --user` ein — der Befehl macht die Einstellung dauerhaft, so daß sie auch Neustarts übersteht. Ohne diese Umschaltung hält Qwen Code bei riskanten Befehlen an — dem Cron-Job für das Gedächtnis-Backup zum Beispiel — und wartet auf deine Bestätigung; der Auftrag läuft dann nicht selbständig durch. **Solche Unterbrechungen erkennst du daran, daß Qwen Code den nächsten Befehl mit einer nummerierten Auswahl zeigt:** Drücke die Ziffer der Bestätigung und dann **Enter**, damit es weiterarbeitet. Was es mit dem Modus auf sich hat, steht in §3.5.

**Standard-Modell dauerhaft festlegen:** Der Erststart hat ein Qwen-Modell als Voreinstellung geschrieben. Seit Qwen Code 0.23.0 bleibt eine im `/model`-Menü getroffene Auswahl dauerhaft erhalten — sie wird als `model.name` in die Konfiguration geschrieben (am 6.9.2026 getestet), du kannst sie also später jederzeit wechseln. Damit von Anfang an das empfohlene Modell steht, gib deinem Assistenten diesen Auftrag:

```text
Setze in deiner Konfiguration (~/.qwen/settings.json) dauerhaft deepseek-v4-flash als Standard-Modell (model.name). Bestätige mir den Eintrag.
```

Danach Qwen Code beenden (`/exit`) und neu starten (`qwen`) — unten in der Fußleiste muß jetzt **deepseek-v4-flash** stehen.

**Alles Weitere kann dein Assistent:** Gib ihm nach dem ersten Start diesen Auftrag — die automatisierte Einrichtung braucht danach nur etwa eine Viertelstunde:

```text
Lese diese Seite und setze alles um. Bis einschließlich Punkt 3.1 habe ich schon alles selbst erledigt, inklusive der Google Drive-Anbindung: https://www.logies.de/studienarbeitsplatz-linux-vm.html

Dabei gelten für dich strikte Regeln:
1. Befolge die Anleitung buchstabengetreu. Führe die dortigen kopierbaren Befehle und Aufträge genau so aus, wie sie dastehen — erfinde nichts um, vereinfache nichts, weiche auf keine anderen Quellen aus (kein GitHub-Ausweichen, keine selbstgeschriebenen Skripte oder SQL-Schemata).
2. Prüfe vor jedem Schritt, ob er auf diesem System schon erledigt ist (z. B. `command -v rclone`). Fehlt nur ein Teil, ergänze nur den fehlenden Teil und melde kurz, was du übersprungen hast.
3. Schlägt ein Befehl fehl: Lies die Fehlermeldung wörtlich und schlage im Troubleshooting-Abschnitt (§10) und beim betreffenden Schritt nach. Stelle dabei das Anleitungsdesign nicht in Frage — zweifle an deiner Ausführung, nicht an der Anleitung (z. B. Browser-Policies: genau nach Vorschrift anlegen, JSON prüfen, Browser neu starten, dann verifizieren).
4. Wenn ein Schritt trotz korrekter Ausführung nicht gelingt: STOPP an dieser Stelle. Melde mir Schritt, Fehlermeldung und deine Ausführung — arbeite nicht „irgendwie“ weiter.
5. Mische Kopierblöcke nicht mit eigenen Varianten. Der Anleitungstext erklärt das Warum — die Ausführung kommt ausschließlich aus den Blöcken.
```

### 3.2 Memory-MCP (Gedächtnis für den KI-Assistenten)

Nachdem Qwen Code läuft, soll der Assistent sein Gedächtnis bekommen:

👉 [**www.logies.de/memory-mcp-fuer-ki-agenten.html**](https://www.logies.de/memory-mcp-fuer-ki-agenten.html)

Kopiere diesen Auftrag in die Qwen-Code-Oberfläche — der Assistent erledigt alles selbständig: Installation des dort beschriebenen Memory-Servers, Import der dort hinterlegten Memory-Inhalte (Nutzungsregeln und Zotero-Wissen) und am Ende die Verifikation von beidem (die Installationsroutine schreibt dafür automatisch einen Prüfbericht, den dein Assistent auswertet und dir kurz zusammenfasst):

```
Gehe auf die Seite https://www.logies.de/memory-mcp-fuer-ki-agenten.html, installiere den dort beschriebenen Memory-Server und importiere dort die hinterlegten Memory-Inhalte. Prüfe nach dem Setup: Enthält crontab -l den Backup-Cron-Job (backup_memory.sh) und existiert der Prüfbericht ~/.qwen/memory-install-report.md? Fehlt eines davon, hat das Setup-Skript vorzeitig abgebrochen — trage dann den Cron-Job (13 * * * * ~/.qwen/backup_memory.sh) manuell nach und führe verify.sh aus. Trage außerdem die im importierten Dokument beschriebene Memory-first-Regel dauerhaft in deine immer geladene Anweisungsdatei ~/.qwen/QWEN.md ein — zusammen mit diesen zwei zusätzlichen Regeln:

1. Nutzungshinweise anzeigen: Suche nach dem Memory-Check am Session-Start mit memory_search (Tag einsteiger-hinweise) die Notiz „Nutzungshinweise für die Zusammenarbeit mit dem KI-Agenten" und zeige sie dem Nutzer vollständig an. Existiert sie nicht, aber die Datei ~/.qwen/nutzungshinweise.md, speichere ihren Inhalt einmalig als Notiz (die Tags stehen in der Datei). Existiert eine Notiz mit Tag nutzungshinweise-deaktiviert, zeige die Hinweise nicht an; bittet der Nutzer um Abschaltung, vermerke das in einer solchen Notiz und bestätige kurz; bei erneuter Anzeige-Aufforderung lösche die Deaktivierungsnotiz (memory_delete).
2. Git selbstständig committen: Nach jeder abgeschlossenen Arbeit, die Dateien im Home-Repo ~/.qwen ändert, committest du selbstständig — nur gezielte Dateien (git add <datei>), niemals git add -A oder git add . (die .gitignore schützt settings.json mit den API-Keys); klare, knappe Commit-Message; kein Push (es gibt kein Remote); vor riskanten Umbauten erst den laufenden Stand committen.

Speichere zum Schluss die Datei ~/.qwen/nutzungshinweise.md als Memory-Notiz ab (die Tags stehen in der Datei). Nach Neustart von Qwen Code verifiziere den Erfolg.
```

Damit Qwen Code das neue Gedächtnis lädt, **startet er nach der Installation einmal neu**: Beende ihn mit `/exit` — **alle Befehle beginnen mit `/`** (tippen, unten in der Befehlsliste scrollen, **Enter** bestätigen). Dann im Terminal wieder `qwen` starten und die angebotene alte Sitzung fortsetzen — dein Assistent behält so den Kontext. Sage ihm kurz **„neu gestartet"**, und er macht die im Auftrag vereinbarte Verifikation.

**Hinweis zum Modell des Gedächtnisses:** Dein KI-Gedächtnis durchsucht seine Notizen semantisch mit dem mehrsprachigen Modell **multilingual-e5-small** — dieselbe Modellfamilie, die auch die Zotero-Semantiksuche (§6.3) nutzt. Kein API-Key nötig, weshalb das so eingerichtet wurde; auf Wunsch kannst du das jederzeit ändern lassen.



### 3.3 Optional: Modell wechseln zu GLM-5.3-Flash

**GLM-5.3-Flash** denkt gründlicher und ist für die Literaturarbeit mit Zotero besser geeignet (preiswerter, besser für Textarbeit), arbeitet aber deutlich langsamer als deepseek-v4-flash — für die Installation gilt die Abwägung aus dem „Empfohlenen Setup“ oben.

**Wenn du umsteigen willst:**
1. Einen API-Key bei [OpenRouter.ai](https://openrouter.ai) holen
2. Deinem KI-Assistenten diesen Auftrag geben (Modellname exakt so, mit `z-ai/`-Präfix):

```
Konfiguriere dich für OpenRouter mit dem Modell z-ai/glm-5.3-flash und meinem OpenRouter-API-Key.
```

3. Der Assistent richtet sich selbst ein — du musst nur den Key bereitstellen

**Mehrere Provider parallel — das `/model`-Menü:** Deine Konfiguration kann beliebig viele Provider-Einträge gleichzeitig halten; das `/model`-Menü zeigt sie als Auswahlliste an, und der Wechsel wirkt sofort — das Menü neu öffnen genügt, ein Neustart ist nicht nötig. So wechselst du, wenn ein Anbieter temporär ausfällt (kommt gelegentlich vor), mit zwei Tasten aufs Ausweichmodell. Das Auswahlmenü schreibt dir dein Assistent nach Wunsch — sag ihm einfach, welche Provider du parallel haben willst:

```text
Richte in deiner Konfiguration (~/.qwen/settings.json) ein Modell-Menü mit zwei parallel hinterlegten Providern ein, zwischen denen ich im /model-Dialog umschalten kann: den ModelStudio-Standard (deepseek-v4-flash) und GLM-5.3-Flash über OpenRouter. Ziel: Fällt einer der beiden Anbieter temporär aus, wechsle ich sofort zum anderen. Erläutere mir die Einträge kurz und bestätige mir den Stand.
```

**Bequeme Variante — der OpenRouter-Auto-Router:** Wer sich die Routing-Feinheiten sparen will, hinterlegt stattdessen den Modellcode `openrouter/auto`: OpenRouter klassifiziert dann jede Anfrage (rund 30 Aufgabentypen) und wählt das Modell selbst — gemessen am realen Nutzungsmarkt der letzten 7 Tage, gesteuert über eine Kostenbandbreite (`cost_tier`: `low`, `medium`, `high`, `xhigh`, `max`; ohne Angabe gilt `low`). Ein Aufpreis fällt nicht an; innerhalb einer Sitzung bleibt der Router bevorzugt beim einmal gewählten Modell. Das manuell gesteuerte Routing mit festem Modell (unten) bleibt die kontrolliertere Variante — für den Einstieg ist der Auto-Router aber der schnellste Weg.

**Routing-Einstellungen bei OpenRouter (entscheidend für Tempo und Kosten):** OpenRouter schaltet dasselbe Modell bei mehreren Anbietern („Providern") parallel frei und wählt pro Anfrage aus. Die Erfahrung aus dem Langzeitbetrieb: Flott, qualifiziert und zugleich preiswert arbeitest du am ehesten, wenn du **das Modell selbst vorgibst** — anhand externer Benchmarks (z. B. artificialanalysis.ai) ausgewählt, aktuell `z-ai/glm-5.3-flash` — und in den OpenRouter-Routing-Einstellungen den **Cost Tier auf „low (default)"** belässt sowie den **Default Provider Sort auf „Default (balanced)"**. OpenRouter balanciert dann die Last über die Provider (Gewichtung nach Preis; Provider mit Ausfällen in den letzten 30 Sekunden werden übersprungen) und wählt dabei laufend neu; ein „Sticky Routing" hält eine aktive Sitzung bis zu 10 Minuten beim selben Provider, damit der Prompt-Cache warm bleibt (wiederholte Eingabe kostet dort nur einen Bruchteil — in meinen Sessions sind das 70–75 % der Eingabe-Tokens). Zwei Ergänzungen gibt dein Assistent dazu aus seinem Memory: Er pinnt das Modell auf die Rabatt-Provider (der OpenRouter-Standard-Provider kostet sonst das Doppelte) und setzt die Kontextgröße auf den Provider-Wert (§3.4).

**Vorsicht bei „Cheapest first" (Sortierung nach Preis):** Damit deaktivierst du die Lastverteilung — OpenRouter fährt die Provider dann strikt in Preisreihenfolge ab, und die billigsten sind oft die langsamsten oder instabilsten. Das kann sehr langsam werden (Faktor > 10). Selbst gemessen (2.9.2026): DeepSeek V4 Flash lief über die billigste OpenRouter-Route mit ~5 Tokens/s, während das Benchmark-Niveau (Artificial Analysis) bei 137 tok/s lag — Faktor ~27. Auch Community-Berichte (u. a. Hacker News, Juni 2026) dokumentieren 15–50 tok/s für dasselbe Modell, je nach Provider — sowie Quantisierungs-Fallen bei Billiganbietern.

**Was so eine Arbeitssitzung „wiegt" — Zahlen statt Bauchgefühl:** Eine DIN-A4-Seite Fließtext entspricht grob 700 Tokens. Bei der Überarbeitung zweier Website-Seiten samt zugehöriger Download-Dateien (3.9.2026) verarbeitete der Assistent in 354 Modellanfragen **rund 60 Millionen Tokens ≈ 86.000 A4-Seiten** — ein Papierstapel von knapp 9 Metern Höhe. Jede einzelne Anfrage enthielt am Ende der Sitzung ~250.000 Tokens (**≈ 360 A4-Seiten**): Daueranweisungen, geladene Memory-Notizen, Dateien und alle Werkzeugergebnisse. 75 % der Eingabe-Tokens kamen aus dem Cache (Preisvorteil). Geschrieben wurden ~525.000 Tokens (≈ 750 Seiten, darin ~200.000 „Gedanken"-Tokens des Modells). Das Gedächtnis war durchgehend im Spiel: **64 Zugriffe auf den Memory-MCP-Server** (20 Suchen — meist vor Aufgabenbeginn, 14 Notiz-Lektüren, 17 Aktualisierungen, 8 Speicherungen, weitere), dazu rund 420 Werkzeug-Aufrufe (Shell-Befehle, Datei-Edits, Zotero-/MCP-Abfragen). **Kosten dieser Session bei GLM-5.3-Flash-Preisen: rund 2 US-Dollar.** Zum Vergleich: Ein menschlicher Chat mit einem KI-Chatbot bewegt sich pro Nachricht im Bereich von hunderten bis wenigen tausend Tokens — der KI-Agent bewegt das 100- bis 500-Fache pro Anfrage, weil er Anleitung, Gedächtnis, Dateien und alle Zwischenergebnisse bei jedem Schritt erneut im Kontext führt. Deshalb sind ein großes Kontextfenster (§3.4), Prompt-Caching und die richtigen Routing-Einstellungen keine Kür, sondern Voraussetzung.

### 3.4 Nach der Installation: Kontextgröße prüfen (wichtig!)

Nach der Ersteinrichtung — und nach jedem Modellwechsel — solltest du prüfen, ob Qwen Code die **Kontextgröße** deines Modells korrekt hinterlegt hat. Es ist schon vorgekommen, dass für glm-5.3-flash eine **viel zu kleine Kontextgröße** konfiguriert war — das schränkt den Assistenten massiv ein, ohne dass eine Fehlermeldung erscheint.

**So erkennst du das Problem in der Oberfläche:** Qwen Code zeigt an, wie viel Prozent des Kontextfensters belegt sind. Wenn z. B. schon bei **~160k Tokens „90 %“** steht, stimmt etwas nicht — moderne Modelle haben deutlich mehr Kontext, und die Prozentanzeige basiert dann auf einem falschen (zu kleinen) Gesamtwert.

**Prüfen und korrigieren — sag deinem Assistenten:**

```
Prüfe in deiner Konfiguration (~/.qwen/settings.json) die hinterlegte Kontextgröße für das aktuell eingestellte Modell. Vergleiche sie mit der offiziellen Kontextgröße des Modells (bei OpenRouter-Modellen: auf der Modellseite von openrouter.ai). Falls der Wert zu klein ist, korrigiere ihn und bestätige mir das Modell danach mit korrektem Kontextfenster.
```

Alternativ kannst du `~/.qwen/settings.json` selbst öffnen und die Einträge zur Kontextgröße (`contextWindowSize` o. ä.) gegen die Modellangaben prüfen.

**Konkreter Wert für glm-5.3-flash (Stand 30.8.2026):** Die Modellseite von OpenRouter nennt 1.310.720 Tokens Kontext — der tatsächlich genutzte Anbieter (top provider) liefert aber nur **1.048.576 Tokens (1 Mio)**. Richtig für die Konfiguration ist daher **1.048.576**. Ein größerer Wert führt zu Problemen, ein kleinerer verschwendet Kontext.

**`model.baseUrl` nicht von Hand setzen:** Im `model`-Block der Konfiguration steht normalerweise nur der Modellname (`model.name`) — die zugehörige Server-Adresse (`baseUrl`) liefert der jeweilige Provider-Eintrag. Qwen Code darf `model.baseUrl` selbst schreiben, um gleichnamige Modelle zu unterscheiden; ein von Hand gesetzter oder aus einer alten Anleitung übernommener, veralteter Wert kann aber dazu führen, daß Anfragen **ohne Fehlermeldung an den falschen Anbieter** gehen. Nach Modellwechseln gilt: den `model`-Block deinem Assistenten prüfen lassen — nie selbst Werte dort ergänzen.

### 3.5 Yolo-Modus aktivieren

Von sich aus hält Qwen Code bei riskanten Aktionen an und fragt nach — bei der Einrichtung genauso wie später im Alltag. Der **Yolo-Modus** lässt den Assistenten ohne solche Rückfragen arbeiten (nur sinnvoll innerhalb deiner eigenen VM!).

**Dauerhaft** — du hast das in §3.1 bereits erledigt: Der Befehl `/approval-mode yolo --user` speichert die Einstellung in deiner Konfiguration, so daß bei jedem Start **yolo** aktiv ist. Zur Kontrolle genügt ein Neustart von Qwen Code (`/exit`, dann `qwen`) — unten muss **yolo** stehen. Falls die Anzeige es nicht zeigt: den Befehl einfach erneut eingeben.

**Nur für die laufende Sitzung:** **Shift + Tab** drücken — die Anzeige zeigt dann „yolo". Jedes Mal beim Start erneut; praktisch, wenn du den Modus nur vorübergehend wechseln willst.

### 3.6 Flackern im Terminal beheben

Direkt nach der Installation kann Qwen Code im ChromeOS-Terminal (hterm) **stark flackern** — das Terminal kommt mit dem Standard-Render-Modus nicht klar. Auch das löst der Assistent selbst — kopiere diesen Auftrag:

```
Das Terminal flackert. Setze in deiner Konfiguration (~/.qwen/settings.json) ui.renderMode = raw und ui.useTerminalBuffer = false und starte danach neu.
```

Danach ist das Flackern weg. (Nebeneffekt: Abschlussmeldungen bleiben sichtbar statt zu verschwinden.)

---

## 4. Arbeitswerkzeuge

Nachdem Qwen Code läuft, ist der Rest der Einrichtung **sein Job**. Kopiere diesen Auftrag in die Oberfläche — er arbeitet alles selbständig ab und fasst am Ende zusammen, was von dir noch übrig bleibt:

```
Arbeite den Rest dieser Installationsanleitung (§4 bis §6) vollständig selbständig ab. Frag mich nur, wenn du einen API-Key, ein Passwort oder eine Bestätigung von mir brauchst. Installiere keine Programme, die in der Anleitung nicht ausdrücklich verlangt sind. Richte auch die Git-Versionierung nach §4.2 ein. Erstelle ganz am Ende eine Liste mit allem, was ich noch selbst erledigen muss, und speichere sie als Markdown-Datei namens todo.md in meinem Home-Verzeichnis (nicht auf dem Desktop — ChromeOS hat keinen). Schreibe neben der todo.md noch einen Bericht, was für Fehler während der Installation aufgetreten sind, wo noch etwas nachzutragen oder nachzuinstallieren ist und wo die Installationsanleitung verbessert werden kann, und speichere ihn ebenfalls im Home-Verzeichnis als installationsbericht.md. Stelle dem Bericht eine kurze Systemübersicht voran: Distribution und Version (aus /etc/os-release), Architektur und Kernel (uname -m -r), Qwen-Code-Version (qwen --version), Node.js-Version (node --version), freier Speicherplatz (df -h /) und das Modell, mit dem du den Auftrag ausgeführt hast. Bereinige den Bericht um eventuelle private Schlüssel oder private Daten und schlage mir vor, ihn an logies@web.de zu mailen.
```

Am Ende liegt die Liste als **`todo.md` in deinem Home-Verzeichnis**, daneben der Bericht als `installationsbericht.md`. **So öffnest du sie:** ChromeOS-App-Menü (unter „Linux-Apps") → **Double Commander** → im Datei-Fenster in dein Home-Verzeichnis navigieren → `todo.md` anwählen → **Enter** — Markdown-Dateien öffnen sich mit Marktext (§5.3), das dein Assistent inzwischen installiert hat. Am Ende schlägt dir dein Assistent vor, den bereinigten Bericht an logies@web.de zu mailen — das hilft, die Anleitung für kommende Studierende zu verbessern.

**Warum Markdown?** Markdown ist das Format, das KIs bevorzugen: reiner Text (jede KI kann es lesen und schreiben), dabei sauber strukturiert (Überschriften, Listen, Codeblöcke) und auch für Menschen direkt lesbar. Für strukturierte Aufträge an die KI und für Ergebnisse der KI ist es die beste Wahl — und mit Marktext (§5.3) öffnet sich eine Markdown-Datei per Doppelklick.

**Wo gebe ich die folgenden Befehle ein?** Gar nicht selbst — du bleibst in Qwen Code. Die Befehlskästen in den folgenden Abschnitten sind die **Arbeitsgrundlage für deinen Assistenten**: Er führt sie selbst aus, wenn du ihm den obigen Auftrag gegeben hast. Willst du einen Befehl ausnahmsweise doch selbst ausführen, öffne dafür ein **zweites Terminal-Fenster** und füge ihn dort ein — in die Qwen-Code-Oberfläche gehören nur Aufträge an den Assistenten und `/`-Befehle.

### 4.1 Uni-VPN (Cisco Secure Client)

Für den Zugriff auf Uni-interne Dienste (Bibliothek, Lernplattformen, Campus-Systeme) wird ein VPN benötigt.

**Installation auf ChromeOS (empfohlen):**
1. **Google Play Store** öffnen → „Cisco Secure Client" suchen → installieren
2. App öffnen → VPN-Verbindung einrichten (VPN-Gateway und Zugangsdaten von der Uni)
3. Verbinden — die Android-VPN-App auf ChromeOS leitet **auch den Traffic der Linux-VM** durch das VPN (funktioniert mit aktuellen ChromeOS-Versionen; im Zweifel mit dem IP-Check unten testen)

**Für Linux-Rechner (ohne ChromeOS):** Der Cisco Secure Client kann von der Uni-Seite heruntergeladen werden. RWTH Aachen und die meisten anderen Unis stellen den Client auf dem VPN-Portal oder dem IT-Service-Portal für Studierende bereit → dort die `.deb`-Version für Linux herunterladen.

**Test, ob das VPN aktiv ist:**
```bash
curl -s https://api.ipify.org
```
→ Zeigt die IP des Uni-Netzwerks an (z. B. 134.61.x.x für RWTH Aachen)

### 4.2 Versionierung mit Git

Git ist bereits installiert (Schritt 2.2) und wird von deinem Assistenten als Teil des obigen Auftrags eingerichtet — die Versionierung macht spätere Änderungen nachvollziehbar. Versioniert werden:

- **Diese Anleitung** (`setup-guide-linux-vm-crostini.md`)
- **Skripte und Konfigurationen** (Memory-MCP-Server, Qwen-Code-Einstellungen)
- **Eigene Notizen und Dokumente** (wenn du sie lokal speicherst)

**Nicht versionieren** solltest du: API-Keys, Passwörter, große Binärdateien (Bilder, Modelle) und Datenbanken.

**Zwingend vor dem ersten Commit — `.gitignore` anlegen:** In `~/.qwen` liegt die Datei `settings.json` mit **API-Keys im Klartext** — ein unüberlegtes `git add -A` würde die Keys committen. Der Assistent legt deshalb zuerst diese `.gitignore` an — **dieser Befehl erzeugt sie vollständig:**

```bash
cat > ~/.qwen/.gitignore <<'EOF'
settings.json
usage_record.jsonl
installation_id
memory.db
memory.db-wal
memory.db-shm
models/
backups/
sessions/
todos/
tmp/
file-history/
usage/
extension-store/
extensions/
projects/
skills/
tip_history.json
__pycache__/
EOF
```

**Schnellstart (führt dein Assistent aus):**
```bash
cd ~/.qwen           # Memory-MCP-Verzeichnis (so legt es das Setup-Skript an)
git init
git config user.name "Student"      # Pflicht vor dem ersten Commit — sonst bricht git ab
git config user.email "student@local"
git add .gitignore memory_server.py verify.sh
git commit -m "Initial"

# Später nach Änderungen (nur gezielte Dateien — niemals git add -A):
git add <geänderte Datei>
git commit -m "Was geändert wurde"
```

Künftig committet dein Assistent selbstständig nach jeder abgeschlossenen Änderung — du musst Git nicht selbst bedienen (die Dauerregel dafür steht in seiner QWEN.md, eingerichtet in §3.2).

**Hinweis zu Office-Programmen:** Für Textverarbeitung, Tabellen und Präsentationen reichen Google Docs, Google Tabellen und Google Präsentationen völlig aus. Sie laufen im Browser, sind immer auf dem neuesten Stand und benötigen keine Installation — LibreOffice wird deshalb **nicht installiert**, und dein Assistent darf es nicht von sich aus nachziehen. Falls du später doch einmal lokale Office-Dokumente bearbeiten willst: sag deinem Assistenten einfach *„Installiere LibreOffice"* — das ist ein Ein-Zeiler.

---

## 5. Lernen & Studium

Auch hier gilt: Dein KI-Assistent arbeitet die Anleitung für dich ab — sag ihm einfach Bescheid, wenn du bereit bist.

**Voraussetzung Flatpak** (auf frischem Crostini oft noch nicht installiert oder Flathub nicht eingerichtet):

```bash
sudo apt install -y flatpak
flatpak remote-add --user --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
```

**Wichtig — immer ohne `sudo`:** Flatpak-Befehle als normaler Nutzer ausführen (User-Installation). Führt der Assistent sie versehentlich mit `sudo` aus, entsteht eine System-Installation — die funktioniert zwar, aber die zwei Varianten verwechseln sich leicht, und `flatpak override --user` wirkt trotzdem nur pro Nutzer.

**Ob du danach etwas tun mußt:** In der Regel erscheinen die Flatpak-Apps von selbst im Linux-Anwendungsmenü. Taucht eine App dort nicht auf, einmal ab- und wieder anmelden — damit wird das Anwendungsmenü neu eingelesen.

### 5.1 Anki (Lernkarteien)

Der Goldstandard für Lernkarteien im Medizinstudium — Anatomie, Pharmakologie, klinische Fächer.

```bash
flatpak install --user flathub net.ankiweb.Anki
```

**Start:** Anki aus dem Anwendungsmenü starten oder:
```bash
flatpak run net.ankiweb.Anki
```

**Falls Anki nicht startet (nur bei Installation ohne Flatpak, z. B. dem offiziellen Linux-Paket von apps.ankiweb.net):** Anki 26.x braucht für die grafische Oberfläche die System-Bibliothek `libxcb-cursor0`. Fehlt sie, bricht der Start sofort ab — mit einer Fehlermeldung wie `Could not load the Qt platform plugin "xcb"`. Abhilfe:
```bash
sudo apt install -y libxcb-cursor0
```
Danach startet Anki normal (verifiziert am 31.8.2026 unter Linux Mint 22.3). Die oben beschriebene Flatpak-Version bringt alle benötigten Bibliotheken selbst mit — dieser Fehler betrifft sie nicht.

**⚠️ Wichtig — bekannter Anki-Bug: Absturz nach der Sprachauswahl:** Anki 26.08.1 (die aktuelle Version, auch als Flatpak) hat einen Start-Fehler: Beim allerersten Start legt es seine Konfigurationsdatenbank ohne Sprachwert an und stürzt daraufhin ab — die von dir gewählte Sprache wird nie gespeichert, und **jeder weitere Start stürzt erneut ab**, ohne dass du jemals zur Hauptansicht kommst. Dein Assistent behebt das, indem er die Datenbank mit korrekten Werten vorbelegt. Gib ihm diesen Auftrag (einmalig):

```
Anki stürzt nach der Sprachauswahl ab — bekannter Bug in Anki 26.08.1: Die Konfigurationsdatenbank ~/.var/app/net.ankiweb.Anki/data/Anki2/prefs21.db wird beim ersten Start ohne Sprachwert (defaultLang: None) angelegt, und jeder Start stürzt deshalb ab. Behebe das, indem du diese Datenbank löschst (inkl. etwaiger -journal/-wal/-shm-Dateien) und sie neu anlegst — wichtig: innerhalb der Flatpak-Sandbox, z. B. über flatpak run --command=sh net.ankiweb.Anki, nicht mit dem Host-Python — mit einem _global-Eintrag, in dem defaultLang auf "de" und firstRun auf False steht, sowie einem Profil namens „Benutzer 1". Starte Anki danach neu und verifiziere, dass es ohne Absturz bis zur Hauptansicht hochkommt. Warnungen zu EGL, MESA/ZINK oder Wayland im Terminal sind harmlos (Software-Rendering in der VM).
```

Anki startet danach direkt ohne Sprachdialog (Deutsch ist vorbelegt) — und künftig ganz normal aus dem Anwendungsmenü.

**Tipp für Medizinstudenten:** Das „AnKingMed"-Deck enthält tausende vorgefertigte Karteikarten für das Medizinstudium. In Anki unter „Karteikarten teilen" danach suchen. Nützliche Add-ons (AnkiWeb-ID in Klammern):
- **Image Occlusion Enhanced** (1374772155) — Bilder abdecken, um Anatomie zu lernen
- **Review Heatmap** (1771074083) — Lernfortschritt visualisieren
- **AnkiConnect** (2055492159) — für KI-Integration

**Anki-Add-ons installieren:** Im GUI-Weg geht das über **Extras → Add-ons → Add-ons abrufen** (ID eintippen). Für den KI-Assistenten ist der Weg versperrt — AnkiWeb lehnt einfache Downloads ab —, daher gib ihm diesen Auftrag:

```
Installiere mir die Anki-Add-ons Image Occlusion Enhanced, Review Heatmap und AnkiConnect ohne GUI. Wichtig: Lade sie von AnkiWeb herunter — GitHub-Releases dieser Add-ons sind veraltet und unzuverlässig — und beachte dabei das Download-Rezept in dieser Anleitung (Abschnitt „Anki-Add-ons ohne GUI einspielen"): User-Agent „Anki <version>" plus Parameter ?v=2.1&p=<int_version>, sonst antwortet AnkiWeb „Your version of Anki is too old". Prüfe jede Version gegen minpt und verifiziere danach: AnkiConnect antwortet auf Port 8765, alle meta.json haben disabled: false.
```

**Anki-Add-ons ohne GUI einspielen (Arbeitsgrundlage für den Assistenten, verifiziert am 1.9.2026 unter Anki 26.08.1):**

AnkiWeb akzeptiert den Download nur mit einem echten Anki-Client-Profil — zwei Bedingungen gleichzeitig:

1. Der **User-Agent** muss `Anki <version>` lauten (z. B. `Anki 26.08.1`) — nicht `anki/…`, kein Browser-String
2. Der Endpunkt verlangt die Parameter `?v=2.1&p=<int_version>`, wobei `p` eine **Ganzzahl** sein muss — die Point-Version `Jahr×10000 + Monat×100 + Patch` (für 26.08.1 also `260801`), zuverlässig ermittelt aus der installierten Anki-Bibliothek:

```bash
flatpak run --command=python3 net.ankiweb.Anki -c "import anki.utils; print(anki.utils.int_version())"
```

**Download (pro Add-on):**

```bash
UA="Anki 26.08.1"          # Versionsstring der installierten Anki
P=260801                    # int_version derselben Installation
curl -sL -A "$UA" -o addon.ankiaddon \
  "https://ankiweb.net/shared/download/<id>?v=2.1&p=$P"
```

**Installation** (Anki darf dabei laufen, lädt die Add-ons aber erst beim nächsten Start):

1. Die `.ankiaddon`-Datei (ein ZIP, dessen `manifest.json` fehlen kann — AnkiConnect hat keins) nach `~/.var/app/net.ankiweb.Anki/data/Anki2/addons21/<id>/` entpacken
2. Eine `meta.json` in denselben Ordner schreiben — Keys: `name`, `mod`, `conflicts`, `min_point_version`, `max_point_version`, `branch_index`, `human_version`, `homepage` — plus **`"disabled": false`** (sonst bleibt das Add-on inaktiv)
3. **Versionsprüfung:** nur `minpt` gegen `int_version` vergleichen (muss ≤ sein). Ein positives `maxpt` ist nur „getestet mit" und wird ignoriert (negativ wäre ein hartes Limit — kommt bei diesen Add-ons nicht vor). Stand 1.9.2026: AnkiConnect minpt 45/maxpt 45 · Image Occlusion Enhanced minpt 50/maxpt 50 · Review Heatmap minpt 49/maxpt 54

**Verifikation ohne GUI:**

- **AnkiConnect:** nach Anki-Start `curl -s -X POST http://127.0.0.1:8765 -d {"action":"version","version":6}` muss `{"result": 6, "error": null}` liefern. Port 8765 ist Default und localhost-gebunden. Es gibt **keine** Add-on-Verwaltungs-Actions über HTTP (eine `getAddonNames`-Abfrage antwortet mit `unsupported action`) — Verwaltung läuft nur über die Dateien.
- **Ladestatus headless:** `__pycache__`-Ordner im Addon-Verzeichnis (`ls ~/.var/app/net.ankiweb.Anki/data/Anki2/addons21/<id>/__pycache__`) — vorhanden = das Modul wurde von Anki importiert. Bewährt als binäres, diagnostikfreies Signal.
- In jeder `addons21/<id>/meta.json` muss `"disabled": false` stehen.

**Betriebshinweise für den Assistenten:**

- **Anki lädt Add-ons nur beim Start** — nach der Installation ist ein Neustart nötig. Und weil Anki **kein SIGTERM behandelt**, soll der Assistent Anki **nicht selbst beenden**, sondern den Nutzer bitten (Strg+Q).
- **Exit-Code 255 beim Fenster-Schließen ist normal** — kein Absturzsignal.
- Deprecation-Warnungen von Image Occlusion Enhanced (`setMod() is deprecated`, `newField is deprecated`) und der `conf key`-Hinweis von Review Heatmap im Log sind **harmlos** und gehören nicht ins Fehlerbild.
- `pgrep -f "anki"` matcht die eigene Befehlszeile — den Klammer-Trick `pgrep -f "/app/bin/[a]nki"` verwenden und die Verifikation mit einem „Anki läuft stabil"-Check abschließen.

### 5.2 Wissensmanagement & PDF-Annotation: Zotero

Fürs Wissensmanagement reicht **Zotero** (§6) völlig: Es verwaltet nicht nur deine Literatur, sondern kann auch PDFs annotieren, Notizen anlegen und per KI-Assistent durchsucht werden — ein separates Wissensmanagement-Tool (z. B. Obsidian) oder ein separates PDF-Annotationsprogramm (Xournal++) ist damit nicht nötig.

### 5.3 Marktext (Markdown-Editor)

Einfacher, aber leistungsfähiger Editor für Notizen und Dokumente.

```bash
flatpak install --user flathub com.github.marktext.marktext
```

### 5.4 Google Chrome in der VM (für Browser-Automatisierung)

Die VM hat bereits Firefox (§2.3). Damit dein KI-Assistent aber auch **selbständig Webseiten bedienen** kann (Seiten aufrufen, Formulare ausfüllen, Screenshots, Prüfläufe), installiert er sich Google Chrome **in der VM**:

```bash
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo apt install -y ./google-chrome-stable_current_amd64.deb
rm google-chrome-stable_current_amd64.deb
```

**Wichtig:** Das ist ein zweiter, **getrennter** Browser — der vorinstallierte Chrome von ChromeOS läuft außerhalb der VM und ist für die KI nicht erreichbar.

---

## 6. Literaturverwaltung (Zotero)

### 6.1 Zotero installieren

```bash
flatpak install --user flathub org.zotero.Zotero
```

**Start:**
```bash
flatpak run org.zotero.Zotero
```

> **Wichtig für die MCP-Anbindung (§6.3):** Bei der Flatpak-Version liegen Zoteros Datenbank und Storage unter `~/Zotero/` (zotero.sqlite, storage/, translators/, styles/), während das Browser-Profil (prefs.js, Extensions) unter `~/.zotero/zotero/<profil>.default/` liegt — das konkrete Profilverzeichnis steht in `~/.zotero/zotero/profiles.ini`. Tools, die direkt auf Dateipfade zugreifen (z. B. Attachment-Import, Volltextsuche, Plugin-Sideloading), müssen diese Pfade kennen.

**⚠️ Wichtig — Zotero sauber behandeln:** Zotero ist eine Single-Instance-Anwendung. Läuft bereits eine Instanz (auch eine unsichtbare), sieht ein neuer Start sichtbar nichts — das wirkt dann wie „Zotero startet nicht". Und: Zotero **niemals mit `kill -9`** abwürgen — ein normales Beenden (SIGTERM) fährt die Datenbank sauber herunter. Nach unsauber beendeten Läufen startet Zotero beim nächsten Start einen Integritätscheck, der bei einer leeren Bibliothek zwar nur Millisekunden dauert, zusammen mit einem aufgeblähten WAL aber wie ein Hängen wirken kann. Zur Diagnose mit Logausgabe: `flatpak run org.zotero.Zotero -ZoteroDebugText`. Im Notfall (nur bei eigener/leerer Bibliothek, Zotero aus): `sqlite3 ~/Zotero/zotero.sqlite "PRAGMA quick_check;"` muss `ok` liefern; `PRAGMA wal_checkpoint(TRUNCATE);` leert das WAL.

**⚠️ Wichtig — einmalige Vorbereitung vor der ersten Sync-Anmeldung:** Zotero speichert den Sync-API-Key im Schlüsselspeicher des Systems. In einer nackten Crostini-VM fehlt dieser Schlüsselspeicher — **die Anmeldung bleibt dann endlos bei „Auf die Anmeldung warten…" hängen**, obwohl die Anmeldung auf zotero.org im Browser erfolgreich war. Die folgende Vorbereitung ist einmalig, überlebt Zotero-Updates und dauert ca. 5 Minuten. Gib deinem Assistenten diesen Auftrag:

```
Bereite Zotero auf die Sync-Anmeldung vor: Installiere gnome-keyring — Pflicht vor der Anmeldung, hier nicht abkürzen: Ohne funktionierenden Secret-Service hängt die Zotero-Sync-Anmeldung beim Start stillschweigend. Erlaube dem Zotero-Flatpak den Zugriff auf den Secret-Service (flatpak override --user --talk-name=org.freedesktop.secrets org.zotero.Zotero). Lege den unverschlüsselten Standardschlüsselbund an: im Verzeichnis ~/.local/share/keyrings die Datei default mit der Zeile „login" sowie eine Datei login.keyring mit dem Abschnitt [keyring] und den Einträgen display-name=login, mtime=0, time=0, lock-on-idle=false, lock-after=false. Starte danach den Secret-Service mit gnome-keyring-daemon --start --components=secrets — die Meldung „couldn't access control socket" ist harmlos — und prüfe mit busctl --user list | grep org.freedesktop.secrets, dass der Dienst läuft. Melde mir das Ergebnis.
```

**So läuft die Anmeldung dann:** Zotero → **Bearbeiten → Einstellungen → Sync → „Anmelden"** → es öffnet sich Firefox. **Zügig anmelden** — die Login-Session läuft nach ca. 10 Minuten ab. Der Firefox-Dialog *„Zotero öffnen?"* auf der Erfolgsseite kann weggeklickt werden, er gehört nicht zum Anmeldevorgang. Die App schließt die Anmeldung nach wenigen Sekunden **von selbst** ab, und der Sync startet. (Der Standardschlüsselbund ist unverschlüsselt, liegt aber mit Dateirechten 600 in deiner VM und verlässt sie nicht.)

**Falls die Anmeldung schon hängt** („Auf die Anmeldung warten…" endlos, obwohl zotero.org den Login bestätigt): genau die obige Vorbereitung nachholen, Zotero **vollständig beenden und neu starten**, dann die Anmeldung erneut starten — danach funktioniert sie.

**Kleiner Display-Fehler beim Löschen:** Erscheint der Bestätigungsdialog beim Löschen von Einträgen nur als schmaler Fensterrest: Das Dialogfenster mit der Maus an der Kante packen und vergrößern — dann lassen sich die Schaltflächen normal bedienen. Der Dialog merkt sich die Größe nicht, das Vergrößern ist also bei jedem Löschen erneut nötig (§10.2).

### 6.2 Zotero-Plugins

Nachdem Zotero installiert ist, kann dein KI-Assistent die Plugins für dich installieren.

**Voraussetzung:** Zotero muß vorher mindestens einmal gestartet haben — ohne Erststart existiert noch kein Profilverzeichnis (`~/.zotero/zotero/<profil>.default`), in das die Plugins eingespielt werden können.

Sage ihm einfach:

> *„Installiere mir die Zotero-Plugins Better BibTeX, Better Notes, Beaver, Zoplicate, Translate und Zutilo."*

Die aktuellen Quellen (verifiziert am 31.8.2026) — der Assistent lädt das jeweilige Release-Asset von der Plugin-Homepage:

| Plugin | Version | Quelle (GitHub-Releases) | Asset |
|---|---|---|---|
| Better BibTeX | 9.0.63 | [retorquere/zotero-better-bibtex](https://github.com/retorquere/zotero-better-bibtex/releases) | `zotero-better-bibtex-<version>.xpi` |
| Better Notes | 3.3.3 | [windingwind/zotero-better-notes](https://github.com/windingwind/zotero-better-notes/releases) | `better-notes-for-zotero.xpi` |
| Beaver | 0.24.0 | [jlegewie/beaver-zotero](https://github.com/jlegewie/beaver-zotero/releases) | `beaver.xpi` |
| Zoplicate | 5.1.1 | [ChenglongMa/zoplicate](https://github.com/ChenglongMa/zoplicate/releases) | `zoplicate.xpi` |
| Translate | 2.4.7 | [windingwind/zotero-pdf-translate](https://github.com/windingwind/zotero-pdf-translate/releases) | `translate-for-zotero.xpi` |
| Zutilo | 4.2.2 | [wshanks/Zutilo](https://github.com/wshanks/Zutilo/releases) | `zutilo.xpi` |

**So spielt der Assistent die Plugins automatisiert ein** (ohne Zotero-GUI, verifiziert unter Zotero 10):

1. Zotero **beenden** (es darf während des Einspielens nicht laufen — sonst überschreibt es die Änderungen) und prüfen, dass keine Instanz mehr läuft (Single-Instance-Verhalten, siehe §6.1)
2. XPI herunterladen und auf die **Addon-ID** umbenennen — die ID steht im XPI in der `manifest.json` unter `browser_specific_settings.zotero.id` (z. B. `better-bibtex@iris-advies.com`)
3. Die umbenannte Datei in das Profil-Verzeichnis `~/.zotero/zotero/<profil>.default/extensions/` legen (Pfad siehe §6.1)
4. In die Profil-`prefs.js` zusätzlich eintragen: `user_pref("extensions.autoDisableScopes", 0);` — ohne diese Zeile werden die Plugins als „neu entdeckt" deaktiviert und bleiben unbenutzt
5. Zotero starten; Erfolgskontrolle über die Felder `active`, `userDisabled`, `appDisabled` in der `extensions.json` des Profils
6. Klemmen Plugins nach Fehlversuchen: bei ausgeschaltetem Zotero `extensions.json` und `addonStartup.json.lz4` im Profil löschen — Zotero scannt beim nächsten Start neu

Welche Plugins sinnvoll sind, steht auch auf der folgenden Seite:

👉 [**www.logies.de/zotero-mcp-server-beaver-vergleich.html**](https://www.logies.de/zotero-mcp-server-beaver-vergleich.html)

**Zotero-Connector in den Browsern (auftragt du deinem KI-Agenten):** Damit du Webseiten mit einem Klick in deine Bibliothek sammeln kannst, richtet dein Assistent die Connectoren in **Firefox und Google Chrome der VM** per Browser-Richtlinie ein — jeweils zusammen mit einem Werbeblocker: **uBlock Origin** (Firefox) bzw. **uBlock Origin Lite** (Chrome). Kopiere diesen Auftrag:

```
Richte in beiden Browsern dieser Linux-VM die Zotero-Connectoren per Browser-Richtlinie ein — Firefox: Zotero Connector (Add-on-ID zotero@chnm.gmu.edu) und uBlock Origin (uBlock0@raymondhill.net); Chrome: Zotero Connector (ekhagklcjbdpajgpjgmbionohlpdbjgc) und uBlock Origin Lite (ddkjiahejlhfcafbddmgiahcphecmpfh). Vorgehen:

1. Existiert /etc/firefox/policies/policies.json bereits, zeig mir zuerst ihren Inhalt. Lege danach die Datei mit genau diesem Inhalt an (Verzeichnis notfalls erstellen; sudo ist in der VM passwortlos):

{
  "policies": {
    "ExtensionSettings": {
      "zotero@chnm.gmu.edu": {
        "installation_mode": "normal_installed",
        "install_url": "https://www.zotero.org/download/connector/dl?browser=firefox"
      },
      "uBlock0@raymondhill.net": {
        "installation_mode": "normal_installed",
        "install_url": "https://addons.mozilla.org/firefox/downloads/latest/ublock-origin/latest.xpi"
      }
    }
  }
}

2. Lege /etc/opt/chrome/policies/managed/zotero-extensions.json mit genau diesem Inhalt an (Verzeichnis notfalls erstellen):

{
  "ExtensionInstallForcelist": [
    "ekhagklcjbdpajgpjgmbionohlpdbjgc;https://clients2.google.com/service/update2/crx",
    "ddkjiahejlhfcafbddmgiahcphecmpfh;https://clients2.google.com/service/update2/crx"
  ]
}

3. Beende laufende Firefox- und Chrome-Fenster ordentlich (Zotero darf dabei weiterlaufen) und starte beide Browser einmal neu: Firefox genügt im Hintergrund (timeout 70 firefox-esr --headless about:blank), Chrome grafisch mit rund einer Minute Wartezeit, damit der Chrome Web Store die Erweiterungen installieren kann; danach Chrome wieder schließen.

4. Verifiziere und berichte mir: In ~/.mozilla/firefox/*/extensions.json müssen zotero@chnm.gmu.edu und uBlock0@raymondhill.net mit "userDisabled": false erscheinen; unter ~/.config/google-chrome/Default/Extensions/ müssen die Ordner ekhagklcjbdpajgpjgmbionohlpdbjgc und ddkjiahejlhfcafbddmgiahcphecmpfh existieren. Installiere nichts darüber hinaus.
```

Kurz erklärt: Firefox bekommt eine Richtliniendatei (`/etc/firefox/policies/policies.json`), Chrome eine verwaltete Erweiterungsliste (`/etc/opt/chrome/policies/managed/zotero-extensions.json`). Bereits vorhandene Erweiterungen werden dabei nicht angerührt — doppelte Installationen sind unmöglich. Chrome zeigt danach den Hinweis, es werde „von einer Organisation verwaltet“ — das kommt von der Richtliniendatei und ist harmlos. Zur Kontrolle kann dein Assistent beide JSON-Dateien mit `python3 -m json.tool <datei> >/dev/null && echo OK` validieren; die Richtlinien greifen erst beim nächsten Browserstart, und in Firefox sind sie unter `about:policies` sichtbar.

**Nur noch von Hand: Chrome von ChromeOS (außerhalb der VM)** — die VM erreicht diesen Browser nicht: [Zotero Connector](https://chromewebstore.google.com/detail/zotero-connector/ekhagklcjbdpajgpjgmbionohlpdbjgc) aus dem Chrome Web Store installieren.

Der Connector braucht nur Zotero laufend im selben System (ChromeOS-Connector: Zotero in der VM; VM-Browser: Zotero daneben) — einrichtbar ist er schon vor der Sync-Anmeldung. Zum Entfernen: Die Chrome-Erweiterungen verschwinden, wenn der KI-Agent die Richtliniendatei löscht (beim nächsten Chrome-Start); die Firefox-Add-ons bleiben und lassen sich normal deaktivieren oder entfernen.

### 6.3 Zotero mit KI-Assistenten verbinden (vereinfachte Einrichtung)

Da alles in **derselben Linux-VM** läuft, ist die Einrichtung einfacher als in der Windows-Variante auf der Webseite — kein Netzwerk zwischen zwei Rechnern, alles kommuniziert über localhost.

**Schritt 1 — Lokale API in Zotero aktivieren:**
- Zotero öffnen → **Bearbeiten → Einstellungen → Erweitert**
- Haken bei „Anderen Anwendungen auf diesem Computer erlauben, mit Zotero zu kommunizieren“ — und in derselben Ansicht den Haken für die Nutzung **über die lokale API** setzen (Prefs: `extensions.zotero.httpServer.enabled` und `extensions.zotero.httpServer.localAPI.enabled`)

**Ohne GUI (Agentenweg):** Bei **ausgeschaltetem Zotero** in die Profil-`prefs.js` (`~/.zotero/zotero/<profil>.default/prefs.js`, Pfad siehe §6.1) die beiden Zeilen eintragen — nur bei ausgeschaltetem Zotero bearbeiten, sonst überschreibt Zotero die Datei beim Beenden:

```
user_pref("extensions.zotero.httpServer.enabled", true);
user_pref("extensions.zotero.httpServer.localAPI.enabled", true);
```

Danach testen: `curl http://127.0.0.1:23119/api/users/0/items?limit=1` muss **200** liefern — bei `403 "Local API is not enabled"` fehlt die zweite Pref.

**Schritt 2 — MCP-Tools installieren (in der Linux-VM):**
Die verschiedenen Werkzeuge (Zotero-MCP-Server, Zoteus, CLI-anything-Zotero, pyzotero) sind auf der Vergleichsseite beschrieben:

👉 [**www.logies.de/zotero-mcp-server-beaver-vergleich.html**](https://www.logies.de/zotero-mcp-server-beaver-vergleich.html)

Die Seite enthält die Installationsbefehle und eine Entscheidungshilfe, welches Tool für welchen Zweck am besten geeignet ist.

**Für diese Anleitung gilt: Installiere ausschließlich Zoteus.** Zoteus deckt alles ab, was du brauchst (Suche, Metadaten, Notizen, Anhänge, Literaturverwaltung, OpenAlex-Recherche, semantische Suche) und ist schneller und stabiler als die Alternative (Zotero-MCP-Server). Den Zotero-MCP-Server brauchst du nicht — die semantische Suche (Schritt 4) erledigt Zoteus selbst, lokal und ohne zweiten Server.

**Voraussetzung: Node.js.** Zoteus läuft auf Node.js — auf einem frischen Crostini-System erst installieren (die in der Vergleichsseite genannte Installationsroute erledigt das mit):

```bash
sudo apt install -y nodejs npm
```

**Installation und Einbindung:** Zoteus wird per npx gestartet und als MCP-Server in der Qwen-Code-Konfiguration eingetragen (der eigentliche Einbau in die Konfiguration ist Schritt 3). Der Eintrag sieht so aus:

```json
"zoteus": {
  "command": "npx",
  "args": ["-y", "@oscardvs/zoteus"],
  "transport": "stdio"
}
```

**Zwei Warnungen beim ersten Start sind normal:** (1) Ohne die Einrichtung aus Schritt 4 läuft die semantische Suche zunächst nur als Stichwortsuche — Schritt 4 richtet sie gleich mit ein, komplett ohne API-Key. (2) Node 20 (Debian 13) hat kein eingebautes `node:sqlite` — Zoteus fällt dann auf ein JSON-Index-Backend zurück; für Bibliotheken weit über 250.000 Passagen wäre Node 22 empfohlen, für den Studienstart irrelevant.

**Smoke-Test ohne GUI** (beweist, dass Zoteus läuft und Zotero erreichbar ist): `timeout 25 npx -y @oscardvs/zoteus < /dev/null` muss `MCP server started on stdio` und `localApi=true` melden.

**Schritt 3 — MCP-Server in Qwen Code einbinden:**
Der Assistent trägt den in Schritt 2 gezeigten Eintrag in die Qwen-Code-Konfiguration (`~/.qwen/settings.json`) ein. **Das ist kein Optional:** Erst mit eingebundenen MCP-Servern kann die KI Zotero überhaupt fernsteuern — Literaturabfragen wie das Beispiel in §1 funktionieren ohne diesen Schritt nicht.

**Schritt 4 — Semantische Suche einrichten (empfohlen, komplett ohne API-Key):**

Die **semantische Suche** macht deine Literatur *inhaltlich* durchsuchbar: Du fragst z. B. *„Welche Artikel behandeln Rückfallprophylaxe nach Parodontitistherapie?“* — und der Assistent findet die passenden Aufsätze, **auch wenn das Wort „Prophylaxe“ im Titel nicht vorkommt** (etwa weil das Paper „recurrence prevention“ schreibt). Das matcht nach *Bedeutung* statt nach exakten Worten — auch über deine gesamten PDF-Volltexte hinweg, inkl. 750-Seiten-Büchern.

Sie läuft **lokal** mit dem mehrsprachigen Modell **multilingual-e5-small** in der quantisierten Variante (q8) — getestet gegen eine echte Bibliothek (10.531 Einträge, 72.554 Passagen): Die q8-Variante liefert 80,6 % identische Treffer wie die unquantisierte, bei deutschen Suchfragen mit gleich guten Ergebnissen. Download: **129 MB**, Kosten danach: keine. Sag deinem Assistenten:

```
Richte in Zoteus die semantische Suche lokal ein: Setze ZOTEUS_EMBEDDINGS=local, ZOTEUS_EMBEDDING_MODEL=Xenova/multilingual-e5-small und ZOTEUS_EMBEDDING_DTYPE=q8. Wichtig: Für q8 funktionieren nur Modellnamen mit Xenova/-Präfix; Zoteus muss mindestens Version 1.14.0 sein (beim Start per npx bekommst du automatisch die aktuelle). Baue danach den semantischen Index einmalig vollständig auf — mit Volltext, maximale Zeichen-/Token-Länge — und melde mir das Ergebnis.
```

Der erste Index-Build läuft lokal auf der CPU und dauert je nach Bibliotheksgröße eine Weile; danach ist alles kostenlos und ohne Cloud. Das Modell belegt Speicher und Arbeitsspeicher — wie viel davon auf dem Chromebook übrig ist, ist Gerätesache: Sicherheitshalber lässt du den Assistenten vor der Einrichtung prüfen, wie viel Arbeitsspeicher dem Linux-Container tatsächlich zur Verfügung steht (zum Beispiel mit `free -h`); mit etwa 8 GB und mehr sollte es gut passen. Wechselst du später zwischen lokal und OpenAI, wird der semantische Index einmal neu aufgebaut — deine PDFs und Bücher selbst bleiben unberührt.

**Alternative mit OpenAI-API-Key (für sehr große Bibliotheken):** Der lokale Erst-Build ist langsam — mit einem OpenAI-Key geht der Aufbau deutlich schneller (Kosten im Centbereich). **Je größer die Bibliothek, desto interessanter diese Variante.**

**So bekommst du den Key:**
1. Auf https://platform.openai.com/api-keys anmelden (oder kostenlosen OpenAI-Account anlegen) → **„Create new secret key"**
2. Kostenpflichtiges Guthaben aufladen (Billing: https://platform.openai.com/usage — bereits wenige Dollar reichen für Monate)

**Welches Embedding-Modell?** Empfehlung: **`text-embedding-3-small`**. Begründung mit Zahlen aus OpenAIs eigener Dokumentation:

| | small | large |
|---|---|---|
| Preis / 1M Tokens | **$0,02** | $0,13 (6,5× teurer) |
| MTEB-Qualität | 62,3 % | 64,6 % |
| Seiten pro Dollar | 62.500 | 9.615 |

Der Qualitätsunterschied (2,3 Prozentpunkte auf dem Standard-Benchmark MTEB) ist für die Bibliothekssuche praktisch irrelevant — der Preisunterschied ist es nicht. Der Vorgänger `ada-002` kostet wie large (61,0 %) und ist schlechter als beide.

**Beim Index-Build sagen:** Der Assistent soll beim Aufbau des semantischen Index (`zotero_index` bei Zoteus) mit **`text-embedding-3-small`** arbeiten und für die Volltext-Indexierung die **maximale Zeichen-/Token-Länge wählen**, damit auch dicke Bücher (beispielsweise 750-Seiten-Wälzer) vollständig in den Index kommen und später auffindbar sind. Bei Zoteus heißt die Einstellung `fulltext_max_chars` — die KI setzt sie hoch genug für deine längsten Dokumente.

**Ohne OpenAI-Key läuft alles andere normal** (Metadaten, Annotieren, Zitationen, Literatur importieren) — und die semantische Suche selbst läuft mit der lokalen Einrichtung aus Schritt 4 ebenfalls ohne Key.

**Wichtig zu wissen:** Der semantische Index bildet den Stand zum Zeitpunkt seines Baus ab. **Neu hinzugefügte Literatur ist automatisch erst mal nicht auffindbar** — der Index muss gelegentlich aktualisiert werden. Sinnvoll etwa einmal im Monat oder nach größeren Sammel-Sessions. Du musst nicht dran denken: Sag deinem Assistenten einfach:

```
Erstelle eine monatliche Erinnerungsaufgabe: Prüfe zu Beginn jedes Monats, ob seit der letzten Indexierung neue Literatur in Zotero hinzugekommen ist. Wenn ja, aktualisiere den semantischen Index in Zoteus inkrementell, mit Volltext — mit dem eingerichteten lokalen Embedding-Modell (Xenova/multilingual-e5-small, q8). Melde mir danach kurz das Ergebnis.
```

Dein Assistent merkt sich die Aufgabe in seinem Gedächtnis (§3.2) und erinnert dich — du musst nur dran denken, ihn zu fragen.

**Hinweis für deinen Assistenten — betrifft nur die OpenAI-Alternative (der kennt das aus seinen Memory-Dateien):** Seit Zoteus v1.13.0 übersteht ein Index-Build OpenAI-Rate-Limits (429) von selbst — der Server wartet und wiederholt automatisch — und ein unterbrochener Build wird an der Unterbrechungsstelle fortgesetzt, statt die Volltext-Phase von vorn zu beginnen. Bei sehr großen Bibliotheken bleiben zwei Drossel-Einstellungen nützlich (`ZOTEUS_EMBED_BATCH_SIZE=256`, `ZOTEUS_EMBED_BATCH_DELAY_MS=8000`); sie sind seit v1.13.0 offiziell dokumentiert und für Konten mit engen Drosselgrenzen die empfohlene Kombination. Bei deinen anfänglich kleinen Sammlungen ist das Thema unwahrscheinlich; wächst die Bibliothek, kennt der Assistent die Einstellungen bereits. Details stehen im Zotero-Knowledge-Export (§3.2).

**Wie es bei mir selbst läuft (Automatismen statt Handarbeit):** In meinem Agenten-Setup aktualisiert der Assistent den semantischen Index **täglich** — dieselbe Erinnerungsaufgabe wie oben, nur mit Tagesrhythmus, weil ich täglich Literatur ergänze — mein Index läuft lokal, Kosten dafür: keine. Dazu kommen ein **wöchentlicher Update-Check** für Zoteus, Zotero und Plugins (§12.2) und die **stündliche Datensicherung des Assistenten-Gedächtnisses** (§12.3). Wenn deine Bibliothek wächst oder du regelmäßig sammelst, kannst du die monatliche Aufgabe jederzeit in eine tägliche umwandeln — der Assistent merkt sich die neue Frequenz genauso.

### 6.4 Werkzeuge für die Notiz-zu-PDF-Konvertierung

Damit dein Assistent Zotero-Notizen als sauber formatiertes **PDF** ausgeben kann (wie im Rechercheauftrag aus §1), braucht er zwei Werkzeuge. Dein Assistent installiert sie mit:

```bash
sudo apt install -y pandoc weasyprint fonts-noto-core
```

- **pandoc** wandelt die Zotero-Notiz in sauberes HTML
- **WeasyPrint** druckt das HTML als PDF — mit deutscher Silbentrennung (über `lang=de-DE`), Seitenzahlen und Blocksatz
- **fonts-noto-core** liefert die Schriften, damit Umlaute und Sonderzeichen sauber gesetzt werden

**Achtung:** Unter Debian 13 heißt das Paket **`weasyprint`** — das früher übliche `python3-weasyprint` existiert dort nicht mehr, und das gesamte apt-Lauf (auch pandoc!) bricht sonst mit „no installation candidate" ab.

Wie die Notiz konkret aufgebaut sein muss und wie die Konvertierung abläuft, steht in den importierten Memory-Dateien (§3.2) — dein Assistent kennt den Workflow, du musst nichts konfigurieren.

---

## 7. Installierte Software (Übersicht)

### Nachinstalliert (apt)

```bash
# Schritt 2.2
sudo apt install -y git

# Schritt 2.3
sudo apt install -y firefox-esr firefox-esr-l10n-de keepassxc doublecmd-gtk pavucontrol vim
sudo apt install -y python3-venv python3.13-venv

# Schritt 2.4
sudo apt install -y locales-all task-german-desktop manpages-de

# aus der Installationsanleitung auf www.logies.de/ki-agent-einstieg.html
# (Python-Build-Tools für Qwen Code und den Memory-MCP-Server)
sudo apt install -y python3-pip python3-venv python3.13-venv build-essential gcc g++ make patch

# zum Entpacken der Anki-Add-ons (§5.1)
sudo apt install -y unzip

# Schritt 5.4 — Chrome in der VM (Browser-Automatisierung)
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo apt install -y ./google-chrome-stable_current_amd64.deb

# Schritt 6.3 — Node.js als Voraussetzung für Zoteus
sudo apt install -y nodejs npm

# Schritt 6.4 — Werkzeuge für die Notiz-zu-PDF-Konvertierung
sudo apt install -y pandoc weasyprint fonts-noto-core
```

### Nachinstalliert (flatpak)

```bash
flatpak install --user flathub net.ankiweb.Anki           # Lernkarteien
flatpak install --user flathub com.github.marktext.marktext    # Markdown-Editor
flatpak install --user flathub org.zotero.Zotero           # Literaturverwaltung
```

---

## 8. Wiederherstellung auf einem Neusystem (Kurzanleitung)

1. **ChromeOS → Terminal → Linux-VM einrichten**
2. **§2.2** — System aktualisieren + Git installieren
3. **§2.3** — Standard-Programme (Firefox, KeePassXC, Double Commander, Vim, Pavucontrol)
4. **§2.4** — Sprache auf Deutsch umstellen
5. **§2.5** — Platte auf 15 GB vergrößern (läuft im laufenden Betrieb)
6. **§3** — Qwen Code + Memory-MCP installieren (dazu die Webseiten aufrufen)
7. **§3.3** — Optional: GLM-5.3-Flash + OpenRouter einrichten
8. **§3.4** — Kontextgröße in der Qwen-Code-Konfiguration prüfen (wichtig!)
9. **§3.5** — Yolo-Modus aktivieren
10. **§3.6** — Terminal-Flackern beheben (falls vorhanden)
11. **§4.1** — Uni-VPN (Cisco Secure Client aus Play Store)
12. **§5.1, §5.3 + §5.4** — Anki, Marktext, Chrome in der VM
13. **§6** — Zotero + Plugins (dabei §6.1: **Sync-Vorbereitung**, bevor du dich das erste Mal anmeldest; §6.2: Connector in die Browser; §6.4: PDF-Werkzeuge)
14. **§6.3 Schritt 4** — OpenAI-API-Key für semantische Suche holen (small als Modell)
15. Direkt nach der Installation: **§10.1** (Icon-Fix) ausführen
16. Optional: **§13** — Google Drive einbinden (rclone — eigenen API-Key nicht vergessen!)

---

## 9. KI-Assistenten bitten (nach der Einrichtung)

Sobald Qwen Code und der Memory-MCP-Server laufen, kannst du deinen KI-Assistenten für alles Mögliche um Hilfe bitten:

- **„Installiere mir die Anki-Add-ons Image Occlusion Enhanced, Review Heatmap und AnkiConnect."**
- **„Welche weiteren Tools oder Workflows würdest du mir fürs Medizinstudium empfehlen?"**
- **„Erstelle mir eine Lernstrategie mit Anki für das erste Semester."**
- **„Wie lege ich mein Zotero mit einem MCP-Server in dieser VM an, damit du darauf zugreifen kannst?"**
- **„Konfiguriere dich für OpenRouter mit dem Modell z-ai/glm-5.3-flash."**

Der Assistent kennt deine installierte Umgebung und kann dir gezielte Vorschläge machen, die über diese Anleitung hinausgehen.

---

## 10. Fehlerbehebungen

### 10.1 Fehlende Icons in der Symbolleiste (leere Platzhalter)

**Ursache:** Ein Fehler im Debian-Icon-Theme macht alle Icons unsichtbar, die nur im hicolor-Theme liegen. Betroffen können je nach Installation verschiedene Anwendungen sein (z. B. KeePassXC). Der Fix am Beispiel KeePassXC:

```bash
sudo cp /usr/share/icons/hicolor/scalable/apps/keepassxc*.svg /usr/share/icons/Adwaita/scalable/apps/
sudo gtk-update-icon-cache --force /usr/share/icons/Adwaita
```
Betroffene Anwendung einmal schließen und neu starten. Für andere betroffene Anwendungen gilt dasselbe Muster: deren Icons aus `hicolor` in das Adwaita-Theme kopieren und den Icon-Cache neu aufbauen.

### 10.2 Display-Probleme bei manchen Apps

Falls Programme nicht richtig dargestellt werden oder sich nicht anheften lassen:
- Terminal schließen und neu öffnen, danach die betroffene App neu starten
- Das ist meist der einfachste Fix.
- **Zotero: Der Bestätigungsdialog beim Löschen erscheint nur als Fensterrest** und läßt sich nicht bedienen — das Dialogfenster mit der Maus an der Kante packen und **vergrößern**, danach funktionieren die Schaltflächen normal. Der Dialog merkt sich die Größe nicht: Das Vergrößern ist bei jedem Löschen erneut nötig (beobachtet unter Zotero 10.0.1, Flatpak wie Debian-Paket).

### 10.3 „API-Key falsch“ — Region prüfen, Key nachträglich ändern

Meldet Qwen Code, der API-Key sei falsch, stimmt er meist trotzdem — die **Region** ist falsch gewählt: API-Keys sind an die Konsole gebunden, aus der sie stammen (internationale Konsole `modelstudio.console.alibabacloud.com` → **Singapore**, chinesische Konsole → **Beijing**). Am Server der falschen Region wird ein korrekter Key abgewiesen.

**Key nachträglich ändern:** Starte `qwen` und gib `/auth` ein — derselbe Dialog wie beim ersten Start; er überschreibt die alte Konfiguration: **Alibaba ModelStudio** → **Standard API Key** → **Region** → Key einkopieren. Danach zeigt `/doctor`, ob die Anmeldung klappt. Wer den Key in einer Datei pflegt: er liegt in `~/.qwen/settings.json` unter `env` oder in `~/.qwen/.env` — die `.env`-Datei hat Vorrang.

---

## 11. Noch nicht installiert (bei Bedarf)

| Programm | Befehl | Zweck |
|---|---|---|
| Java | `sudo apt install default-jre` | Java-Anwendungen |

(Node.js ist seit der Überarbeitung nicht mehr in dieser Liste — es wird in §6.3 als Voraussetzung für Zoteus installiert.)

---

## 12. Was du selbst noch machen mußt

Diese Punkte kann dir kein Installationsskript und keine Anleitung abnehmen — die gehören zu deinem persönlichen Account und deinen Entscheidungen.

### 12.1 Accounts einrichten

| Account | Wofür? | Selbst machen? |
|---|---|---|
| **Cisco Secure Client** | Uni-VPN-Zugang | App aus Play Store installieren, Uni-Zugangsdaten eingeben, Verbindung testen (§4.1) |
| **Zotero.org** | Synchronisation & Backup deiner Literatur | Konto und Cloud-API-Key nach §2.6 anlegen, dann in Zotero unter Bearbeiten → Einstellungen → Sync anmelden. **Vorher unbedingt die einmalige Sync-Vorbereitung aus §6.1** — sonst hängt die Anmeldung bei „Auf die Anmeldung warten…" |
| **Google API-Key** | rclone/Google Drive (optional) | In der Google Cloud Console erstellen (§13.2, kleinschrittige Anleitung) — danach die OAuth-App auf „In Produktion" stellen, sonst muss die Anmeldung jede Woche erneut erfolgen |
| **Qwen API-Token** | KI-Assistent | Bei Alibaba ModelStudio holen (§3.1 → Webseite) |
| **OpenRouter API-Key** | Optional: GLM-5.3-Flash | Bei [OpenRouter.ai](https://openrouter.ai) holen, dann KI-Assistenten bitten sich umzustellen (§3.3) |

### 12.2 Regelmäßig erledigen

- **VM updaten:** `sudo apt update && sudo apt upgrade -y` (etwa einmal pro Woche)
- **Speicher prüfen:** Wenn die Platte voll läuft, in ChromeOS-Einstellungen vergrößern
- **Memory-Einträge pflegen:** Dein KI-Assistent kann das automatisch, aber ein Blick ins Memory schadet nicht

### 12.3 Backups — wichtige Daten sichern

**Git ist kein Backup.** Die Versionierung im Git-Repo dient der Nachverfolgung von Änderungen, nicht der Datensicherung.

**Was automatisch gesichert ist:**
- **Google Docs, Tabellen, Präsentationen** — liegen in der Google Cloud, kein Zutun nötig
- **Zotero-Literatur** — wird mit zotero.org synchronisiert (sobald der Account eingerichtet ist, §12.1)
- **Dein KI-Gedächtnis** (die Memory-Datenbank) — sichert sich das Installationspaket selbst: automatisch stündlich, nur bei Änderung, 8 Tage Aufbewahrung. Du musst nichts tun.

**Zusätzlich empfohlen: Cloud-Backup des KI-Gedächtnisses über Zotero.** Zotero-Notizen zählen **nicht** auf das Speicherlimit deines Zotero-Accounts, werden aber vollständig über die Zotero-Synchronisation gesichert. Der Memory-Server spiegelt alle Memory-Einträge als Zotero-Notizen in eine eigene, **gerätespezifische** Sammlung — pro Rechner eine eigene (der Sammlungsname trägt den Gerätenamen), damit sich die Backups mehrerer Geräte in einem geteilten Zotero-Account nie überschneiden. Ein zweites, externes Backup, das selbst dann überlebt, wenn die VM verloren geht. Einmalig einrichten lassen:

**Voraussetzung: Zotero-Sync an.** Dein lokales Zotero sollte fest mit zotero.org verbunden sein und automatisch synchronisieren (§6.1) — das sichert nicht nur deine Bibliothek laufend: Nach dem Zurückspielen einer älteren VM-Sicherung bringt der Zotero-Sync die **Bibliothek** von selbst wieder auf den aktuellen Stand. Dein KI-Gedächtnis dagegen rekonstruiert sich nicht von selbst: Die Backup-Notizen kommen zwar mit dem Zotero-Sync zurück, aber das Agenten-Memory wird daraus erst wieder aufgebaut — §12.4 sagt deinem Assistenten, was fehlt.

**So läuft das Backup:** Der Memory-Server sichert seine Inhalte **spätestens 6 Stunden nach dem letzten Backup — beim nächsten Zugriff auf das Memory** — als Zotero-Notizen in seine eigene Sammlung „KI-Gedächtnis-Backup — <geräte-id>“. Nutzt du den Assistenten nur morgens, sichert er automatisch zweimal am Tag; bei geschlossenem Deckel holt der nächste Zugriff das Backup nach. Manuell auslösen kannst du es jederzeit: sage deinem KI-Agenten *„synchronisiere das Memory mit Zotero“*.

```
Richte das Zotero-Backup meines KI-Gedächtnisses ein. Das Memory-Server-Paket bringt das Werkzeug memory_zotero_sync mit. Lege die Datei ~/.qwen/zotero-sync.json mit dem Inhalt {"device": "<geräte-id>"} an (geräte-id = kurzer Name dieses Rechners, z. B. der Hostname) und lege meinen Zotero-API-Key in ~/.qwen/zotero-api-key ab (ich gebe ihn dir gleich; Rechte 600). Teste danach: Rufe memory_zotero_sync mit action "status" auf — es muss device, den Sammlungsnamen „KI-Gedächtnis-Backup — <geräte-id>" und key_present: true zeigen. Löse dann das erste Backup mit action "sync" aus: Das Werkzeug spiegelt alle Memory-Einträge als Zotero-Notizen in die eigene Sammlung dieses Geräts (Restore-Schutz eingebaut; gelöschte Notizen bleiben in Zotero als Audit-Spur stehen). Verifikation: Ein zweiter Aufruf von "sync" meldet 0 neu / 0 aktualisiert; Zotero enthält danach exakt so viele Notizen in der Sammlung, wie die Memory-Datenbank Einträge hat. Von jetzt an läuft das Backup automatisch: Bei jeder Nutzung des Memory prüft der Server, ob das letzte Backup mehr als 6 Stunden zurückliegt, und führt es sonst selbst aus — du musst nichts tun. Sag mir, wann das Backup läuft und wie ich es jederzeit manuell auslösen kann ("synchronisiere das Memory mit Zotero").
```

Nach dem ersten Backup einmal Zotero syncen lassen und bestätigen, dass die Sammlung bei zotero.org angekommen ist.

**Wöchentlicher Update-Check (empfohlen):** Zotero, Zoteus und die Zotero-Plugins entwickeln sich weiter. Dein Assistent kann jede Woche automatisch prüfen, ob Updates vorliegen — er meldet sie dir mit einer Kurzusammenfassung, installiert aber nichts ohne deine Freigabe:

```
Erstelle eine wöchentliche Erinnerungsaufgabe: Prüfe zu Beginn jeder Woche, ob Updates verfügbar sind für Zotero (GitHub zotero/zotero), Zoteus (npm @oscardvs/zoteus) und die installierten Zotero-Plugins (Better BibTeX, Better Notes, Beaver, Zoplicate, Translate, Zutilo — jeweils GitHub-Releases). Vergleiche mit den installierten Versionen (Zotero: Über Zotero; Plugins: Extras → Plugins; Zoteus: npm view). Melde mir jede neue Version mit 2-3 Sätzen zu den Release Notes und schlage die nächsten Schritte vor. Installiere oder aktualisiere nichts ohne meine ausdrückliche Freigabe.
```

**Was du selbst sichern musst:**
- **Lokale Dateien** in der Linux-VM (z. B. Marktext-Dokumente, heruntergeladene PDFs)
- **Die gesamte VM-Konfiguration** (Installation, Einstellungen, alle Programme)

**So sicherst du die ganze VM:**
1. Zuerst die Linux-VM sichern: ChromeOS → Einstellungen → Linux → „Sichern und Wiederherstellen" → **Sichern** — ChromeOS erzeugt eine Sicherungsdatei der VM (mit allen Programmen und Einstellungen)
2. Dann diese Sicherungsdatei zu Google Drive hochladen
3. **Wichtig für große Dateien:** Der Upload über den Browser ist stabiler als über die Datei-App — also im Chrome-Browser auf drive.google.com hochladen

**Wiederherstellen:** Sicherungsdatei von Google Drive herunterladen, dann ChromeOS → Einstellungen → Linux → „Aus Sicherung wiederherstellen" und die Datei auswählen

### 12.4 Vom Gedächtnis der anderen Geräte lernen

**Vom Gedächtnis der anderen Geräte lernen.** Dein KI-Assistent sichert sein Memory automatisch nach Zotero (§12.3) — das deckt den Alltag ab. Hast du aber einem Gerät viele neue Memory-Einträge gegeben und soll ein **anderes Gerät** davon lernen, sage dem Assistenten dieses Geräts:

```
Prüfe die Zotero-Memory-Backups meiner anderen Geräte (memory_zotero_sync, action "status") und zeige mir, welche Einträge hier fehlen. Importiere gezielt, was für deine Arbeit hier nützlich ist — passende Einträge direkt mit memory_store übernehmen (Tag quelle:cross-import, Herkunft ins Source-Feld). Nichts Eigenes wird überschrieben oder gelöscht; was ich bewusst gelöscht habe, kommt nicht zurück. Berichte, was du importiert hast und warum.
```

Das ist bewusst so: Importe passieren **nur auf deine ausdrückliche Anweisung** — was du auf einem Gerät gelöscht hast, kommt auf einem anderen nicht zurück. Aufräumen auf einem Gerät bleibt endgültig.

### 12.5 Alle 2–4 Wochen: Webseiten-Check

Unsere KI-Seiten auf www.logies.de werden weiterentwickelt. Ein einziger wiederkehrender Auftrag hält deine Installation auf dem Stand der Anleitung (z. B. jeden 1. und 3. Freitag):

```
Führe den 2-4-Wochen-Check aus: Prüfe die KI-Seiten auf www.logies.de (Studienarbeitsplatz, Memory-MCP für KI-Agenten, die Knowledge-Dateien): Gibt es neue Versionen, Empfehlungen oder Änderungen, die deine Installation (Zoteus, Embeddings, Memory-Praxis) oder dein Memory verbessern? Setze um, was passt, und berichte mir, was du geändert hast.
```

Das Lernen von anderen Geräten machst du bei Bedarf nach §12.4 — es passiert nicht automatisch.

---

## 13. Optional: Google Drive einbinden (rclone)

**Dieser Baustein ist bewusst optional** — die Einrichtung ist etwas fummelig, weil die Google-Oberfläche für die OAuth-Freigabe leider nicht intuitiv ist. Überspringen kostet dich nichts. Sie lohnt sich insbesondere, wenn:

- du einen **stabilen, dauerhaften Zugriff auf dein Google Drive über den Double Commander** willst — dann kopierst du Dateien hin und her wie auf eine lokale Platte, ohne Browser-Upload
- **KeePassXC seine Passwortdatei zuverlässig über Google Drive synchronisieren** soll — lege die Datenbankdatei einfach in `~/GoogleDrive` ab und öffne sie von dort; dann ist sie auf allen deinen Geräten am gleichen Stand

Du kannst diesen Abschnitt auch von deinem KI-Assistenten abarbeiten lassen: *„Arbeite §13 dieser Anleitung ab und richte mir rclone mit Google Drive ein. Frag mich, wenn du Zugangsdaten oder Bestätigungen von mir brauchst."*

### 13.1 rclone installieren und konfigurieren

```bash
sudo apt install -y rclone
```

**Einrichtung:**
```bash
rclone config
```
- `n` für neue Konfiguration
- Name: `GoogleDrive`
- Google Drive auswählen
- **client_id** und **client_secret**: hier gehört dein eigener Google-API-Key rein (kleinschrittige Anleitung im nächsten Schritt). Du kannst beide Fragen erst mal mit **Enter** leer lassen, die Konfiguration durchklicken und `rclone config` danach wiederholen, wenn der Key bereit ist
- Beim Scope: `1` (drive) wählen
- Rest mit Enter bestätigen
- `q` zum Beenden

### 13.2 Eigenen Google-API-Key erstellen — kleinschrittige Anleitung

Hintergrund: Ohne eigenen Key teilen sich alle rclone-Nutzer denselben Zugang, was Transfers deutlich drosselt. Leider ist Googles Oberfläche für OAuth nicht intuitiv — deshalb hier jeder einzelne Klick:

1. Im Browser [console.cloud.google.com](https://console.cloud.google.com) öffnen und mit deinem Google-Konto anmelden
2. Oben in der Leiste: **Projekt anlegen** — Name z. B. „rclone", dann **Erstellen**. Danach prüfen, dass das neue Projekt oben in der Projektauswahl tatsächlich aktiv ist (häufigster Stolperstein)
3. Menü (☰) oben links → **APIs & Dienste** → **Bibliothek** → nach „Google Drive API" suchen → **Aktivieren**
4. Zurück zu **APIs & Dienste** → **OAuth-Zustimmungsbildschirm** → User-Typ **Extern** → **Erstellen** → App-Name eintragen (z. B. „rclone") und deine E-Mail-Adresse als Support-/Entwicklerkontakt angeben → die folgenden Seiten jeweils mit **Speichern und fortfahren** durchklicken
5. **APIs & Dienste** → **Anmeldedaten** → **+ Anmeldedaten erstellen** → **OAuth-Client-ID** → Anwendungstyp **Desktop-App** → **Erstellen**
6. **Client-ID** und **Clientschlüssel** kopieren (Kopier-Symbole neben den Werten) — genau diese beiden Werte fragt rclone bei `client_id` und `client_secret` ab
7. **Wichtig — „In Produktion" stellen:** zurück zum **OAuth-Zustimmungsbildschirm** → **APP VERÖFFENTLICHEN** → mit **Bestätigen** abschließen. Sonst läuft die Anmeldung nach 7 Tagen ab und du musst dich ständig neu autorisieren

Danach in `rclone config` (§13.1) die beiden Werte eintragen und die Google-Anmeldung im Browser abschließen.

### 13.3 Automatisches Einbinden (systemd-Dienst)

Damit das Drive nach jedem Neustart automatisch eingebunden ist:

```bash
mkdir -p ~/GoogleDrive
mkdir -p ~/.config/systemd/user/
nano ~/.config/systemd/user/rclone-mount.service
```

Folgenden Inhalt einfügen (mit **Strg+Umschalt+V**):
```ini
[Unit]
Description=Rclone Mount für Google Drive
After=network-online.target

[Service]
Type=simple
ExecStart=/usr/bin/rclone mount GoogleDrive: %h/GoogleDrive --vfs-cache-mode full
ExecStop=/bin/fusermount3 -u %h/GoogleDrive
Restart=on-failure
RestartSec=10

[Install]
WantedBy=default.target
```

Speichern mit **Strg+O**, Enter, dann **Strg+X** zum Beenden.

Dienst aktivieren:
```bash
systemctl --user daemon-reload
systemctl --user enable rclone-mount.service
systemctl --user start rclone-mount.service
```

**Test:**
```bash
systemctl --user status rclone-mount.service
ls -la ~/GoogleDrive
```

**Bonus: Die VM vom Handy aus steuern.** Dein Arbeitsplatz verliert seinen Assistenten nicht, nur weil du unterwegs bist: Mit Termius (SSH), dem WireGuard-VPN der FRITZ!Box und diktierenden Tastaturen steuerst du die VM vom Handy aus — Aufträge sprechen, Ergebnisse lesen, unterwegs weiterarbeiten. Die ausführliche Schritt-für-Schritt-Anleitung (deutsch) steht auf unserer Seite: [Die Linux-VM vom Handy aus steuern](linux-vm-vom-handy-steuern.html).

*Erstellt von Qwen Code (glm-5.3-flash) für www.logies.de — erste Fassung mit deepseek-v4-flash — CC0, frei zur Weitergabe.*
*Stand: 4. September 2026 | Bei Fragen oder Updates: die Webseiten www.logies.de prüfen, dort sind die aktuellsten Informationen.*