Yomi (読み) — der persönliche LINE-MCP-Server

Yomi ist ein Open-Source-LINE-MCP-Server für dein persönliches Konto. Lies, antworte, sende Bilder und durchsuche jede Unterhaltung von Claude oder einem beliebigen lokalen KI-Agenten — ohne Browser, Bot-Konto oder LINE-eigenen Client.

Der Name lässt sich auf mehr als eine Weise lesen. 読み (yomi) — eine Lesart: nicht nur das Parsen deiner Nachrichten, sondern das Lesen der Situation, so wie du es tust. 詠み (yomi) — rezitieren: es liest nicht still, es liest dir Dinge vor. Und 黄泉 (yomi) — das unerreichbare Reich; genau das yomi in 黄泉帰り (yomigaeri), „Rückkehr aus Yomi." Wie ein Bote, der zwischen zwei Reichen wandert, durchdringt Yomi Versiegelung und Stille, um Nachrichten, die tief in deinen Unterhaltungen noch lesbar sind, wieder ans Licht zu bringen. Es beschwört keine bereits verlorene Geschichte herauf; es hilft, dass das, was nicht verschwunden ist, wieder gesehen wird.

Im Gegensatz zum offiziellen LINE-Bot-MCP-Server, der KI-Agenten über die Messaging-API mit einem LINE-Official-Account verbindet, verbindet sich Yomi als sekundäres Gerät mit deinem bestehenden persönlichen LINE-Konto und deinen Unterhaltungen.

Yomi spricht direkt LINEs TCompact-über-HTTPS-Protokoll, entschlüsselt Letter-Sealing (E2EE)-Nachrichten und -Medien und stellt das Ergebnis jedem KI-Agenten über einen kleinen stdio-MCP-Server zur Verfügung. Richte Claude Desktop (oder einen beliebigen MCP-Client) darauf aus, und der Agent kann dein LINE so nachvollziehen, wie du es tust — lesen, antworten, ein Bild senden, jemanden erwähnen und deine gesamte Historie lokal durchsuchen — und mit get_insight die Situation lesen: welche Unterhaltungen auf deine Antwort warten, wer deine Welt zusammenhält und was überfällig ist.

Keine offizielle API, kein Bot-Konto, kein Webhook. Yomi meldet sich als sekundäres Gerät auf deinem eigenen Konto an.

Anleitungen: Was ist ein LINE-MCP-Server? · LINE MCP 是什麼？Yomi、官方 Bot 與桌面自動化的差異.

Inoffiziell. Yomi ist ein unabhängiges persönliches Projekt, das weder mit LINE verbunden ist noch von LINE unterstützt wird. Die Nutzung kann gegen die Nutzungsbedingungen von LINE verstoßen, und das Ausführen eines zusätzlichen Clients auf deinem Konto birgt das Risiko von Rate-Limiting oder Sperrung. Es ist für das Lesen deines eigenen Kontos gedacht. Nutzung auf eigenes Risiko. Siehe Haftungsausschluss.

Erste Schritte

Native-Desktop-Vorschau

Yomi Desktop bringt den LINE-Posteingang und den lokalen Agenten-Arbeitsbereich in einer nativen App zusammen. Es enthält eine eigene Laufzeit: Benutzer müssen Node nicht installieren, kein Terminal öffnen, dieses Repository nicht klonen oder YOMI_RUN_MJS konfigurieren. Native Desktop ist getrennt von der unten beschriebenen Claude-Desktop-MCPB-Erweiterung.

Das macOS-Paket wurde über den echten Download-Pfad getestet: quarantäniertes DMG, Installation in /Applications, Gatekeeper-Prüfung, erster Start, Nachrichtenaktualisierung mit gebündelter Laufzeit und LINE-Anmeldeformular ohne Terminal. Der Windows-Installer enthält den entsprechenden In-App-Telefon-/PIN- Anmeldeablauf und wird vor der Veröffentlichung auf einem nativen Windows-Runner getestet.

Desktop-Builds sind experimentell und inoffiziell. LINE-Änderungen können sie beschädigen, und das Ausführen eines zusätzlichen Clients kann ein Konto gefährden. Bevorzuge ein Testkonto und halte ein aktuelles Backup bereit. Vorschau-Installer werden nur als GitHub-Pre-Releases veröffentlicht, nachdem die Plattformsignierung verfügbar ist.

Siehe den Desktop-Release-Prozess, Code-Signierungsrichtlinie und Datenschutzrichtlinie.

MCP-Server und Desktop-Erweiterung

