yt-mem-ai — ein lokaler YouTube-Speicher für deinen KI-Assistenten

Gib Claude, Codex, Cursor oder einem beliebigen MCP-Host die Fähigkeit, YouTube für dich zu schauen: Videos transkribieren, sie merken, deinen Abonnements folgen und alles in Zusammenfassungen, Zeitstempel-Highlights, Q&A, Digests und Video-Reels verwandeln. Alles läuft auf deinem Rechner — kein Cloud-Dienst, kein API-Schlüssel.

Beispiel — „Erstelle eine Präsentation aus diesem Video" (Andrej Karpathy: From Vibe Coding to Agentic Engineering, Sequoia, 30 Min.) → 13 Folien, PDF, jedes Zitat mit Zeitstempel aus dem Transkript. Vom Ingest zum Deck in einer einzigen Anfrage.

Inhaltsverzeichnis

• Funktionen

• Installation

• Erste Schritte

• Verwendung

• Beispiele

• Konfiguration

• Unter der Haube

Related MCP server: YouTube MCP Server

Funktionen

• 🎧 Transkribiert jedes Video — YouTube-Untertitel, wenn vorhanden (schnell, jede Sprache), offline Whisper, wenn nicht.

• 🧠 Merkt sich, was du gesehen hast — jedes Transkript wird lokal gespeichert und indexiert, damit deine Bibliothek für immer durchsuchbar bleibt. Nichts verlässt deinen Rechner.

• 🔎 Findet den Moment — frag „Was hat das Video zu X gesagt?" und erhalte die Antwort mit einem Zeitstempel, zu dem du springen kannst.

• 📡 Folgt deinen Abonnements — erkennt neue Uploads und verwandelt den Tag in einen Digest.

• ✍️ Dein Assistent übernimmt das Schreiben — Zusammenfassungen, Highlights, Q&A, Folien-Decks, alles in der Sprache des Videos, mit dem Modell, das du ohnehin bezahlst.

• ❤️ Lernt deinen Geschmack — magst du Videos oder nicht, und erhalte Empfehlungen aus deiner eigenen Bibliothek.

• 🎬 Erstellt auch Medien — klickbare Highlight-Dokumente, Standbilder und gerenderte Supercut-Reels.

• 🔌 Funktioniert mit deinen Tools — Claude Code, Claude Desktop, Codex, Cursor, Antigravity, OpenClaw, Hermes: Skills oder MCP, deine Wahl.

Installation

1. Verbinde deinen Assistenten ⭐

curl -LsSf https://raw.githubusercontent.com/dasein108/yt-mem-ai/main/install.sh | sh

Ein interaktiver Assistent öffnet sich. Wähle, was du möchtest, hake deine Apps an, drücke Enter:

step 1/2 — what (pick one)     step 2/2 — where (tick any)
> Plugin  skills + CLI         [x] Claude Code    [ ] Claude Desktop
  MCP     typed tools          [x] Codex          [ ] Cursor
                               [ ] Antigravity    [ ] OpenClaw   [ ] Hermes

Plugin bringt deinem Assistenten bei, auf einfache Anfragen zu reagieren — „fasse dieses Video zusammen". MCP gibt ihm stattdessen einen Satz Tools. Unsicher? Beginne mit Plugin; du kannst den Assistenten später erneut für das andere ausführen.

Es installiert alles, was es braucht, hakt ab, was du bereits hast, und entfernt alles, was du abwählst (es zeigt einen Plan und fragt zuerst). Dann starte die App neu und versuche: fasse 'https://youtu.be/…' zusammen.

Du weißt schon, was du willst? Überspringe die Fragen:

curl -LsSf https://raw.githubusercontent.com/dasein108/yt-mem-ai/main/install.sh \
  | sh -s -- --plugin --claude-code --codex
curl -LsSf https://raw.githubusercontent.com/dasein108/yt-mem-ai/main/install.sh \
  | sh -s -- --mcp --claude-desktop --cursor

Hosts: --claude-code --claude-desktop --codex --cursor --antigravity --openclaw --hermes oder --all. Vollständige Flag-Liste und Deinstallationshinweise: integrations/README.md. Lieber einen Agenten machen lassen? Füge integrations/PROMPT.md in einen beliebigen Assistenten ein.

