Second Brain mit Telegram, Obsidian und Claude Code: Ein Self-Hosted-Setup für den DACH-Raum
Wie ich mit Telegram als Capture-Tool, CouchDB LiveSync für Multi-Device-Sync, nativen Obsidian-Apps und Claude Code als KI-Organisator ein vollständig selbst gehostetes Second Brain gebaut habe.
Second Brain mit Telegram, Obsidian und Claude Code: Ein Self-Hosted-Setup für den DACH-Raum
Jeder kennt das Problem: Eine Idee kommt unterwegs, ein Link fällt im Chat auf, eine Sprachnachricht enthält den Kern eines neuen Projekts — und drei Stunden später ist alles vergessen. Die Lösung heißt seit Jahren „Second Brain” — ein persönliches Wissensmanagementsystem, das Gedanken auffängt, strukturiert und durchsuchbar macht.
Die meisten Second-Brain-Setups scheitern aber an einem von zwei Punkten: Entweder ist die Erfassung zu umständlich (wer öffnet unterwegs schon eine Notiz-App, um einen schnellen Gedanken zu tippen?) oder die Organisation bleibt liegen, weil niemand Lust hat, abends seine Inbox durchzusortieren.
Dieses Setup löst beide Probleme. Telegram dient als Quick-Capture-Interface — schneller als jede Notiz-App, immer griffbereit, mit Sprachnachrichten-Support. CouchDB synchronisiert das Obsidian-Vault in Echtzeit über alle Geräte. Und Claude Code übernimmt die Strukturierung: Kategorisierung, Tagging, Zusammenfassungen und Einordnung in die Wissensdatenbank — automatisiert und auf Wunsch im Hintergrund. Alles Self-Hosted, alles unter eigener Kontrolle.
Architektur im Überblick
Die Pipeline besteht aus vier Komponenten, die jeweils eine klar definierte Rolle übernehmen:
Telegram (Handy/Desktop)
│
▼
Telegram Sync Plugin ──► Obsidian Desktop (immer laufend)
│
├──► CouchDB (Docker/NAS) ──► LiveSync ──► Obsidian Mobile + Laptop
│
▼
Claude Code (periodisch)
│
▼
Strukturierte Notes im VaultTelegram ist das Capture-Interface. Du schickst dir selbst Nachrichten — Text, Links, Bilder, Sprachnachrichten — über einen eigenen Telegram-Bot. Kein Zugriff auf fremde Chats, kein Reverse Engineering einer proprietären API.
Obsidian mit Telegram Sync Plugin läuft auf einem Desktop-Rechner (oder in einem Docker-Container via obsidian-remote) und empfängt die Telegram-Nachrichten als Markdown-Notes direkt im Vault. Das Plugin nutzt die offizielle Telegram Bot API und hat über 35.000 Installationen im Obsidian Community Store.
CouchDB mit LiveSync hält das Vault über alle Geräte synchron — Handy (native Obsidian-App), Laptop, Desktop. End-to-End-Verschlüsselung optional. Läuft in Docker auf dem NAS oder einem beliebigen Server.
Claude Code greift per Filesystem-MCP-Server auf das Vault zu und organisiert den Content: Inbox verarbeiten, Notizen taggen, Zusammenfassungen generieren, Wikilinks setzen, Daily Notes erstellen.
Warum Telegram statt WhatsApp?
Die Entscheidung für Telegram über WhatsApp ist nicht nur eine Geschmacksfrage — sie hat handfeste technische und rechtliche Gründe.
WhatsApp bietet keine offizielle API für persönliche Accounts. Jede Integration nutzt inoffizielle Bibliotheken wie Baileys oder whatsapp-web.js, die das WhatsApp-Web-Protokoll reverse-engineeren. Das verstößt gegen Metas Nutzungsbedingungen und führt regelmäßig zu Account-Sperrungen. Schlimmer noch: Diese Bibliotheken operieren auf einem All-or-Nothing-Modell — einmal verbunden, hat der MCP-Server Zugriff auf sämtliche Chats, Kontakte und Medien des gesamten Accounts. Eine Einschränkung auf bestimmte Gruppen oder Chats ist auf Protokollebene nicht möglich.
Telegram löst all diese Probleme. Die Bot API ist offiziell, dokumentiert und stabil. Ein Bot kann nur Nachrichten empfangen, die explizit an ihn gesendet werden — kein Zugriff auf andere Chats, keine Kontaktlisten, keine Medien aus Gruppenchats. Die Kommunikation ist auf den Bot-Kontext beschränkt. Für den DACH-Raum besonders relevant: Telegram speichert Daten in einem verteilten Rechenzentrum-System mit Standorten in Europa, und die Bot-API-Daten werden serverseitig nach 24 Stunden gelöscht, wenn sie nicht abgerufen werden.
Das Obsidian Telegram Sync Plugin nutzt diese offizielle Bot API und unterstützt Text, Bilder, Dateien, Sprachnachrichten (mit Transkription für Telegram-Premium-Nutzer), konfigurierbare Templates für neue Notizen, automatische Markdown-Formatierung und optionales Löschen der verarbeiteten Nachrichten in Telegram.
Schritt 1: Telegram-Bot erstellen
Die Bot-Erstellung dauert zwei Minuten. Öffne Telegram und suche nach @BotFather. Starte einen Chat und sende /newbot. BotFather fragt nach einem Namen (z.B. „Second Brain Capture”) und einem Username (z.B. stagl_brain_bot). Nach der Erstellung erhältst du einen API-Token im Format 123456789:ABCdefGHIjklMNOpqrsTUVwxyz.
Diesen Token brauchst du im nächsten Schritt für das Obsidian-Plugin. Wichtig: Teile den Token mit niemandem — wer ihn hat, kann Nachrichten an deinen Bot senden und empfangen.
Optional, aber empfehlenswert: Sende /setdescription an BotFather und setze eine Beschreibung wie „Persönliches Second Brain Capture – nur für mich”. Dann /setuserpic für ein Profilbild, damit der Bot in der Chat-Liste sofort erkennbar ist.
Für die Sicherheit lässt sich im Telegram Sync Plugin eine Allowlist konfigurieren — nur Nachrichten von deiner eigenen Telegram-User-ID werden verarbeitet. Deine User-ID findest du über @userinfobot in Telegram.
Schritt 2: Obsidian mit Telegram Sync Plugin einrichten
Installiere Obsidian auf dem Rechner, der als „Hub” dienen soll — idealerweise ein immer laufender Desktop, ein Home-Server, oder ein Docker-Container. Das Telegram Sync Plugin ist ein offizielles Community Plugin und lässt sich direkt über den Plugin-Browser installieren: Einstellungen → Community Plugins → Browse → „Telegram Sync” suchen → Installieren → Aktivieren.
In den Plugin-Einstellungen trägst du den Bot-Token ein. Die wichtigsten Konfigurationsoptionen:
Speicherort für neue Nachrichten: Setze den Pfad auf 00-Inbox/telegram/ — so landen alle eingehenden Nachrichten in einem dedizierten Inbox-Ordner, den Claude Code später verarbeitet.
Template für neue Notizen: Hier definierst du, wie eingehende Nachrichten als Markdown-Notes formatiert werden. Ein sinnvolles Template:
---
title: "{{title}}"
source: telegram
date: {{date:YYYY-MM-DD}}
captured_at: {{date:YYYY-MM-DDTHH:mm}}
tags: [source/telegram, status/inbox]
type: capture
---
{{content}}Nachrichten nach Verarbeitung löschen: Optional kannst du einstellen, dass verarbeitete Nachrichten automatisch aus dem Telegram-Chat gelöscht werden, um die Inbox dort sauber zu halten.
Append-Modus: Statt für jede Nachricht eine neue Notiz zu erstellen, kannst du Nachrichten auch an die tägliche Daily Note anhängen. Das ist nützlich für kurze Gedankenfetzen, die keinen eigenen Eintrag rechtfertigen.
Ein wichtiger Hinweis: Das Telegram Sync Plugin funktioniert nur auf der Desktop-Version von Obsidian, nicht auf Mobile. Das ist kein Problem, wenn der Desktop-Rechner oder Docker-Container dauerhaft läuft — er empfängt die Nachrichten im Hintergrund und schreibt sie ins Vault. Die mobilen Geräte sehen die neuen Notes dann über LiveSync.
Schritt 3: CouchDB und LiveSync für Multi-Device-Sync
Das Obsidian-Vault soll nicht nur auf dem Hub-Rechner verfügbar sein, sondern auf allen Geräten — Handy, Laptop, Tablet. Hier kommt CouchDB mit dem Self-hosted LiveSync Plugin ins Spiel.
CouchDB in Docker auf dem NAS
CouchDB ist eine dokumentenorientierte Datenbank, die von Haus aus für Replikation und Sync gebaut wurde. Das macht sie ideal als Backend für Obsidian LiveSync. Auf deinem NAS (z.B. UGREEN) oder einem beliebigen Docker-Host erstellst du folgende docker-compose.yml:
services:
couchdb:
image: couchdb:latest
container_name: obsidian-couchdb
restart: unless-stopped
ports:
- "5984:5984"
environment:
- COUCHDB_USER=admin
- COUCHDB_PASSWORD=ein-sicheres-passwort-hier
volumes:
- couchdb-data:/opt/couchdb/data
- couchdb-config:/opt/couchdb/etc/local.d
networks:
- second-brain
volumes:
couchdb-data:
couchdb-config:
networks:
second-brain:
driver: bridgeStarte mit docker compose up -d. CouchDB ist danach unter http://dein-nas:5984 erreichbar. Die Fauxton-Admin-Oberfläche findest du unter http://dein-nas:5984/_utils.
CouchDB für LiveSync konfigurieren
Nach dem Start muss CouchDB für LiveSync optimiert werden. Führe folgende Befehle gegen die CouchDB-API aus (ersetze admin:password und hostname entsprechend):
# CORS aktivieren
curl -X PUT http://admin:password@localhost:5984/_node/_local/_config/httpd/enable_cors -d '"true"'
curl -X PUT http://admin:password@localhost:5984/_node/_local/_config/cors/origins -d '"app://obsidian.md,capacitor://localhost,http://localhost"'
curl -X PUT http://admin:password@localhost:5984/_node/_local/_config/cors/credentials -d '"true"'
curl -X PUT http://admin:password@localhost:5984/_node/_local/_config/cors/methods -d '"GET, PUT, POST, HEAD, DELETE"'
curl -X PUT http://admin:password@localhost:5984/_node/_local/_config/cors/headers -d '"accept, authorization, content-type, origin, referer"'
# Performance-Optimierungen
curl -X PUT http://admin:password@localhost:5984/_node/_local/_config/chttpd/max_http_request_size -d '"4294967296"'LiveSync-Plugin auf allen Geräten einrichten
Installiere das Plugin „Self-hosted LiveSync” auf jedem Gerät über den Community Plugin Browser. Auf dem Hub-Rechner (wo auch Telegram Sync läuft) konfigurierst du als erstes:
Öffne die LiveSync-Einstellungen → Setup-Wizard → „Discard existing preferences and setup”. Trage die CouchDB-URL ein: http://dein-nas:5984 (oder https:// wenn du einen Reverse Proxy mit SSL davor hast — empfohlen für Mobile-Zugriff). Wähle einen Datenbanknamen wie obsidian-secondbrain, gib die CouchDB-Credentials ein, und teste die Verbindung.
Aktiviere „LiveSync” als Sync-Modus — das synchronisiert Änderungen in Echtzeit, nicht erst bei manuellem Trigger. Optional: Aktiviere End-to-End-Verschlüsselung mit einer Passphrase, die du dir separat merkst.
Nach der Konfiguration generiert LiveSync eine Setup-URI (unter Setup → „Copy setup URI”). Diese URI enthält alle Verbindungsdaten verschlüsselt. Auf jedem weiteren Gerät installierst du LiveSync, wählst „Open setup URI”, fügst die URI ein, gibst die Passphrase ein — fertig. Der Sync startet sofort.
Zugriff über Tailscale
Wenn du Tailscale bereits nutzt (was bei einem Self-Hosted-Setup im DACH-Raum fast Standard ist), ist der CouchDB-Zugang von unterwegs trivial: CouchDB ist über die Tailscale-IP des NAS erreichbar, verschlüsselt und ohne Port-Forwarding. In den LiveSync-Einstellungen auf dem Handy gibst du statt localhost einfach die Tailscale-IP ein, z.B. http://100.64.x.x:5984.
Schritt 4: Claude Code als KI-Organisator
Hier wird das Setup intelligent. Claude Code greift per Filesystem-MCP-Server auf das Obsidian-Vault zu und verarbeitet die unstrukturierten Telegram-Captures zu sauberen, verlinkten, getaggten Notizen.
Claude Code mit Pro-Subscription nutzen
Claude Code ist im Claude Pro-Abo enthalten — kein separater API-Key nötig. Installiere Claude Code über npm:
npm install -g @anthropic-ai/claude-codeBeim ersten Start wähle „Subscription” als Login-Methode und authentifiziere dich über den Browser. Die Credentials werden lokal gespeichert.
MCP-Server für Vault-Zugriff konfigurieren
Claude Code braucht einen MCP-Server, um auf das Obsidian-Vault zugreifen zu können. Der einfachste Ansatz nutzt den offiziellen Filesystem-MCP-Server von Anthropic:
claude mcp add obsidian-vault -- npx -y @modelcontextprotocol/server-filesystem /pfad/zum/vaultDieser Server stellt 14 Tools bereit: read_file, write_file, edit_file, create_directory, list_directory, search_files und mehr. Keine laufende Obsidian-Instanz nötig — der Server arbeitet direkt auf dem Dateisystem.
Für Obsidian-spezifische Features wie Tag-Management und Frontmatter-Bearbeitung empfiehlt sich zusätzlich der spezialisierte Server obsidian-mcp:
claude mcp add obsidian -- npx -y obsidian-mcp /pfad/zum/vaultCLAUDE.md: Die Anweisungen für die Vault-Organisation
Im Root-Verzeichnis des Vaults erstelle eine CLAUDE.md-Datei. Diese wird von Claude Code bei jedem Start automatisch gelesen und definiert die Regeln für die Content-Organisation:
# Second Brain – Vault-Organisationsregeln
## Vault-Struktur
- `/00-Inbox/telegram/` — Rohe Telegram-Captures (hier nicht ändern, nur lesen)
- `/01-Projekte/` — Aktive Projektnotizen
- `/02-Bereiche/` — Laufende Verantwortungsbereiche
- `/03-Ressourcen/` — Referenzmaterial, Links, Artikel
- `/04-Archiv/` — Inaktive oder abgeschlossene Einträge
- `/05-Notizen/` — Atomare, permanente Notizen (Zettelkasten)
- `/06-Daily/` — Tägliche Journaleinträge (YYYY-MM-DD.md)
## Verarbeitungsregeln
Wenn du Dateien in `/00-Inbox/telegram/` findest:
1. Lies jede unverarbeitete Notiz (erkennbar am Tag `status/inbox`)
2. Erstelle eine Zusammenfassung in 2-3 Sätzen
3. Extrahiere Aufgaben als `- [ ]` Checkboxen
4. Generiere 3-5 Tags mit verschachtelter Taxonomie:
- Typ: #typ/flüchtig, #typ/permanent, #typ/referenz, #typ/aufgabe
- Quelle: #quelle/telegram, #quelle/web, #quelle/buch
- Status: #status/inbox, #status/verarbeitet, #status/überprüft
5. Suche im Vault nach verwandten Notizen und setze [[Wikilinks]]
6. Verschiebe die Notiz in den passenden Ordner:
- Enthält Deadline oder Aufgabe → `/01-Projekte/`
- Ist ein Link oder Artikel → `/03-Ressourcen/`
- Ist ein Gedanke oder Idee → `/05-Notizen/`
- Enthält Tagesbezug → Anhängen an `/06-Daily/` des jeweiligen Datums
7. Ändere den Status-Tag auf `status/verarbeitet`
8. Aktualisiere die Frontmatter:
- Setze `processed_at` auf das aktuelle Datum
- Ergänze `related` mit Pfaden zu verwandten Notizen
## Wichtige Regeln
- NIEMALS bestehende Notizen löschen
- NIEMALS Duplikate erstellen — immer zuerst suchen
- Schreibe alle Notizen auf Deutsch
- Verwende die du-Form in Zusammenfassungen
- Halte Zusammenfassungen konkret und actionablePeriodische Verarbeitung mit Headless-Modus
Claude Code kann im Headless-Modus (-p Flag) ohne interaktives Terminal ausgeführt werden — perfekt für automatisierte Verarbeitung:
claude -p "Verarbeite alle neuen Telegram-Captures im Inbox-Ordner gemäß den Regeln in CLAUDE.md. Fasse zusammen, was du getan hast." \
--allowedTools "mcp__obsidian-vault__read_file,mcp__obsidian-vault__write_file,mcp__obsidian-vault__edit_file,mcp__obsidian-vault__list_directory,mcp__obsidian-vault__search_files,mcp__obsidian-vault__create_directory" \
--max-turns 25 \
--output-format jsonDie --allowedTools-Liste ist bewusst restriktiv: Nur Lese- und Schreiboperationen auf dem Vault sind erlaubt — keine Shell-Befehle, keine Netzwerkzugriffe.
Auf Windows lässt sich das über den Task Scheduler automatisieren — z.B. alle 30 Minuten oder einmal abends um 21 Uhr. Auf Linux/NAS über einen klassischen Cron-Job:
# Crontab: Jeden Abend um 21:00 Inbox verarbeiten
0 21 * * * cd /pfad/zum/vault && claude -p "Verarbeite die Telegram-Inbox" --max-turns 25Vault-Struktur für KI-gestützte Organisation
Die Ordnerstruktur folgt dem PARA-Prinzip (Projects, Areas, Resources, Archive) von Tiago Forte, ergänzt um einen Zettelkasten-Bereich für atomare Notizen und einen Daily-Notes-Ordner:
vault/
├── 00-Inbox/
│ └── telegram/ # Telegram Sync schreibt hierhin
├── 01-Projekte/ # Aktive Vorhaben mit Deadline
├── 02-Bereiche/ # Laufende Verantwortlichkeiten (Arbeit, Familie, Gesundheit)
├── 03-Ressourcen/ # Referenzmaterial, Bookmarks, Artikel
├── 04-Archiv/ # Abgeschlossenes
├── 05-Notizen/ # Atomare permanente Notizen
├── 06-Daily/ # YYYY-MM-DD.md Tagesnotizen
├── _templates/ # Obsidian-Templates
├── _attachments/ # Bilder, PDFs, Medien
└── CLAUDE.md # Anweisungen für Claude CodeDie nummerierten Präfixe sorgen für eine stabile Sortierung in Obsidians Datei-Explorer. Der Underscore-Präfix bei _templates und _attachments hält Verwaltungsordner am Ende der Liste.
Jede von Claude Code verarbeitete Notiz erhält Frontmatter nach diesem Schema:
---
title: "Beschreibender Titel"
type: capture | permanent | reference | task
source: telegram
date: 2026-03-11
captured_at: 2026-03-11T14:30
processed_at: 2026-03-11T21:00
tags:
- quelle/telegram
- typ/referenz
- status/verarbeitet
- thema/kubernetes
related:
- "[[03-Ressourcen/K8s-Multi-Cluster-Strategie]]"
- "[[01-Projekte/DataOps-Pipeline-Q2]]"
---Das komplette Docker-Compose-Setup
Alle Komponenten lassen sich in einem einzigen Docker-Compose-Stack zusammenfassen. Dieses Setup setzt voraus, dass der Vault-Ordner auf dem Host existiert und Obsidian Desktop (mit Telegram Sync Plugin) entweder nativ oder über obsidian-remote läuft:
services:
# CouchDB für LiveSync
couchdb:
image: couchdb:latest
container_name: secondbrain-couchdb
restart: unless-stopped
ports:
- "5984:5984"
environment:
- COUCHDB_USER=admin
- COUCHDB_PASSWORD=${COUCHDB_PASSWORD}
volumes:
- couchdb-data:/opt/couchdb/data
- couchdb-config:/opt/couchdb/etc/local.d
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:5984/"]
interval: 30s
timeout: 5s
retries: 3
# Obsidian im Browser (optional, für Zugriff ohne native App)
obsidian-remote:
image: ghcr.io/sytone/obsidian-remote:latest
container_name: secondbrain-obsidian
restart: unless-stopped
ports:
- "8080:8080"
volumes:
- ${VAULT_PATH}:/vaults/SecondBrain
- obsidian-config:/config
environment:
- PUID=1000
- PGID=1000
- TZ=Europe/Vienna
- PASSWORD=${OBSIDIAN_WEB_PASSWORD}
volumes:
couchdb-data:
couchdb-config:
obsidian-config:Dazu eine .env-Datei:
VAULT_PATH=/pfad/zum/ObsidianVault
COUCHDB_PASSWORD=ein-langes-sicheres-passwort
OBSIDIAN_WEB_PASSWORD=web-zugangs-passwortStart: docker compose up -d
Sicherheit und DSGVO-Bewertung
Für IT-Entscheider im DACH-Raum ist die DSGVO-Konformität kein Nice-to-have, sondern Pflicht. Dieses Setup schneidet deutlich besser ab als WhatsApp-basierte Alternativen:
Datenfluss Telegram: Nachrichten an den Bot werden über Telegrams Server geroutet (verschlüsselt in Transit, aber nicht Ende-zu-Ende). Bot-API-Daten werden serverseitig nach 24 Stunden gelöscht, wenn sie nicht abgerufen wurden. Telegram speichert Daten in einem verteilten System mit Rechenzentren, die für europäische Nutzer primär in Amsterdam und London stehen. Kein Zugriff auf fremde Chats — der Bot sieht nur, was explizit an ihn gesendet wird.
Datenfluss CouchDB/LiveSync: Vollständig unter eigener Kontrolle. Die Daten verlassen nie dein Netzwerk (NAS/Server). End-to-End-Verschlüsselung ist im LiveSync-Plugin optional aktivierbar — dann sind die Daten auch auf dem CouchDB-Server nur verschlüsselt gespeichert.
Datenfluss Claude Code: Hier liegt der sensibelste Punkt. Claude Code sendet den Vault-Content zur Verarbeitung an Anthropics API-Server in den USA. Unter dem Pro-Abo gelten Anthropics Consumer Terms — Daten können für Training verwendet werden (Opt-out über Privacy Settings erforderlich). Für Unternehmensdaten empfiehlt sich ein API-Key unter Commercial Terms mit Data Processing Agreement und Standard Contractual Clauses, oder die Nutzung über Amazon Bedrock in der EU-Region Frankfurt.
Mitigations-Strategien: Für maximale Kontrolle lässt sich Claude Code über die Umgebungsvariable ANTHROPIC_BASE_URL auch an lokale Modelle (Ollama, vLLM) redirecten. Die Qualität ist dann geringer, aber die Daten bleiben vollständig lokal. Alternativ: Nur nicht-sensible Captures per Claude Code verarbeiten lassen und vertrauliche Notizen manuell sortieren.
Vergleich mit WhatsApp-basierten Setups: WhatsApp-MCP-Server nutzen inoffizielle APIs (Bann-Risiko), haben Vollzugriff auf alle Chats (nicht einschränkbar), und Nachrichten fließen über Meta-Server mit intransparentem Datenhandling. Invariant Labs hat bereits einen funktionierenden Prompt-Injection-Angriff gegen WhatsApp-MCP demonstriert, bei dem eingehende Nachrichten die KI manipulieren und Chat-Verläufe exfiltrieren konnten. Das Telegram-Bot-Modell eliminiert diese Angriffsfläche fast vollständig, da der Bot nur selbst gesendete Nachrichten verarbeitet.
Workflow im Alltag
Der tägliche Workflow ist bewusst reibungsarm gestaltet:
Capture (jederzeit, überall): Öffne den Telegram-Chat mit deinem Bot. Tippe einen Gedanken, schicke einen Link, nimm eine Sprachnachricht auf. Fertig — die Hürde ist exakt so niedrig wie eine WhatsApp-Nachricht an dich selbst, aber mit dem entscheidenden Unterschied, dass kein proprietäres Ökosystem dazwischenhängt.
Automatische Sync (Echtzeit): Das Telegram Sync Plugin auf dem Hub-Rechner schreibt die Nachricht sofort als Markdown-Note in /00-Inbox/telegram/. CouchDB LiveSync verteilt die Änderung innerhalb von Sekunden auf alle verbundenen Geräte. Auf dem Handy öffnest du Obsidian und siehst die neue Notiz bereits im Inbox-Ordner.
KI-Verarbeitung (periodisch): Abends um 21 Uhr (oder nach individuellem Zeitplan) läuft Claude Code im Headless-Modus über die Inbox. Es liest jede neue Capture-Notiz, generiert eine Zusammenfassung, extrahiert Aufgaben, vergibt Tags, sucht nach verwandten Notizen im Vault, setzt Wikilinks, und verschiebt die Notiz in den richtigen Ordner. Am nächsten Morgen ist die Inbox leer und alle Gedanken sind eingeordnet.
Manuelle Review (wöchentlich): Einmal pro Woche öffnest du die Notizen mit dem Tag status/verarbeitet und überprüfst Claudes Arbeit. Passen die Tags? Stimmen die Links? Soll die Notiz zu einer permanenten Zettelkasten-Notiz ausgebaut werden? Dieser menschliche Review-Schritt ist entscheidend für die langfristige Qualität des Vaults.
Fazit
Dieses Setup löst ein reales Problem mit ausschließlich Open-Source-Komponenten und Self-Hosted-Infrastruktur. Telegram als Capture-Layer ist schneller als jede Notiz-App und sicherer als WhatsApp-basierte Alternativen. CouchDB mit LiveSync eliminiert die Abhängigkeit von Obsidians kostenpflichtigem Sync-Service und gibt die volle Kontrolle über die Daten. Claude Code als KI-Organisator übernimmt die Arbeit, die niemand gerne macht — Inbox sortieren, taggen, verlinken — und macht sie besser als die meisten Menschen es manuell tun würden.
Die Kosten: Obsidian ist kostenlos für persönliche Nutzung. CouchDB ist Open Source. Telegram ist kostenlos. Claude Code ist im Pro-Abo (20 USD/Monat) enthalten. Kein zusätzlicher Sync-Service, kein SaaS-Abo für Capture, kein Vendor Lock-in bei der Datenhaltung.
Für IT-Entscheider im DACH-Raum ist besonders relevant: Die gesamte Datenhaltung (CouchDB, Vault-Dateien) bleibt im eigenen Netzwerk. Der einzige externe Datenfluss ist die Claude-API-Verbindung, die sich durch API-Wahl (Bedrock EU), lokale Modelle, oder selektive Verarbeitung kontrollieren lässt. Das ist ein deutlicher Fortschritt gegenüber Cloud-First-Lösungen wie Notion oder Evernote, bei denen alle Daten auf US-Servern liegen.
Der Stack ist modular: Wer Telegram nicht mag, tauscht das Capture-Plugin aus. Wer Claude nicht vertraut, nutzt Ollama lokal. Wer kein NAS hat, hostet CouchDB bei einem europäischen Provider. Jede Komponente ist austauschbar, keine ist ein Single Point of Failure. Das ist die Stärke eines Setups, das auf offenen Standards statt auf proprietären Integrationen aufbaut.