Du benötigst Node.js und ein LINE-Konto. Yomi läuft lokal über npx; du musst dieses Repository nicht klonen, Bun installieren oder etwas bauen. Führe zuerst node --version aus und installiere das aktuelle LTS, wenn der Befehl fehlt oder die Version nicht unterstützt wird.

Yomis lokaler Suchindex verwendet das in Node integrierte node:sqlite, daher benötigt es v22.13 oder neuer — außer v23.0–v23.3, die neuer als v22.13 sind, aber dieses Modul noch nicht enthalten (es wurde in 22.13.0 und 23.4.0 entflaggt). Jedes aktuelle LTS ist in Ordnung. Dies ist engines.node in package.json; der Rest von Yomi läuft auf älterem Node, aber Suche, Scope und Capture nicht.

⚠️ Yomi benötigt einen Client, der es auf deinem eigenen Rechner ausführt. Nur-Cloud-Tools (ChatGPT, Claude.ai-Web) können Yomi nicht ausführen. Konfiguriere Yomi in Claude Desktop oder Claude Code, und es funktioniert sowohl im Chat als auch in Cowork, weil Desktop Yomi auf deinem Rechner startet und Coworks lokale Sitzungen es laden. Bitte Cowork nicht, Yomi für dich zu installieren: Coworks Shell läuft in einer Wegwerf-VM, nicht auf deinem Rechner, also ist alles, was es dort installiert, verschwunden, wenn die Sitzung endet. Folge den Schritten unten selbst, in deinem eigenen Terminal.

Wähle den Client, den du tatsächlich verwendest, und folge nur diesem Abschnitt. Claude Code und Claude Desktop haben separate MCP-Einstellungen; das Konfigurieren des einen konfiguriert nicht das andere.

Der einfachste Weg und der einzige, der überhaupt keine Befehlszeile benötigt. Claude Desktop bringt eine eigene Node-Laufzeit mit, also muss nichts anderes installiert werden.

1. Lade das Bundle für deinen Rechner vom neuesten Release herunter:

   Rechner	Datei
   Windows (Intel/AMD)	yomi-win32-x64.mcpb
   Mac (Apple Silicon)	yomi-darwin-arm64.mcpb
   Linux (x64)	yomi-linux-x64.mcpb

2. Öffne in Claude Desktop Einstellungen → Erweiterungen und ziehe die heruntergeladene Datei auf diese Seite (oder doppelklicke einfach auf die Datei).

3. Überprüfe, was verlangt wird, und klicke auf Installieren.

4. Starte eine Unterhaltung und sage "bei LINE anmelden". Yomi zeigt ein Formular, du gibst deine Telefonnummer ein und bestätigst auf deinem Telefon. Kein Terminal zu irgendeinem Zeitpunkt.

Dies überspringt die Konfigurationsdatei vollständig, was auch den unten beschriebenen Windows-MSIX-Fehler umgeht.

Hinweis für Cowork-Benutzer: Bitte Cowork nicht, Yomi für dich zu installieren. Coworks Shell läuft in einer Wegwerf-VM — nicht auf deinem Rechner — und es wird nicht in dein echtes Terminal tippen. Installiere das Bundle selbst mit den drei Klicks oben; sobald es installiert ist, können Coworks lokale Sitzungen Yomi wie jedes andere Tool verwenden.

1. Finde den vollständigen Pfad zu npx:

   macOS / Linux: which npx
   Windows:       where npx

2. Öffne die Claude-Desktop-Konfigurationsdatei:

   macOS:   ~/Library/Application Support/Claude/claude_desktop_config.json
   Windows: %APPDATA%\Claude\claude_desktop_config.json

   ⚠️ Windows: Der dokumentierte Pfad ist möglicherweise nicht der, den Claude tatsächlich liest. Claude Desktop wird als MSIX-Paket ausgeliefert, dessen Dateisystem virtualisiert ist. Die App liest ihre Konfiguration von

   %LOCALAPPDATA%\Packages\Claude_pzs8sxrjxfjjc\LocalCache\Roaming\Claude\claude_desktop_config.json

   während Einstellungen → Entwickler → Konfiguration bearbeiten die unvirtualisierte %APPDATA%\Claude\-Datei öffnet. Es sind zwei verschiedene Dateien, die nie synchronisiert werden, also wird eine korrekte Yomi-Konfiguration, die in den dokumentierten Pfad geschrieben wird, still ignoriert — kein Fehler, kein Log, Yomi erscheint einfach nie. Dies ist claude-code#26073, noch offen. Wenn Yomi nach einem Neustart nicht erscheint, schreibe dieselbe Konfiguration auch in den LocalCache-Pfad oben. (Nicht anwendbar auf Claude Code oder auf Desktop, das außerhalb von MSIX installiert ist.)

