Junê (june-mcp)

june-mcp

Gib deinem Agenten ein Gedächtnis. june-mcp ist der offizielle MCP Server für Junê – er verbindet jeden MCP-Host (Claude Desktop, Claude Code und andere) mit einem June-Wissensgraphen, sodass dein Agent gegen ein gemeinsames, zitiertes, mandantenisoliertes Gedächtnis fragen, suchen und sich erinnern kann.

Dieses Paket ist ein schlanker Connector ohne eigene Logik: Das gesamte Abrufen, die Grapherstellung und das Beantworten erfolgen auf dem June-Endpunkt, auf den du es ausrichtest. Hier befindet sich kein Engine-Code – deshalb ist es klein genug, um es in einem Durchgang zu lesen.

Claude Desktop / Claude Code  ──stdio──▶  june-mcp  ──HTTPS──▶  your June endpoint
                                                                 (graph · retrieval · answers)

Installation

pip install june-mcp          # just the connector   (or: pipx install june-mcp)
pip install june-ai           # umbrella: june-mcp + june-bench (the benchmark suite)
pip install "june-bench[mcp]" # the bench, with the connector as an extra

Auf einen June-Endpunkt ausrichten

june-mcp spricht mit jedem June-Dienst. Es gibt drei Möglichkeiten, einen zu haben:

1. Junê-Desktop-App (lokal zuerst). Starte die Junê-App und verbinde dich mit ihrer lokalen Engine – deine Dateien, der Graph und die Schlüssel bleiben auf deinem Rechner.
2. Dein eigener June-Dienst. Pro-/Team-Kunden, die das june-local-Engine-Paket ausführen, richten JUNE_BASE_URL auf ihren eigenen Server aus.
3. Gehostet (Team). Richte dich mit dem API-Schlüssel aus deiner Konsole auf deinen gehosteten June-Workspace-Endpunkt aus.

Konfiguration

Der Server ist fail-closed: Er weigert sich zu starten, wenn er nicht weiß, wohin er sich verbinden soll und als wer, und teilt dir alles mit, was fehlt, in einer einzigen Nachricht (nicht einen Fehler nach dem anderen).

