Junê (june-mcp)

offiziell

Verleihen Sie Ihrem Agenten ein Gedächtnis: gemeinsames, zitiertes, mandantenisoliertes Knowledge-Graph-Gedächtnis für jeden MCP-Host. Fundierte Antworten von einem lokalen June-Endpunkt – er enthält sich, statt zu raten.

GitHubDieses MCP ausprobierenGesponsert

Was kann man mit Junê (june MCP machen?

Zitierte Antworten aus dem Gedächtnis — Bitten Sie Ihre KI, eine Frage mit june_answer zu beantworten, das fundierte, zitierte Antworten aus dem Wissensgraphen liefert und sich bei Unsicherheit enthält, statt zu raten.
Im Graphen suchen und erkunden — Verwenden Sie june_search für eingestufte Multi-Hop-Beweise, june_neighborhood zur Untersuchung von Verbindungen um einen Knoten oder june_subgraph, um einen begrenzten Graphenbereich zu exportieren.
Neue Erinnerungen schreiben — Lassen Sie Ihren Agenten Fakten oder Notizen mit june_remember aufzeichnen, damit sie sofort abrufbar und zitierbar werden, oder erfassen Sie strukturierte Knoten/Kanten über june_ingest.
Alles auflisten, was einem Prädikat entspricht — Bitten Sie um eine vollständige Aufzählung aller Knoten mit june_enumerate, die jede Übereinstimmung zurückgibt, statt einer Top-k-Stichprobe.
Lokale Dateien erfassen — Laden Sie unterstützte Dokumente (PDF, DOCX, XLSX, CSV, HTML, MD, Bilder, Audio) aus einem genehmigten Ordner mit june_ingest_file hoch, wenn JUNE_FILES_ROOT konfiguriert ist.
Doppelte Entitäten zusammenführen — Führen Sie june_resolve aus, um doppelte Entitäten über reversible same_as-Kanten zu konsolidieren, mit einer optionalen semantischen Stufe auf Pro-Endpunkten.

Dokumentation

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 weitere) 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 Retrieval, die Graphenkonstruktion und die Beantwortung finden auf dem June-Endpoint statt, auf den du ihn ausrichtest. Hier befindet sich kein Engine-Code — genau deshalb ist das Paket 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-Endpoint ausrichten

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

Junê-Desktop-App (lokal zuerst). Starte die Junê-App und verbinde dich mit ihrer lokalen Engine — deine Dateien, dein Graph und deine Schlüssel bleiben auf deinem Rechner.
Eigener June-Dienst. Pro-/Team-Kunden, die das june-local-Engine-Paket ausführen, richten JUNE_BASE_URL auf ihren eigenen Server aus.
Gehostet (Team). Richte dich mit dem API-Schlüssel aus deiner Konsole auf den Endpoint deines gehosteten June-Workspace aus.

Konfiguration

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

env	erforderlich	Bedeutung
`JUNE_BASE_URL`	✅	Dein June-Endpoint, z. B. `http://localhost:8000`
`JUNE_CANVAS`	✅	Die Canvas (der Workspace), an die diese Verbindung gebunden wird — ein Name (`work`) oder eine Canvas-ID. Namen werden beim Start in die ID aufgelöst; mehrdeutige Namen führen zu einem fail-closed
`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` entscheidet sich explizit gegen einen Schlüssel für schlüssellose lokale Setups)
`JUNE_LLM_KEY`	optional	Bring-your-own-LLM-Schlüssel für zitierte Antworten — wird pro Anfrage als Header weitergeleitet, niemals protokolliert, niemals auf dem Dienst gespeichert
`JUNE_READONLY`	optional	`1` blendet alle Schreib-Tools aus und verweigert sie (das Gedächtnis wird schreibgeschützt)
`JUNE_FILES_ROOT`	optional	Opt-in-Verzeichnis, aus dem Agenten Dateien über `june_ingest_file` hochladen dürfen — nicht gesetzt ⇒ dieses Tool existiert nicht
`JUNE_TIMEOUT_READ` / `JUNE_TIMEOUT_ANSWER`	optional	Zeitüberschreitungen pro Verb (Standard 15 s / 120 s)
`JUNE_LOG_LEVEL`	optional	Die Protokollierung erfolgt bewusst nur über stderr — stdout ist die MCP-Leitung