3. Füge Yomi unter mcpServers hinzu und ersetze den Beispiel-command durch den vollständigen Pfad aus Schritt 1. Unter Windows erfordert JSON, dass jedes \ im Pfad als \\ geschrieben wird:

{
  "mcpServers": {
    "yomi": {
      "command": "/opt/homebrew/bin/npx",
      "args": ["@rikaidev/yomi"]
    }
  }
}

Zum Beispiel kann ein Windows-Pfad wie "C:\\Program Files\\nodejs\\npx.cmd" aussehen. Verwende den Pfad, der auf deinem eigenen Rechner gemeldet wird, anstatt eines der Beispiele blind zu kopieren.

⚠️ Das npx, das du hier angibst, entscheidet nicht, welches Node Yomi ausführt. Auf macOS und Linux ist npx ein Skript, das mit #!/usr/bin/env node beginnt, also führt es das node aus, das zuerst auf Claude Desktops PATH kommt — nicht das Node, das neben dem npx installiert ist, auf das du gerade gezeigt hast. Desktop erbt seinen PATH von der Desktop-Sitzung, die oft nicht die deines Terminals ist, und Versionsmanager (nvm, fnm, asdf, volta, …) stellen ihr eigenes node vor alles andere. Also kann which npx eine perfekt moderne Installation melden, während Yomi trotzdem auf einem alten Node startet.

Das Symptom ist spezifisch: Anmelden, Lesen und Senden funktionieren alle, aber Suche, Scope und Capture schlagen fehl, und das Log sagt No such built-in module: node:sqlite. Yomi druckt die Laufzeit, die es tatsächlich erhalten hat, in diesem Fehler — lies es, anstatt anzunehmen.

Die Lösung besteht darin, dem Server einen PATH zu geben, dessen erster Eintrag ein unterstütztes node enthält:

"yomi": {
  "command": "<the npx path from step 1>",
  "args": ["-y", "@rikaidev/yomi"],
  "env": { "PATH": "<dir holding a supported node><sep><a base PATH>" }
}

Trennzeichen: : auf macOS/Linux, ; auf Windows. Behalte eine nutzbare Basis danach (/usr/local/bin:/usr/bin:/bin oder das Äquivalent deiner Plattform) — dies ersetzt den PATH des Servers, anstatt ihm voranzustellen, und npx benötigt die gewöhnlichen Werkzeuge.

Die Angabe eines absoluten node in command funktioniert nicht, so plausibel es auch aussieht: npx startet das eigene Bin des Pakets als Kindprozess und löst node erneut aus PATH dafür auf, also wählt command nur aus, wer npx ausführt, nicht wer Yomi ausführt. Das Setzen von PATH ist das, was tatsächlich den Server erreicht.

Konfigurierst du das mit einem KI-Agenten? MCP-Konfigurationen werden heutzutage meist von Agenten geschrieben statt von Hand, also sind die obigen Schritte für einen Menschen formuliert, der seinen eigenen Rechner liest. Ein Agent sollte die Werte auflösen, anstatt Platzhalter auszugeben, und dieses Setup hat eine Falle, die es wert ist, klar ausgesprochen zu werden: Das Benennen von npx in command pinnt die Laufzeit nicht. Vorgehen:

1. Finden Sie eine Node, die tatsächlich das Modul hat, das Yomis Index benötigt – leiten Sie es nicht aus einer Versionsnummer ab:

   node -e 'require("node:sqlite")' && command -v node    # POSIX
   node -e "require('node:sqlite')" && where node         # Windows

   Wenn es einen Fehler wirft, ist diese Node für Suche/Scope/Capture unbrauchbar. Probieren Sie die anderen Installationen (which -a node, nvm ls, fnm list, …) aus, bis eine funktioniert; erst dann fahren Sie fort.

2. Schreiben Sie das Verzeichnis dieser Node in env.PATH, gemäß dem obigen JSON, und behalten Sie danach ein Basis-PATH bei. Ermitteln Sie das Verzeichnis auf dem Zielrechner (dirname des Pfads aus Schritt 1); kopieren Sie kein Beispiel aus dieser README – es sind Apple-Silicon-Homebrew-Pfade und fast überall falsch.

   Setzen Sie stattdessen nicht ein absolutes node in command. Es liest sich wie die stärkere Lösung und ist es nicht: npx startet das Binärskript des Pakets als Kindprozess und löst node für dieses erneut aus PATH auf, sodass command nur entscheidet, wer npx ausführt. Das wurde gemessen, nicht angenommen – mit einem Node 20 zuerst in PATH ergab das Pinnen von command dem Server trotzdem Node 20.

   command -v kann auch einen Wrapper statt einer echten Binärdatei zurückgeben – Heap-Shims, lokale npx-Wrapper und Versionsmanager-Stubs sind alle üblich, und einige verhalten sich je nach Arbeitsverzeichnis des Clients unterschiedlich. Versuchen Sie nicht, sich zum „echten" durchzudenken. Schritt 3 klärt das.