2. MCP von Hand — ein Konfigurationseintrag, selbstinstallierend

Keine vorherige Installation nötig: uvx holt das Paket beim ersten Start des Servers durch den Host und hält es danach im Cache. Füge das in die MCP-Konfig deines Hosts ein:

{
  "mcpServers": {
    "yt-mem-ai": {
      "command": "uvx",
      "args": ["--from", "yt-mem-ai[mcp]", "yt-ai-mcp"]
    }
  }
}

Das ist die gesamte Einrichtung — keine Pfade, kein env-Block. Einstellungen liegen in ~/.yt-mem-ai/config.env und der Agent kann sie selbst mit dem config_set-Tool schreiben (oder du mit yt-ai config set).

# ~/.codex/config.toml
[mcp_servers.yt-mem-ai]
command = "uvx"
args = ["--from", "yt-mem-ai[mcp]", "yt-ai-mcp"]

# ~/.hermes/config.yaml
mcp_servers:
  yt-mem-ai:
    command: "uvx"
    args: ["--from", "yt-mem-ai[mcp]", "yt-ai-mcp"]
    enabled: true

Starte die App neu und die Tools erscheinen — siehe Verwendung für das, was sie tun.

Nichts erschienen, oder der Host hat ein Timeout? Der erste Start lädt Abhängigkeiten herunter und kann die Startprüfung des Hosts überschreiten. Führe uvx --from 'yt-mem-ai[mcp]' yt-ai-mcp --help einmal aus und öffne die App dann erneut. Wenn der Host sie immer noch nicht starten kann, gib absolute Pfade an — uv tool install 'yt-mem-ai[mcp]' und verwende which yt-ai-mcp als command mit "args": [] (GUI-Apps sehen ~/.local/bin oft nicht in ihrem PATH).

3. Claude Desktop — Skills (in der App)

Desktop speichert Plugins auf deinem Claude-Konto, nicht auf der Festplatte, daher kann sie niemand für dich installieren. Es dauert eine Minute in der App:

Customize (linke Seitenleiste) → Plugins → Personal plugins → + → Add marketplace → Add from a repository → https://github.com/dasein108/yt-mem-ai → Add → Install yt-mem-ai

Dann frag: fasse 'https://youtu.be/…' zusammen. Deinstallieren auf demselben Weg. Dasselbe Plugin funktioniert auch auf claude.ai und Cowork. Tools statt Skills bevorzugt? Die MCP-Einrichtung oben funktioniert auch für Desktop — und die kann skriptiert werden.

Jeder Host lädt SKILL.md-Dateien aus einem Verzeichnis im Benutzerbereich: Codex ~/.codex/skills/ (CLI und IDE teilen es, v0.117.0+), Cursor ~/.cursor/skills/, Antigravity ~/.gemini/skills/, OpenClaw ~/.agents/skills/, Hermes ~/.hermes/skills/ (wo sie zu /yt und /yt-agent werden).

# from a checkout
cp -R skills/yt skills/yt-agent ~/.codex/skills/

# without a checkout
for s in yt yt-agent; do
  mkdir -p ~/.codex/skills/$s
  curl -LsSf "https://raw.githubusercontent.com/dasein108/yt-mem-ai/main/skills/$s/SKILL.md" \
    -o ~/.codex/skills/$s/SKILL.md
done