Vorab prüfen, bevor es dein Agent tut

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

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

In Claude einbinden

Claude Desktop — in claude_desktop_config.json einfügen (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, dass der Server 10 Tools anzeigt (11, wenn du dich über JUNE_FILES_ROOT für june_ingest_file entscheidest).

Die Tools

Tool	Was dein Agent bekommt
`june_answer`	Eine fundierte, zitierte Antwort aus dem Graphen — enthält sich lieber, als zu raten
`june_search`	Rangfolge der Belege für eine Abfrage (unterstützt Multi-Hop)
`june_context`	Ein zusammengestelltes Kontextpaket unter einem Token-Budget
`june_neighborhood`	Der Graph um einen einzelnen Knoten
`june_subgraph`	Ein begrenzter Teilgraph-Export
`june_remember`	Eine Tatsache/Notiz in den Graphen schreiben (wird sofort abrufbar und zitierbar)
`june_ingest`	Strukturierte Knoten-/Kantenaufnahme
`june_enumerate`	JEDER Knoten, der einem Prädikat entspricht — vollständiges „Liste ALLE X" (nicht Top-k)
`june_ingest_file`	Eine lokale Datei (pdf/docx/xlsx/csv/html/md/Bilder/Audio) aus dem freigegebenen Ordner hochladen — existiert nur, wenn du `JUNE_FILES_ROOT` setzt
`june_enrich`	Pro: Hintergrund-Nachbearbeitung der Canvas mit der leistungsfähigeren Engine (idempotent; Job + Poll; 403 im freien Tarif)
`june_resolve`	Wartung: Duplikate von Entitäten über reversible `same_as`-Kanten zusammenführen (läuft serverseitig; `strong_only=false` schaltet die semantische Stufe auf Pro frei)

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

Kostenlos 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 Endpoints, 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 auf Pro-Niveau: jeder june_remember- und june_ingest_file-Schreibvorgang führt automatisch die leistungsfähigeren Entitäts-/Kanten-Engines aus (das Ergebnis berichtet, welche engine ausgeführt wurden), june_resolve wird auf semantisches Matching aufgewertet, und june_enrich füllt Erinnerungen nach, die vor dem Upgrade auf der kostenlosen Stufe 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 auch Pro-Routen serverseitig freischaltet), sodass es nicht von dem abweichen kann, was du tatsächlich bekommst — und es ist nur zur Anzeige: Berechtigungen werden auf dem Dienst durchgesetzt, egal was ein Client ausgibt. Ältere Dienste ohne /v1/whoami zeigen schlicht kein Tag an.

Sicherheitsmodell

Die Tool-Oberfläche legt keinen Canvas-/Workspace-Parameter offen — der Workspace wird serverseitig aus dem Kontext deiner Verbindung gebunden, fail-closed. Ein mandantenübergreifender Lesezugriff ist keine Berechtigungsprüfung, die fehlschlagen könnte; er ist vom Client aus nicht darstellbar. JUNE_READONLY=1 fügt einen zweiten Zaun für Nur-Lese-Bereitstellungen hinzu. Dein BYO-LLM-Schlüssel reist bei jeder Antwortanfrage als Header mit und wird vom Dienst weder gespeichert noch protokolliert.

Fehler

Jeder Upstream-Fehler wird auf eine typisierte, redigierte Fehlerantwort abgebildet (nur aus Ausnahmetyp + HTTP-Status aufgebaut — niemals aus Antworttexten), sodass der Server alles übersteht, was der Endpoint auslöst, 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 gestaltet.