3. Verifizieren Sie mit einem Tool, das den Index berührt. yomi version ist keine Verifizierung – es gibt eine Zeichenkette aus, ohne SQLite zu öffnen, und funktioniert daher auf einer Node, die keine Suche ausführen kann. Rufen Sie get_scope_policy auf: Es benötigt SQLite und keinen LINE-Login. Wenn es den Richtlinientext zurückgibt, ist die Laufzeit korrekt. Wenn es fehlschlägt, nennt der Fehler die Node, die tatsächlich ausgeführt wurde, und was sie benötigte.

4. Beenden Sie Claude Desktop vollständig und öffnen Sie es erneut. Bestätigen Sie, dass Yomi unter Einstellungen → Entwickler geladen ist, bevor Sie etwas anderes tun: Wenn Yomi dort nicht aufgeführt ist, hat Claude Ihre Konfiguration nie gelesen – unter Windows siehe die MSIX-Warnung in Schritt 2. Sobald es aufgeführt ist, sind die Tools sowohl im Chat als auch in Coworks lokalen Sitzungen verfügbar.

Sie müssen für dieses Setup nicht Claude Code installieren.

claude mcp add yomi -- npx @rikaidev/yomi

Starten Sie eine neue claude-Sitzung. Die Yomi-Tools sollten automatisch erscheinen. Dieser Befehl konfiguriert nur Claude Code; er konfiguriert nicht Claude Desktop.

Diese Form überlässt die Laufzeit PATH, was in Ordnung ist, solange das node, das Ihre claude-Sitzung auflöst, eine unterstützte Version ist – es ist derselbe PATH, den Sie sehen können, anders als bei Claude Desktop. Überprüfen Sie mit node -e 'require("node:sqlite")'. Wenn es einen Fehler wirft oder Sie überhaupt nicht von PATH abhängig sein möchten, benennen Sie die Node explizit:

claude mcp add yomi -e PATH="$(dirname "$(command -v node)"):$PATH" -- npx -y @rikaidev/yomi

Verifizieren Sie in jedem Fall mit get_scope_policy statt mit yomi version: Der Versionsbefehl gibt eine Zeichenkette aus, ohne SQLite zu öffnen, und besteht daher auf einer Node, die keine Suche ausführen kann.

Führen Sie Claude Code in einem Klon dieses Repos aus? Geben Sie die Spec als @rikaidev/yomi@latest an. Ohne Tag sucht npx zuerst nach einem lokalen Binärskript, und in diesem Repo deklariert package.json "bin": {"yomi": ...}, während nichts es in node_modules/.bin verlinkt – also überspringt npx die Installation und endet mit sh: yomi: command not found. Ein explizites Tag bewirkt, dass das veröffentlichte Paket abgerufen wird. Betrifft nur Arbeitskopien von Yomi selbst; überall sonst ist die Form ohne Tag in Ordnung.

Diese Standardkonfiguration funktioniert in den meisten MCP-Clients:

{
  "mcpServers": {
    "yomi": {
      "command": "npx",
      "args": ["@rikaidev/yomi"]
    }
  }
}

Cursor Settings → MCP → Add new MCP Server → benennen Sie es yomi, Befehlstyp, Wert: npx @rikaidev/yomi

Oder fügen Sie es zu .cursor/mcp.json in Ihrem Projektstamm hinzu.

Fügen Sie zu .vscode/mcp.json hinzu:

{
  "servers": {
    "yomi": {
      "command": "npx",
      "args": ["@rikaidev/yomi"]
    }
  }
}

Fügen Sie zu ~/.config/opencode/opencode.json hinzu:

{
  "mcp": {
    "yomi": {
      "type": "local",
      "command": ["npx", "@rikaidev/yomi"],
      "enabled": true
    }
  }
}

codex mcp add yomi npx @rikaidev/yomi

Oder fügen Sie zu ~/.codex/config.toml hinzu:

[mcp_servers.yomi]
command = "npx"
args = ["@rikaidev/yomi"]

Fügen Sie zu cline_mcp_settings.json hinzu:

{
  "mcpServers": {
    "yomi": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@rikaidev/yomi"]
    }
  }
}