Codex-Extras: die /yt-*-Prompts (integrations/codex/prompts/*.md → ~/.codex/prompts/) und integrations/codex/AGENTS.md → ~/.codex/AGENTS.md. Vollständige Anleitung: skills/README.md.

4. Das CLI für sich allein

Die Skills steuern es, aber es ist ein vollwertiges eigenständiges Tool:

uvx yt-mem-ai --help          # zero-install run
uv tool install yt-mem-ai     # or install the persistent `yt-ai` command

Benötigt Python 3.11+ und uv; ffmpeg nur für supercut / frame.

Die Desktop-Oberfläche lebt in einem separaten Repository: yt-mem-ai-desktop — es hängt von diesem Paket ab und betreibt eine eigene lokale REST-API.

Erste Schritte

Installiert und Host neu gestartet? Du bist bereit. Sprich einfach mit deinem Assistenten — die Skills (oder MCP-Prompts + analyze_video) übernehmen das Ingesting für dich:

„Fasse https://youtu.be/dQw4w9WgXcQ zusammen" → ingestiert das Video (Untertitel → Whisper), schreibt dann eine Management-Zusammenfassung plus Kernpunkte, in der Sprache des Videos.

„Gib mir die Highlights dieses Videos mit Zeitstempeln" → 3–8 Deep-Link-Momente (watch?v=…&t=123s), verankert durch semantische Suche.

„Was habe ich über Retrieval-Augmented Generation gesehen?" → durchsucht jedes Transkript in deiner Bibliothek und zitiert die Momente.

„Verarbeite meine Abonnements zu heutigem Digest" → erkennt neue Uploads, ingestiert sie, schreibt digests/<DATE>.md.

Terminal bevorzugt? Derselbe erste Lauf:

yt-ai fetch 'https://www.youtube.com/watch?v=VIDEO_ID'   # ingest one video
yt-ai search "what was said about embeddings"            # search your library
yt-ai status                                             # what's in the store

Alles landet in ~/.yt-mem-ai/ (Bibliothek, Logs, Downloads).

Der erste Lauf ist langsam — das ist normal. Die Installation zieht den ML-Stack (torch, LanceDB, sentence-transformers ≈ 1 GB auf der Festplatte), und dein erstes fetch oder search lädt das Embedding-Modell obendrein herunter. Wenn ein Video keine Untertitel hat, wird auch das Whisper-Modell (small, ≈ 460 MB) heruntergeladen — der Untertitel-Pfad braucht es nie. Alles wird gecacht, passiert also einmal, nicht pro Video. Auf einem GUI-Host kann der erste MCP-Start aus demselben Grund die Startprüfung der App überschreiten: Führe uvx --from 'yt-mem-ai[mcp]' yt-ai-mcp --help einmal in einem Terminal aus, um den Cache zu wärmen, und öffne die App dann erneut.

Tägliche Routine

yt-ai discover               # what's new in your subscriptions
yt-ai fetch-pending          # transcribe today's batch

dann in deinem Assistenten: „Abonnements verarbeiten" → Zusammenfassungen pro Video und digests/<DATE>.md, und optional yt-ai compile --out compilations/$(date +%F).md für die Highlights des Tages als klickbare Links.

Verwendung

Mit deinem Assistenten sprechen (Skills & Prompts)

Zwei Skills werden mit dem Plugin ausgeliefert. MCP-Hosts erhalten dieselben Playbooks als Prompts (yt_summarize, yt_highlights, yt_qa, yt_presentation, yt_digest, yt_review, yt_group), sodass ohne Skill-Unterstützung nichts verloren geht.

Skills greifen nie direkt auf die Datenbank zu — sie rufen das CLI auf, sodass derselbe Workflow auf jedem Host läuft. Installiere oder füge sie von Hand ein: skills/README.md.

MCP-Tools

Der yt-ai-mcp-Server stellt die gesamte Engine als typisierte Tools bereit. analyze_video ist der Einstiegspunkt in einem Schritt: Es ingestiert und liefert das Transkript zurück, damit das Modell die Zusammenfassung selbst schreiben kann.

Serverdetails, Prompt-Liste und Rohkonfiguration: integrations/mcp/README.md.

CLI-Befehle

yt-ai fetch <url>            # download + transcribe + embed + store one video
yt-ai fetch <url> --captions-only  # captions only: no audio download / no whisper (fails if none)
yt-ai transcript <url>       # same pipeline
yt-ai discover               # new subscription uploads (--after/--deep/--min-duration/--json); incremental by default
yt-ai fetch-pending          # batch-fetch pending 'discovered' videos (since --since, default today; --limit)
yt-ai list                   # list stored videos (--status/--since/--json)
yt-ai show <video_id>        # metadata + transcript (--json)
yt-ai status                 # counts by status
yt-ai search "<query>"       # semantic search (--hybrid/--fts/--vector, -k N)
yt-ai save-summary <id> "<summary>" --highlights '<json>' --qa '<json>'  # persist a summary (used by skills)
yt-ai like <video_id>        # mark liked (feeds recommendations)
yt-ai dislike <video_id>     # mark disliked
yt-ai recommend              # rank your unrated fetched videos by taste (--limit/--json)
yt-ai compile                # deep-linked highlights doc, budget-bounded (--since/--max-minutes/--json/--out)
yt-ai supercut               # video reel of highlights, re-downloaded + labeled (--since/--max-minutes/--out/--keep-clips)
yt-ai frame <video_id> --at <ts>  # still frame at a timestamp (seconds or H:M:S) → frames/<id>_<s>s.png
yt-ai reembed                # re-embed all chunks with the current YT_EMBEDDING_* config
yt-ai channel-list <url>     # list a channel's recent uploads (--limit/--from/--to/--json); enumerate only
yt-ai config list            # get/set any .env setting: config get/set/unset/path (reconfigure from CLI or chat)

Beispiele

Fall: ein vollständiges PDF-Lehrbuch aus einem 10-teiligen YouTube-Kurs. examples/defi-crypto-options.pdf — ein 96-seitiges russisches Lehrbuch, erstellt aus der Serie «DeFi. Бесплатный вводный курс по крипто-опционам» (@Menaskop).

Pipeline: die 10 Serienvideos identifizieren → ru-orig-Untertitel abrufen (yt-dlp + Browser-Cookies; kein Whisper nötig) → strukturierte Zusammenfassungen pro Video → ein gemeinsames Grundgerüst (Glossar, Notation, Abbildungsverzeichnis) → 10 neu geschriebene Kapitel (~28,5k Wörter)

• 47 neu gezeichnete Vektorabbildungen → mit Typst zusammengesetzt und gerendert. Keine Zusammenfassung — Kapitel aus ersten Prinzipien mit durchgerechneten Beispielen, Diagrammen, Glossar und Deep-Links pro Kapitel zurück zu jedem Video.

Konfiguration

Zum Starten ist nichts erforderlich — die Standardwerte legen Speicher, Logs und Downloads unter ~/.yt-mem-ai/ ab und verwenden ein lokales Einbettungsmodell. Passe es an, wenn du es brauchst:

Über die CLI oder einen Agenten konfigurieren — statt .env von Hand zu bearbeiten, yt-ai config verwenden (oder die MCP-config_*-Werkzeuge, damit ein Agent sich selbst aus dem Chat neu konfigurieren kann):

yt-ai config list                  # every setting, value, and source
yt-ai config set WEBSHARE_PROXY_USERNAME <user>
yt-ai config set WEBSHARE_PROXY_PASSWORD <pass>
yt-ai config set YT_EMBEDDING_MODEL paraphrase-multilingual-MiniLM-L12-v2
yt-ai config get OPENAI_API_KEY    # secrets masked (--reveal to show)

set schreibt standardmäßig die globale Konfigurationsdatei (~/.yt-mem-ai/config.env), damit der MCP-Server sie unabhängig von seinem Arbeitsverzeichnis übernimmt; --project schreibt ./.env. Priorität: Prozess-Umgebung > Projekt-.env > globale Konfigurationsdatei, und config list zeigt, woher jeder Wert stammt.

Unter der Haube

Alles unten ist optionale Lektüre — Interna, Feinabstimmung und Entwicklerhinweise.

So funktioniert es

yt-dlp → captions (or Whisper) → chunks → embeddings → LanceDB
                                                          ↓
                     your assistant reads + writes summaries back

Die CLI erledigt die schwere E/A und besitzt den Speicher; die Skills und MCP-Werkzeuge sind dünne Aufrufer. Ein Video durchläuft discovered → downloaded → transcribed → summarized; Live-Streams erhalten einen terminalen stream-Status und werden von der Stapelerfassung übersprungen (einzeln transkribieren mit yt-ai fetch <url>). Der Speicher ist ein eingebettetes LanceDB (videos, channels, transcripts, chunks, summaries, feedback), mit Vektoren pro Chunk plus einem Volltextindex — das macht die Suche hybrid.

Befehlsdetails

Bewerten & empfehlen — Videos, die du abgerufen hast, mit „Gefällt mir“/„Gefällt mir nicht“ bewerten, dann stuft yt-ai recommend den Rest nach Ähnlichkeit zu dem ein, was dir gefallen hat (abzüglich dessen, was dir nicht gefallen hat), anhand der Transkript-Einbettungen. Bevor du etwas bewertet hast, fällt es auf die zuletzt veröffentlichten zurück.

discover ist inkrementell — es ruft die neuesten Feed-Einträge in einem einzigen flachen Aufruf ab (begrenzt durch YT_DISCOVER_FEED_LIMIT), stempelt jeden mit einem ungefähren Zeitstempel und behält nur die, die neuer sind als der Hochwassermarker des letzten Laufs minus einer 1-Stunden-Überlappung (YT_DISCOVER_OVERLAP_S), sodass auf Stunden gerundete Daten nie ein Grenzvideo verpassen. Bereits verarbeitete Videos werden herausgefiltert. --after YYYY-MM-DD überschreibt den Grenzwert.

compile vs. supercut — compile rendert die Highlights des Tages als Markdown-Deep-Links (watch?v=ID&t=<start>s), neuestes Video zuerst und begrenzt durch --max-minutes (Standard 20); es ist sofort fertig und gibt auf stdout aus, außer du übergibst --out. supercut lädt den Abschnitt jedes Highlights in 720p erneut herunter, brennt ein Label darauf ein und verkettet alles zu supercuts/<date>.mp4 plus einer .refs.md-Begleitdatei, die die Quellen auflistet (und alle Clips, die nach einem Fehler übersprungen wurden) — viel langsamer, benötigt Netzwerk + ffmpeg, aber teilbar.

Einbettungen, Proxy und andere Feinabstimmung

Einbettungen: YT_EMBEDDING_BACKEND=local|openai. Lokal verwendet sentence-transformers (YT_EMBEDDING_MODEL, Standard all-MiniLM-L6-v2) — für nicht-englische Bibliotheken paraphrase-multilingual-MiniLM-L12-v2 setzen (384-d, 50+ Sprachen), damit die semantische Suche sprachübergreifend funktioniert. openai verwendet text-embedding-3-small|large (benötigt OPENAI_API_KEY). Nach einem Modellwechsel yt-ai reembed ausführen, um die vorhandene Bibliothek zu migrieren (bettet alle Chunks neu ein; kein erneuter Abruf).

Proxy / VLESS: YT_USE_WEBSHARE ist standardmäßig aus. Wenn du bereits einen systemweiten Proxy/VPN (VLESS/Xray usw.) betreibst, lass es aus — der Datenverkehr läuft durch diesen Tunnel. Den Webshare-Proxy darüberzustapeln bricht den authentifizierten Abonnement-Feed (sein CONNECT-Tunnel gibt 405 zurück). Setze YT_USE_WEBSHARE=true nur, wenn du keinen anderen Proxy hast und YouTube deine rohe IP drosselt. Discover-Feinabstimmung: YT_DISCOVER_FEED_LIMIT (Neueste-N-Begrenzung, Standard 60), YT_DISCOVER_OVERLAP_S (inkrementelle Überlappung, Standard 3600), YT_DISCOVER_TIMEOUT_S.

Aus einem Checkout arbeiten? uv sync --extra dev, dann cp .env.example .env, wenn du die Einstellungen lieber projektspezifisch statt in ~/.yt-mem-ai/config.env halten möchtest.

Als Python-Paket verwenden

yt-mem-ai ist eine normale Bibliothek — die CLI ist eine dünne Typer-Hülle über run_*- Kerne, die du direkt aufrufen kannst. Alles ist lokal: kein Server, kein API-Schlüssel (außer du wählst das openai-Einbettungs-Backend).

pip install yt-mem-ai     # or: uv add yt-mem-ai

from dataclasses import replace
from pathlib import Path

from yt_mem_ai.config import load_config
from yt_mem_ai.cli import open_store, run_fetch, run_search, run_list, run_save_summary
from yt_mem_ai.store import db as store

# Config comes from ~/.yt-mem-ai/config.env < ./.env < process env.
# Override any field in code (Config is a frozen dataclass):
cfg = replace(load_config(), store_path=Path("~/.yt-mem-ai/lance").expanduser())

db = open_store(cfg)          # opens LanceDB + creates tables/indexes once
                              # pass db=... to every run_* call to reuse it

# 1. Ingest: download → transcribe (captions → whisper) → chunk → embed → store
video_id = run_fetch("https://www.youtube.com/watch?v=dQw4w9WgXcQ", cfg, db=db)
# captions only (no audio download, no whisper):
# video_id = run_fetch(url, cfg, db=db, captions_only=True)

# 2. Read what was stored
video = store.get_video(db, video_id)
text = store.get_transcript_text(db, video_id)
print(video.title, video.channel, video.duration_s, len(text or ""))

for c in store.list_chunks(db, video_id)[:3]:
    print(f"[{c['start_s']:.0f}s] {c['text'][:80]}")

# 3. Semantic search across the whole library (hybrid | vector | fts)
for hit in run_search(cfg, "retrieval augmented generation", mode="hybrid", k=5, db=db):
    print(hit["video_id"], hit["start_s"], hit["text"][:100])

# 4. Bring your own LLM: summarize the transcript however you like, then persist
summary_md = my_llm(text)                       # any model / provider
run_save_summary(
    cfg, video_id, summary_md,
    highlights_json='[{"t": 42, "text": "key moment"}]',
    qa_json='[{"q": "What is it about?", "a": "..."}]',
    db=db,
)
print(store.get_summary(db, video_id))

# 5. Library queries
for v in run_list(cfg, status="transcribed", since="2026-01-01", db=db):
    print(v.video_id, v.published_at, v.title)

Andere Kerne, gleiche Form (run_x(cfg, ..., db=db)): run_discover, run_fetch_pending, run_channel_list, run_recommend, run_feedback, run_compile, run_supercut, run_frame, run_reembed. Auch niedrigere Ebenen sind importierbar — yt_mem_ai.download.download, yt_mem_ai.transcript.get_transcript, yt_mem_ai.store.embeddings.build_embedder / chunk_segments, yt_mem_ai.store.db (LanceDB-CRUD + search_chunks).

Der Speicher ist schlichtes LanceDB, du kannst ihn also auch direkt öffnen:

import lancedb
from pathlib import Path
tbl = lancedb.connect(Path("~/.yt-mem-ai/lance").expanduser()).open_table("chunks")
df = tbl.to_pandas()      # video_id, start_s, end_s, text, vector

Protokollierung

Die CLI schreibt strukturierte JSON-Ereignisse in logs/common.jsonl (über obs.log_event/blog) — ein Objekt pro Zeile, {ts, source, level, event, msg, ...ctx}. Pfad mit YT_LOG_FILE überschreiben; es ist gitignored. Mit jq untersuchen:

jq -c 'select(.level=="error")' logs/common.jsonl   # every error
tail -f logs/common.jsonl | jq -c '{ts,event,msg}'  # live tail, compact

Tests

uv run pytest -q                       # offline unit tests (fake embedder)
YT_RUN_INTEGRATION=1 uv run pytest -q  # + real sentence-transformers integration

Veröffentlichen (Maintainer)

Die Version stammt aus dem Git-Tag (hatch-vcs). Taggen, bauen und veröffentlichen:

git tag -a vX.Y.Z -m "vX.Y.Z" && git push origin vX.Y.Z
uv build                                # → dist/ (sdist + wheel)
sh scripts/publish.sh dist/yt_mem_ai-X.Y.Z*   # uploads to PyPI

scripts/publish.sh lädt UV_PUBLISH_TOKEN bei Bedarf aus .env (gitignored), damit du es nicht jedes Mal exportieren musst — füge UV_PUBLISH_TOKEN=pypi-… einmal zu .env hinzu (siehe .env.example). Äquivalent: set -a; . ./.env; set +a; uv publish dist/*. Rotiere das Token auf PyPI, falls es jemals offengelegt wird.