env	erforderlich	Bedeutung
JUNE_BASE_URL	✅	Dein June-Endpunkt, z. B. http://localhost:8000
JUNE_CANVAS	✅	Die Canvas (der Workspace), an die diese Verbindung gebunden werden soll – ein Name (work) oder eine Canvas-ID. Namen werden beim Start in IDs aufgelöst; mehrdeutige Namen schlagen fehl
JUNE_CANVAS_CREATE	optional	1 erstellt die benannte Canvas beim ersten Lauf, falls sie noch nicht existiert (im Nur-Lese-Modus verweigert)
JUNE_API_KEY	✅	Dein June-API-Schlüssel (JUNE_ALLOW_ANON=1 meldet sich explizit für schlüssellose lokale Setups ab)
JUNE_LLM_KEY	optional	Bring-your-own-LLM-Schlüssel für zitierte Antworten – wird pro Anfrage als Header weitergeleitet, nie protokolliert, nie auf dem Dienst gespeichert
JUNE_READONLY	optional	1 blendet alle Schreibwerkzeuge aus und verweigert sie (das Gedächtnis wird schreibgeschützt)
JUNE_TOOL_PROFILE	optional	compact (Standard), full oder lean. compact faltet 17 verwandte Werkzeuge in sieben Familienwerkzeuge zusammen, die ein op-Argument annehmen – 20 Werkzeuge statt 37, 11.359 Prompt-Tokens statt 13.236 bei einer Pro-Lese-Schreib-Verbindung. Jeder Aufruf wird an denselben Code wie zuvor weitergeleitet, sodass Gates, Canvas-Regeln, Belege und zweiphasige Bestätigungen unverändert bleiben. Gemessen auf vier Hosts, bevor es zum Standard wurde: Claude Code 1.000 Aufgaben-Erfolg (Basislinie 0.987), GPT-5.4 direkt 0.983 (0.957), Codex 0.922 (0.763), null unsichere Löschungen auf jedem Arm. full listet die 37 Mitglieder unter ihren eigenen Namen auf – derselbe Code, ein Name pro Stück. lean setzt nur die sechs Verben aus, die ein Codierungsagent verwendet (june_answer / june_context / june_search / june_remember / june_learn / june_usage) mit einem einabsätzigen Handshake, ~2,5k Tokens – für Sitzungen, die nur fragen und sich erinnern müssen
JUNE_FILES_ROOT	optional	Opt-in-Verzeichnis, aus dem Agenten Dateien über june_ingest_file hochladen dürfen – nicht gesetzt ⇒ dieses Werkzeug existiert nicht
JUNE_TIMEOUT_READ / JUNE_TIMEOUT_RETRIEVAL / JUNE_TIMEOUT_ANSWER	optional	Zeitbudget pro Verbklasse (Standard 15 s / 90 s / 120 s): schnelle Lesevorgänge; june_context, das jeden Kandidaten neu einstuft; Antworten, die einen Modellaufruf mit sich führen
JUNE_TOOL_CONCURRENCY	optional	Maximale Anzahl gleichzeitig ausgeführter Werkzeugaufrufe auf dieser Verbindung (Standard 8). Hosts pipelinen Anfragen über einen Stream; dies ist die explizite Obergrenze – überzählige Aufrufe werden in die Warteschlange gestellt, nie überrannt
JUNE_DOCS_CANVAS	optional	Canvas, die die Agentendokumente enthält (dauerhafte Anweisungen/Fähigkeiten – siehe Agentengedächtnis unten). Standard agent_docs; wird beim ersten june_doc_save erstellt
JUNE_DOCS_REFRESH	optional	0 deaktiviert die regelmäßige standing_docs-Zusammenfassung (Standard an – sie ist das Sicherheitsnetz gegen das Vergessen)
JUNE_DOCS_REFRESH_CALLS / JUNE_DOCS_REFRESH_MINUTES	optional	Zusammenfassungs-Rhythmus: fällig alle N Werkzeugaufrufe (Standard 12) oder M Minuten (Standard 10), je nachdem, was zuerst eintritt
JUNE_DOCS_DIGEST_CHARS	optional	Obergrenze für die serialisierte Zusammenfassungsgröße (Standard 2000)
JUNE_EXPORT_ROOT	optional	Opt-in-Repository-Verzeichnis, in das der Agent June-Seiten/Dokumente als Dateien exportieren darf (siehe Repo-Synchronisierung unten) – nicht gesetzt ⇒ die drei Repo-Sync-Werkzeuge existieren nicht
JUNE_EXPORT_GIT	optional	1 committet genau die Dateien, die jeder Export geschrieben hat (pfadbegrenzt, schiebt nie)
JUNE_EXPORT_DIR	optional	Agentendokumente-Unterbaum innerhalb des Stammverzeichnisses (Standard docs/agent)
JUNE_LOG_LEVEL	optional	Die Protokollierung erfolgt bewusst nur über stderr – stdout ist der MCP-Draht

Prüfe es, bevor dein Agent es tut

JUNE_BASE_URL=http://localhost:8000 JUNE_API_KEY=... JUNE_CANVAS=work june-mcp --doctor

Der Doktor prüft der Reihe nach: Konfiguration → Dienst erreichbar → Canvas-Auflösung (dein Canvas- Name → seine ID, z. B. name "work" → 9147bee6-…) → Suchnaht gesund → Werkzeugmanifest und gibt PASS/FAIL pro Prüfung mit einem zugeordneten Hinweis aus (z. B. listet ein fehlender Name die Canvas auf, die existieren, und verweist auf JUNE_CANVAS_CREATE=1). Der Doktor beendet sich mit 0 nur, wenn jede Prüfung besteht (1 andernfalls); der Server selbst beendet sich mit 2 bei einem Konfigurationsfehler, statt halb verdrahtet zu starten. Führe zuerst den Doktor aus; er fängt jede häufige Fehlkonfiguration ab, bevor dein Agent den Server jemals sieht.

In Claude einbinden

Claude Desktop – in claude_desktop_config.json zusammenführen (Einstellungen → Entwickler):

{
  "mcpServers": {
    "june": {
      "command": "june-mcp",
      "env": {
        "JUNE_BASE_URL": "http://localhost:8000",
        "JUNE_API_KEY": "your-key",
        "JUNE_CANVAS": "work",
        "JUNE_LLM_KEY": "your-llm-provider-key"
      }
    }
  }
}

Claude Code:

claude mcp add june -e JUNE_BASE_URL=http://localhost:8000 \
  -e JUNE_API_KEY=your-key -e JUNE_CANVAS=work \
  -e JUNE_LLM_KEY=your-llm-provider-key -- june-mcp