Fügen Sie zu ~/.codeium/windsurf/mcp_config.json hinzu — dieselbe JSON wie die Standardkonfiguration.

amp mcp add yomi -- npx @rikaidev/yomi

Advanced settings → Extensions → Add custom extension → benennen Sie yomi, Typ STDIO, Befehl: npx @rikaidev/yomi

grok mcp add yomi -- npx @rikaidev/yomi

Erste Anmeldung

Sobald die Verbindung hergestellt ist, sagen Sie dem Agenten:

„Loggen Sie sich bei LINE ein – meine Nummer ist +8869XXXXXXXX."

Bestätigen Sie das Gerät auf Ihrem Telefon (siehe Anmelden), und:

„Fassen Sie meine ungelesenen LINE-Nachrichten zusammen und sagen Sie mir, wer auf eine Antwort wartet."

Related MCP server: line-desktop-mcp

Was Sie tun können

Yomi stellt 20 Tools über MCP bereit (die, die es wert sind, genannt zu werden; siehe die Tabellen). Große Leseergebnisse verwenden token-effizientes TOON; kleine Status- und Schreibergebnisse verwenden kompaktes JSON. Fehler bleiben Klartext und Medien verwenden native MCP-Bild-/Audio-/Ressourceninhalte. „Ehrlicher Fehler" unten bedeutet einen expliziten Fehlschlag, der das Problem benennt (z. B. missing_decrypt_material) – Yomi erfindet nie einen Fallback, einen Platzhalter oder einen vorgetäuschten Erfolg.

Lesen

Einblick (die Situation lesen, nicht nur die Nachrichten)

Schreiben (diese senden wirklich – keine Entwürfe)

Suche (lokal, konversationsübergreifend – LINE hat keine solche Grundoperation)

Umfang & Datenschutz (alles funktioniert offline, keine LINE-Sitzung erforderlich)

Sitzung

Anmelden

Voraussetzung: Aktivieren Sie auf Ihrem Haupttelefon 設定 › 我的帳號 › 允許自其他裝置登入 (Einstellungen › Konto › Anmeldung auf anderen Geräten erlauben). Ohne diese Einstellung bietet LINE diesem Gerät niemals eine Anmeldeaufforderung an — dies ist der mit Abstand häufigste Grund, warum eine erste Anmeldung zu hängen scheint.

⚠️ Limit von einer Desktop-Sitzung: LINE erlaubt nur eine Desktop-Client-Sitzung gleichzeitig pro Konto. Da Yomi sich als Desktop-Zweitgerät (DESKTOPMAC) verbindet, wird durch die Anmeldung bei Yomi Ihre offizielle LINE-Desktop-App abgemeldet (und die erneute Anmeldung bei LINE Desktop macht Yomis Sitzung ungültig). Sie können Yomi und den offiziellen LINE-Desktop-Client nicht gleichzeitig verwenden.

Sie müssen dem Agenten lediglich Ihre Telefonnummer im E.164-Format geben — er liefert die Region selbst (z. B. TW für eine +886-Nummer), wenn er das Tool aufruft.

Yomi steuert den passwortlosen (Zweitgerät-) Ablauf von LINE. Wie die Anmeldung erscheint, hängt von Ihrem MCP-Client ab:

• Clients mit der MCP-elicitation-Fähigkeit — login fragt Sie nach Ihrer Telefonnummer/Region, zeigt die PIN in einem Dialog an und blockiert bis zum Abschluss. Ein Aufruf, keine PIN, die durch das Modell geleitet wird. Ihre Telefonnummer gelangt nie ins Transkript.

• Clients ohne diese Fähigkeit (z. B. Claude Desktop heute) — zwei Aufrufe. login (mit Ihrer Telefonnummer + Region) gibt die PIN in seinem Ergebnis zurück; geben Sie sie in LINE auf Ihrem Haupttelefon ein und genehmigen Sie das Gerät; rufen Sie dann login_complete auf, das blockiert, bis das Telefon bestätigt. Der Agent sollte login_complete sofort aufrufen — es übernimmt das Warten, sodass es für Sie nichts zurückzumelden gibt.

• Vom Terminal aus — npx @rikaidev/yomi login führt den gesamten Ablauf auf stdout aus, PIN und alles. Immer als Fallback verfügbar.

Die einzige Frist, die zählt, ist die von LINE: Sie haben etwa 3 Minuten ab dem Zeitpunkt, an dem die PIN angezeigt wird, um sie einzugeben und das Gerät zu genehmigen. Yomis eigener Client hört noch viele Minuten darüber hinaus zu, sodass ein langsames Telefon nie der Fehler ist — nur LINEs 3-minütige Code-Lebensdauer ist es.

Sobald Sie angemeldet sind, wird die Sitzung — einschließlich eines Anmelde-Zertifikats — gespeichert (siehe unten), und zukünftige Anmeldungen überspringen die PIN vollständig.

Es gibt auch eine experimentelle MCP Apps-Oberfläche (eine ui://yomi/login-Karte) für Clients, die interaktive Ansichten rendern. Sie ist spezifikationskonform und rendert unter dem MCP Inspector, aber einige Hosts rufen die Ressource ab, ohne den Ansichts-Handshake abzuschließen, sodass sie nur zur Anzeige dient und nie auf dem kritischen Pfad liegt — die obigen Abläufe funktionieren immer, unabhängig davon.

Sitzungen und Anmeldedaten

Yomi besitzt seinen eigenen Login. Beim Start ruft es einmal resumeSession() auf, liest die LINE-Sitzung aus dem macOS-Schlüsselbund (Dienst dev.rikai.yomi.credentials, Konto line) und aktualisiert das Token bei Bedarf stillschweigend.

• First-Party-Anmeldedaten. Der passwortlose Login speichert das Auth-Token, Refresh-Token, Zertifikat, die MID und das E2EE-Schlüsselpaar selbst — und liest sie dann zurück, um zu verifizieren, dass der Schreibvorgang tatsächlich angekommen ist. Ein Login, der nicht gespeichert werden kann, schlägt laut beim Login fehl, nicht stillschweigend beim nächsten Neustart.

• Gemeinsame Sitzung. Die Sitzung wird im kanonischen dev.rikai.yomi.credentials- Schlüsselbund-Eintrag (oder im lokalen Anmeldedatenspeicher) gespeichert, sodass Yomi MCP und Yomi Desktop exakt dieselbe LINE-Anmeldesitzung nahtlos teilen können.

• Plattformhinweis. Auf macOS befindet sich die Sitzung im Anmelde-Schlüsselbund. Auf Linux und Windows fällt Yomi derzeit auf eine lokale JSON-Datei zurück — funktional, aber weniger geschützt als ein OS-Geheimnisspeicher und weniger getestet als der macOS-Pfad. Native sichere Speicher-Backends (libsecret / DPAPI) sind geplant; behandeln Sie eine Nicht-macOS-Installation bis dahin entsprechend.

Jedes Tool außer login und den Offline-Umfang/Such-Tools gibt einen ehrlichen Fehler zurück, wenn keine Sitzung vorhanden ist. Yomi ist ansonsten ein reiner Abfrageserver — es pollt nie, füllt nie im Hintergrund nach; jeder Tool-Aufruf macht genau die LINE-Anfragen, die er benötigt, und collect_messages ist der einzige Pfad, der über viele Chats hinweg gleichzeitig abruft.

Suche

LINE hat keine unterhaltungsübergreifende Suche; Yomi baut eine lokal auf. Der Index ist eine gitignorierte SQLite-Datenbank (data/search-index.db) im Repository — nichts verlässt Ihren Rechner.

Die Suche ist hybrid konzipiert. Sie führt immer FTS5-Keyword-Suche aus (bm25 über bigramm-vorverarbeiteten Text, sodass CJK-Teilstrings ohne Wortgrenzen abgedeckt sind) und, wenn Einbettungen vorhanden sind, semantische Suche, und fusioniert dann die beiden Ranglisten per Reciprocal Rank Fusion. Reine semantische Suche lässt exakte Treffer, die in nicht eingebetteten Nachrichten liegen, stillschweigend weg; reine Keyword-Suche verfehlt Paraphrasen; die Fusion beider bringt einen exakten Begriff und eine Bedeutungstreffer zusammen. Das mode-Feld der Antwort meldet immer, welche Methoden beigetragen haben.

Die semantische Rangfolge behält jede Nachricht als eigenen Vektor. Tests mit real indizierten LINE-Unterhaltungen ergaben, dass das Einbetten überlappender Unterhaltungsfenster die mittlere Nachricht verwässerte und die Abrufqualität verringerte. Kontext wird daher erst nach der Rangfolge hinzugefügt: Yomi begrenzt, dass ein Chat die obersten Ergebnisse überflutet, und erweitert jeden Gewinner um zwei Nachrichten auf jeder Seite, sodass der Agent den Austausch sieht, der dem Treffer Bedeutung verlieh, ohne die Einbettung selbst zu schwächen.

Die semantische Rangfolge verwendet Xenova/bge-small-zh-v1.5 (BAAI-Allzweck-Einbettung, klein, chinesisch-primär, aber mehrsprachig) über transformers.js. Die Einbettungs-Inferenz läuft vollständig prozessintern auf der CPU — Ihr Nachrichtentext wird niemals irgendwohin gesendet.

Der einzige Vorbehalt ist ein einmaliger Modell-Download: Beim ersten collect_messages oder search_messages ruft transformers.js das Modell (~90 MB) von huggingface.co ab und speichert es lokal zwischen; jeder weitere Lauf danach ist vollständig offline. Dieser erste Abruf ist eine ausgehende HTTPS-Anfrage an HuggingFace für die Modellgewichte — sie überträgt Ihre IP und welches Modell heruntergeladen wird, aber keinen Nachrichteninhalt und keine LINE-Daten. Wenn Sie Yomi vollständig netzwerkisoliert benötigen, befüllen Sie den transformers.js-Cache (oder richten Sie ihn auf ein lokales Modellverzeichnis aus) vor der ersten Suche, sodass niemals ein Netzwerkaufruf erfolgt.

Die Zweitgeräte-Realität (lesen, bevor Sie „Ich kann keine alten Nachrichten abrufen" glauben)

Yomi läuft als Zweitgerät auf Ihrem Konto. Das bestimmt, was es sehen kann:

• Gruppenchats ohne Letter Sealing sind auf dem LINE-Server im Klartext — vollständiger Verlauf und Medien, ohne Einschränkung.

• Gruppenchats mit Letter Sealing sind E2EE-verschlüsselt, und dort kommt es auf die Epoche an. Eine solche Gruppe ist mit einem gemeinsamen Gruppenschlüssel verschlüsselt, der rotiert (bei Mitgliedschaftsänderungen oder wenn ein Client einen neuen bereitstellt). LINE gibt einem Gerät nur den aktuellen Gruppenschlüssel — es gibt keine API, um einen ersetzten abzurufen. Ein Zweitgerät entschlüsselt also Nachrichten ab der Epoche, deren Schlüssel es besitzt; Nachrichten, die unter einer älteren Epoche — bevor Yomi den aktuellen Schlüssel erhalten hat — gesendet wurden, können unentschlüsselbar zurückkommen, selbst in einer Gruppe, deren früheren Verlauf es lesen kann. Das ist der per-Epoche-Gruppenschlüssel von Letter Sealing inhärent, kein Fehler hier. Es kann auch quer schneiden: Die Epoche, die Ihr Telefon besitzt, und die Epoche, die Yomi besitzt, müssen nicht dieselbe sein, sodass die beiden Geräte jeweils einen anderen Ausschnitt derselben Gruppe lesen können.

• Die Installation von Yomi rotiert selbst nichts, also ist „bevor ich Yomi installiert habe" die falsche Grenze. Yomi löst nur einen vorhandenen Gruppenschlüssel auf; es registriert (erzeugt) nie einen, weil das Erzeugen das gemeinsame Geheimnis der Gruppe für jedes Mitglied rotiert und jede Nachricht, die unter dem vorherigen verschlüsselt ist, stranden lässt. Eine frische Installation übernimmt also den aktuellen Schlüssel und liest bis zur letzten Rotation zurück — die Monate vor der Installation liegen kann. Die Grenze ist die letzte Neuverschlüsselung, nicht Ihr Installationsdatum. Und sobald Yomi eine Epoche gesehen hat, behält es diesen Schlüssel, sodass eine Rotation nach der Installation es in die Lage versetzt, beide Seiten zu lesen. Wenn eine Gruppe bis heute durchgehend unentschlüsselbar zurückkommt, ist das nicht diese Einschränkung — bitte melden Sie es.

• 1:1-Medien verwenden den E2EE-Schlüsselbund auf Kontobene, den ein Zweitgerät vollständig besitzt (LINE synchronisiert ihn während der Kopplung) — Yomi kann 1:1-Bilder/Dateien entschlüsseln, die es sehen kann.

• Das 1:1-Verlaufs-Backfill ist die eine echte Einschränkung. LINE übergibt einem Zweitgerät nicht den vergangenen 1:1-Nachrichtenverlauf, wie es das für Gruppen tut. Nachrichten, die empfangen werden, während Yomi verbunden ist, entschlüsseln normal; tiefes Scrollen in den 1:1-Verlauf, der vor der Kopplung liegt, kann leer zurückkommen. Das ist eine serverseitige Einschränkung von LINE, kein Fehler hier.

Wenn die Entschlüsselung tatsächlich fehlschlägt, gibt Yomi einen expliziten missing_decrypt_material- Fehler zurück — niemals eine gefälschte Karte oder einen Platzhalter. Stille ist ehrlich; ein fabrizierter Treffer ist es nicht.

Entwicklung

Für Mitwirkende, die am Yomi-Quellcode arbeiten (erfordert bun oder Node.js 24+ — .nvmrc pinnt dieselbe 24, die CI installiert, sodass nvm use in diesem Verzeichnis sie aufnimmt; beachten Sie, dass nvm engines nicht liest, weshalb die beiden getrennt angegeben und durch einen Test abgesichert sind):

bun install                 # install dependencies (or npm install)
bun run.mjs                 # run the stdio MCP server
bun run.mjs login           # run the login flow in a terminal
npm run build               # tsc --noEmit — type-check only (Yomi ships & runs from src/)
npm test                    # bun test

Der Build führt nur Typprüfung und Kompilierung durch; dieses Repository spricht nicht mit Live-LINE- Servern als Teil seines eigenen Builds. Das Verbinden eines MCP-Clients und das Aufrufen von login ist das, was tatsächlich eine Sitzung startet.

src/
  line/     LINE protocol core: TCompact/Thrift codec, E2EE (Letter-Sealing,
            group keys, media), Talk/Auth/Sync service clients, session state,
            passwordless login flow.
  auth/     Credential store (macOS Keychain, JSON-file fallback off-darwin).
  search/   Local cross-conversation index (SQLite + FTS5) and the offline
            embedding pipeline (transformers.js).
  mcp/      The stdio server: tool schemas, handlers, the privacy-policy loader,
            and the experimental MCP Apps login view (mcp/ui/).
  util/     [TAG]-prefixed logger (stderr only — stdout is the MCP JSON-RPC stream).

Alles, was Yomi für Menschen schreibt, geht an stderr; stdout ist für den MCP-JSON-RPC-Stream reserviert. Ein versehentliches console.log beschädigt das Protokoll — fügen Sie keins auf einem Pfad hinzu, den der Server erreichen kann.

Datenschutz

Standardmäßig indexiert Yomi alle deine Unterhaltungen in den lokalen, auf dem Gerät befindlichen Suchindex, damit ein Agent darin suchen kann – ein Alles-erfassen-Standard, pro Chat abwählbar. Es wird nie etwas hochgeladen; die einzigen Daten, die dein Gerät verlassen, sind das, was der Agent selbst in seinen Antworten preisgibt. (Der einzige Nicht-LINE-Netzwerkaufruf, den Yomi selbst tätigt, ist der einmalige Download des Embedding-Modells von HuggingFace bei der ersten Suche – Modellgewichte rein, keine Nachrichteninhalte raus; siehe Suche.) PRIVACY.md ist die maßgebliche Richtlinie, und Yomi zeigt dem Agenten bei der Verbindung denselben Text an (und über get_scope_policy), damit er den Standard vor jedem Massenlesen offenlegen kann.

Haftungsausschluss

Yomi ist ein unabhängiges, inoffizielles persönliches Projekt, das zum Lernen und für den Zugriff auf das eigene LINE-Konto entwickelt wurde. Es ist nicht mit der LINE Corporation verbunden, von ihr autorisiert oder unterstützt. „LINE" ist eine Marke des jeweiligen Inhabers.

Die Nutzung von Yomi kann gegen die Nutzungsbedingungen von LINE verstoßen, und der Betrieb eines zusätzlichen Clients auf einem Konto kann zu Rate-Limiting oder Sperrung dieses Kontos führen. Yomi ist für den Zugriff auf dein eigenes Konto und deine eigenen Daten gedacht. Du bist allein für die Nutzung verantwortlich. Die Software wird „wie besehen" ohne jegliche Gewährleistung bereitgestellt – siehe LICENSE.

Danksagungen

Yomis LINE-Protokollimplementierung wurde unter Bezugnahme auf drei Open-Source-Projekte geschrieben, deren Feldlayouts, E2EE-Chunk-Reihenfolge, Anforderungsformen und Thrift-Definitionen diese unabhängige Implementierung beeinflusst haben:

• evex-dev/linejs (MIT) — Anforderungsformen und das Letter-Sealing-E2EE-Payload-Layout.

• DeachSword/CHRLINE (BSD-3-Clause) — Protokoll-Feldlayouts und den passwortlosen Anmeldeablauf.

• er1ce/LINE-Protocol (Apache-2.0) — Thrift-Enum-Definitionen (ContentType, MessageRelationType, ServiceCode).

Ihre Urheberrechtshinweise und vollständigen Lizenztexte sind in NOTICE wiedergegeben, wie es ihre Lizenzen verlangen.

Lizenz

MIT