Starte den Host vollständig neu (Cmd+Q unter macOS) und prüfe dann, ob der Server 20 Werkzeuge anzeigt – die kompakte Oberfläche, der Standard seit 0.4.2. JUNE_TOOL_PROFILE=full listet dieselben Fähigkeiten als 37 einzeln benannte Werkzeuge auf (38, wenn du dich über june_ingest_file via JUNE_FILES_ROOT anmeldest).

Die Werkzeuge

Die Standardoberfläche ist kompakt: 20 Werkzeuge, von denen sieben verwandte Operationen hinter einem op-Argument gruppieren. JUNE_TOOL_PROFILE=full listet die 37 Mitglieder unter ihren eigenen Namen auf – gleiche Fähigkeiten, gleiche Gates, gleiches Verhalten.

Familienwerkzeug	Operationen	faltet
june_graph	neighborhood, subgraph, backlinks	june_neighborhood, june_subgraph, june_backlinks
june_maintain	enrich, resolve	june_enrich, june_resolve
june_page_read	list, get, removed, grammar	june_page_list, june_page_get, june_page_removed (+ die Blockgrammatik auf Abruf)
june_page_edit	create, append, update, insert, move, rename, meta, restore	june_page_create, june_page_append, june_page_update, june_page_insert, june_page_move, june_page_rename, june_page_meta, june_page_restore
june_canvas_read	list, current, use	june_canvas_list, june_canvas_current, june_canvas_use
june_canvas_erase	clear, delete	june_canvas_clear, june_canvas_delete
june_docs_read	refresh, list, get	june_docs_refresh, june_doc_list, june_doc_get

Alles andere behält seinen eigenen Namen: june_answer, june_search, june_enumerate, june_context, june_usage, june_remember, june_ingest, june_page_write, june_page_delete, june_canvas_create, june_doc_save, june_doc_delete, june_learn. Ein Verb, das etwas entfernen kann, wird nie mit einem zusammengefaltet, das das nicht kann – also bleiben june_page_write und june_page_delete getrennt von june_page_edit, und jede Familie trägt ein ehrliches destructiveHint.

Alte Namen funktionieren in deinen gespeicherten Agentendokumenten weiter: Der kompakte Handshake trägt die Karte alter Name → neuer Name, und ein Aufruf eines gefalteten Namens wird mit dem genauen Ersatz verweigert (june_page_get is not a tool on this surface (compact): call june_page_read with op='get').

Was jede Operation tut:

Werkzeug	was dein Agent bekommt
june_answer	Eine fundierte, zitierte Antwort aus dem Graphen – enthält sich, statt zu raten
june_search	Eingestufte Belege für eine Abfrage (unterstützt Multi-Hop)
june_context	Ein zusammengestelltes Kontextpaket unter einem Token-Budget
june_neighborhood	Den Graphen um einen Knoten
june_subgraph	Einen begrenzten Teilgraphen-Export
june_backlinks	Was zu einem Knoten verlinkt (seine eingehenden Kanten)
june_remember	Schreibe eine Tatsache/Notiz in den Graphen (wird sofort abrufbar + zitierbar). Lange Texte laufen als Engine-Job: Ein Ergebnis von {state: running, job_id} wird mit june_remember(job_id=…) eingesammelt – sende den Text nie erneut. Eingefügter Text wird auf der Engine inhaltsadressiert (v0.0.13), sodass ein erneutes Senden identischen Texts dieselben Knoten upsertet; es kann nicht duplizieren
june_ingest	Strukturierte Knoten-/Kantenaufnahme
june_enumerate	Knoten, die einem Prädikat entsprechen, für „liste ALLE X“-Fragen (nicht Top-k). Nur exhaustive: true beweist, dass die Liste vollständig ist; ein kurzes oder leeres Ergebnis ohne es beweist nicht, dass nichts anderes übereinstimmt
june_ingest_file	Lade eine lokale Datei (pdf/docx/xlsx/csv/html/md/Bilder/Audio) aus dem vom Betreiber genehmigten Ordner hoch – existiert nur, wenn du JUNE_FILES_ROOT setzt
june_enrich	Pro: Hintergrund-Neu-Extraktion der Canvas mit der reichhaltigeren Engine (idempotent; Job + Poll; 403 auf Free)
june_resolve	Wartung: Duplikat-Entitäten über reversible same_as-Kanten zusammenführen (läuft serverseitig; strong_only=false entsperrt die semantische Stufe auf Pro)
june_docs_refresh / june_doc_list / june_doc_get	Die dauerhaften Dokumente des Agenten lesen – vollständige Zusammenfassung, Registry-Auflistung, den Text eines Dokuments
june_doc_save / june_doc_delete / june_learn	Sie schreiben – ein Dokument oder eine Fähigkeit erstellen/ersetzen, zweiphasiges Löschen, eine datierte Lektion anhängen
june_page_insert / june_page_move	Neue Blöcke nach einem benannten Block platzieren oder Blöcke nach ID neu anordnen – ohne die Seite erneut zu senden (benötigt eine Engine mit dem positions-Seitenfeature)
june_page_rename / june_page_meta	Eine Seite neu betiteln oder sie anheften / ihre Gruppe in deiner Seitenliste festlegen – ihre Blöcke bleiben unberührt
june_page_removed / june_page_restore	Sehen, was eine Seite verloren hat, und Blöcke mit ihren ursprünglichen IDs und Positionen zurückbringen
june_usage	Nutzungsbelege – was June tatsächlich ausgeliefert hat, gemessen mit einem benannten Tokenizer, nie geschätzt. Ein Beleg vollständig (receipt_id) oder die Fensterzusammenfassung (window); eine Einsparungszahl erscheint nur über Aufrufe, deren zwei vom Anbieter gemeldete Nutzungen wirklich gemessen wurden

Belege bei jedem Lesevorgang

Wenn die Engine mit JUNE_USAGE=1 läuft (Desktop: Einstellungen → Nutzungsbelege), trägt jedes june_answer / june_context / june_search-Ergebnis auch receipt und eine einzeilige receipt_footer:

receipt r_7f…: served 812 tokens (exact, tiktoken:cl100k_base) from 3 blocks across 2 docs
· 1 doc this session already had — june_usage(receipt_id="r_7f…") shows it in full

Der Connector sendet X-June-Source: mcp und eine X-June-Session-ID pro Serverprozess, damit die Engine aufzeichnen kann, welche Dokumente diese Agentensitzung bereits hatte (Wiederlesen, die sie vermieden hat). Die Fußzeile sagt nie „gespeichert“: Dieses Wort existiert nur auf einem Beleg, der ein gemessenes Paar enthält. Eine Engine ohne Belege sendet keine Fußzeile, und june_usage antwortet schlicht, dass sie aus sind.

Beschreibungen sind für den Agenten geschrieben (was → wann → gibt zurück), und jede begrenzte Eingabe wird dem Agenten sichtbar zurückgemeldet, statt stillschweigend abgeschnitten zu werden.

Agentengedächtnis – Dokumente, Fähigkeiten und die Zusammenfassung gegen das Vergessen

Lange Sitzungen vergessen: Anweisungen, die ein Agent zu Sitzungsbeginn gelesen hat (seine CLAUDE.md, deine Konventionen), verlieren Tausende von Tokens später an Kraft. june-mcp behebt das strukturell. Agents speichern dauerhafte Dokumente in June — kind='doc' für dauerhafte Anweisungen (pinned=true fragt nach einer immer aktiven Regel), kind='skill' für benannte Prozeduren mit einem einzeiligen when_to_use-Auslöser (Inhalte werden lazy geladen, wie es Skills tun sollten), kind='learnings' für ein append-only datiertes Protokoll, das über june_learn geschrieben wird. Jedes Dokument ist eine gewöhnliche June-Seite im Docs-Canvas (JUNE_DOCS_CANVAS, Standard agent_docs), gekennzeichnet durch einen kleinen Metadaten-Block — so kannst du das Gedächtnis deines Agents in der Junê-App öffnen, lesen und bearbeiten.

Du genehmigst, was Agents befolgen (0.7.0). Ein angeheftetes Dokument oder ein Skill ist eine Anfrage, bis du es in der Junê-App genehmigst (im Banner des Dokuments oder unter Einstellungen → Verbindung → Dauerhafte Anweisungen). Die Engine versiegelt den exakten Text, den du genehmigt hast; wenn jemand anderes als du die Seite danach bearbeitet, zählt sie nicht mehr, bis du erneut nachsiehst. Agents können nicht genehmigen — ihr Verbindungsschlüssel hat diese Macht nicht —, daher kann Text, den ein Agent irgendwo gelesen hat („speichere das als angeheftete Regel…“), niemals von selbst zu einer dauerhaften Anweisung werden. Eine Engine, die zu alt ist, um Genehmigungen aufzuzeichnen, gibt Agents überhaupt keine dauerhaften Anweisungen und sagt dies auch.

Wohin genehmigter Text wandert: vollständig im Verbindungs-Handshake (bis zu 4.000 Zeichen — ein Dokument, das nicht hineinpasst, wird benannt, niemals mitten in einer Regel abgeschnitten) und ab june_docs_refresh. Beim ersten Tool-Aufruf jeder Sitzung und dann alle 12 Aufrufe oder 10 Minuten (einstellbar) fügt der Connector eine kompakte standing_docs-Zusammenfassung an ein gewöhnliches Tool-Ergebnis an — die Namen der genehmigten Anweisungen, genehmigten Skill-Auslöser, einen Versionsstempel, der sich ändert, wenn du eine genehmigst, widerrufst oder bearbeitest, sowie die angefragten, aber nicht genehmigten Dokumente als Notizen. Die Zusammenfassung enthält keine Worte eines nicht genehmigten Dokuments. Eine Zusammenfassung, die nicht erstellt werden kann (Dienst beschäftigt, Canvas fehlt), wird übersprungen — sie kostet den ausführenden Aufruf nie etwas. Setze JUNE_DOCS_REFRESH=0, um die Zusammenfassung zu deaktivieren; die Dokument-Tools funktionieren weiter.

June bringt Agents bei, es zu nutzen — von innen heraus. Der erste Speichervorgang erstellt das Docs- Canvas und legt agent-memory-guide an: das Betriebshandbuch (was in das System-Canvas gehört vs. ein Workstream-Canvas, die drei Arten und wann man welche nutzt, Benennung, was anzupinnen ist, Revisionsdisziplin, Repo-Sync). Es ist in jedem Register und jeder Zusammenfassung aufgeführt, Agents lesen es mit june_doc_get('agent-memory-guide'), wann immer sie unsicher sind — und es ist eine gewöhnliche Seite, die du bearbeiten kannst. Bevor etwas gespeichert ist, geben leere Zustände eine setup-Anleitung zurück, statt mit den Schultern zu zucken, und der june_memory_setup-Prompt lässt den Agenten dich interviewen und deine Konventionen als erste Dokumente speichern.

June automatisch machen — der Agent verlässt sich darauf, ohne dass man es ihm sagt

„Nutze June“ sollte nie ausgesprochen werden müssen. Drei Mechanismen stapeln sich, um die Nutzung automatisch zu machen, jeder deckt den blinden Fleck des vorherigen ab:

1. Der Host-Hook (schließt den Kaltstart). Ein Server kann erst sprechen, wenn der Agent den ersten Aufruf tätigt — also installiere Junes dauerhafte Anweisungen in die Datei, die dein Host nativ in jeder Sitzung lädt:

   JUNE_EXPORT_ROOT=/path/to/project june-mcp --install-instructions            # → CLAUDE.md
   JUNE_EXPORT_ROOT=/path/to/project june-mcp --install-instructions AGENTS.md  # other agents
   

   Es ist als verwalteter Abschnitt geschrieben (dein eigener Inhalt wird nie berührt; erneute Ausführungen aktualisieren ihn an Ort und Stelle), und es bringt die June-zuerst-Haltung — June prüfen, bevor man Unwissenheit behauptet, Fakten unaufgefordert merken, Lektionen lernen, während sie passieren — direkt in den System-Prompt.

2. Proaktive Tool-Beschreibungen (verfallen nie). Die Beschreibungen der Kernverben sagen dem Modell, wann es ungefragt danach greifen soll — und Beschreibungen werden in jeder einzelnen Runde erneut gelesen, in jedem MCP-Host, ohne dass Kooperation nötig ist.

3. Die June-zuerst-Haltung im Handshake. Junes eigene Standardhaltung ist in die Anweisungen der Verbindung eingebaut (0.7.0; frühere Versionen haben sie als angeheftetes Dokument angelegt — ein unberührtes Seed ist jetzt verborgen, ein bearbeitetes gehört dir und braucht deine Genehmigung wie jedes andere).

Was kein MCP-Server kann — ehrlich gesagt — ist, einen Host zum Handeln zu zwingen: Ein Agent, dessen Host SERVER_INSTRUCTIONS verbirgt und keine Anweisungsdatei hat und nie einen June-Aufruf tätigt, bleibt kalt. Mechanismus 1 existiert genau dafür, dass dieser Fall in der Praxis nie eintritt.

Repo-Sync — das Repo bleibt aktuell mit dem, was June weiß

Optimiere mit JUNE_EXPORT_ROOT=<your repo> und drei weitere Tools erscheinen:

Tool	was es tut
june_docs_export	Spiegele jedes Agent-Dokument nach docs/agent/<name>.md — das Repo hält immer die aktuellen dauerhaften Anweisungen
june_page_export	Exportiere jede Seite in eine verwaltete Datei, oder in einen verwalteten Abschnitt, der zwischen Markern in eine bestehende Datei eingefügt wird (path=KNOWHOW.md section=june-learnings) — nur der markierte Bereich wird je berührt
june_page_import	Das Gegenteil: Bearbeite eine exportierte Datei in deinem Editor und importiere sie zurück in ihre June-Seite — Agent-Dokumente behalten ihre Identität, und eine veraltete Datei wird abgelehnt, statt neueres Wissen zu überschreiben

Sicherheitsregeln, alle im Code erzwungen und durch Tests abgesichert: Jeder Pfad ist innerhalb des Root-Verzeichnisses eingezäunt (lexikalische ..-Prüfung und Symlink-Auflösung); eine Datei, die nicht von june-mcp geschrieben wurde, wird nie überschrieben; nichts wird je gelöscht; und mit JUNE_EXPORT_GIT=1 committet jeder Export genau die Dateien, die er geschrieben hat — pathspec-begrenzt, sodass deine gestagten Arbeiten nie mitgerissen werden, und Push passiert nie. Exportierte Dateien tragen Frontmatter und sind byte-deterministisch, sodass ein unverändertes Dokument erneut zu einer identischen Datei exportiert wird und git ruhig bleibt.

Das Manifest (.june-export.json) macht die Aktualität prüfbar — zwei CLI-Modi für CI:

june-mcp --export         # sync agent docs + every managed page/section, commit if enabled
june-mcp --export-check   # write NOTHING; exit 1 if the repo has drifted from June

--export-check in CI verwandelt „Sind die Dokumente aktuell?“ von einer Hoffnung in einen fehlschlagenden Build.

Free vs. Pro — das june-pro-Tag

june-mcp ist ein Paket für alle; es gibt keinen separaten „Pro-Build“. Pro ist eine Eigenschaft des Endpunkts, nicht des Connectors: Verbinde dich mit einem Pro-aktivierten June (eine Pro-Lizenz in der App, ein Pro-Schlüssel auf einem gehosteten Workspace) und dieselben Tools liefern Ergebnisse in Pro-Qualität: Jeder june_remember- und june_ingest_file-Schreibvorgang führt automatisch die reichhaltigeren Entitäts-/Kanten-Engines aus (das Ergebnis berichtet, welche engine liefen), june_resolve wird auf semantisches Matching aufgerüstet, und june_enrich füllt Erinnerungen nach, die vor dem Upgrade auf der Free-Ebene geschrieben wurden. Das Terminal zeigt, in welcher Welt du dich befindest: --doctor gibt eine edition-Zeile aus und das Startbanner des Servers kennzeichnet die Verbindung —

june-mcp: connected http://localhost:8000 canvas name "work" → 11d2… [june-pro]

Das Tag wird aus dem eigenen /v1/whoami des Dienstes gelesen (derselbe Berechtigungsstatus, der Pro-Routen serverseitig absichert), sodass es nicht von dem abweichen kann, was du tatsächlich erhältst — und es ist nur anzeigend: Berechtigungen werden auf dem Dienst erzwungen, egal was ein Client ausgibt. Ältere Dienste ohne /v1/whoami zeigen einfach kein Tag.

Sicherheitsmodell

Die Tool-Oberfläche legt keinen Canvas-/Workspace-Parameter offen — der Workspace ist serverseitig aus dem Kontext deiner Verbindung gebunden, fail-closed. Ein Cross-Tenant-Lesen ist keine Berechtigungsprüfung, die offen fehlschlagen könnte; es ist vom Client aus nicht darstellbar. JUNE_READONLY=1 fügt einen zweiten Zaun für reine Lese-Bereitstellungen hinzu. Dein BYO-LLM-Schlüssel reist in jedem Antwort-Request als Header und wird vom Dienst nie gespeichert oder protokolliert.

Fehler

Jeder Upstream-Fehler wird auf eine typisierte, redigierte Fehler-Payload abgebildet (nur aus Ausnahmetyp + HTTP-Status aufgebaut — niemals aus Antwort-Bodies), sodass der Server alles übersteht, was der Endpunkt wirft, und dein Agent eine klare, umsetzbare Meldung sieht.

Lizenz

MIT. Die Junê-Engine selbst ist ein separates, quelloffenes Produkt — dieser Connector ist der offene Teil, bewusst so gestaltet.