wisdomGraph

English | 简体中文

Graph-native, persistente Kognition für KI-Agenten.

graphify liefert dir eine Momentaufnahme. wisdomGraph gibt dir ein Gedächtnis, das sich weiter aufbaut.

Nutze wisdomGraph mit Claude Code, Codex, OpenClaw oder einem beliebigen MCP-Host. Füttere es mit deinen Codebasen, Notizen, Papers, Gesprächen – jeder Lauf verschmilzt in einem lebendigen Neo4j-Graphen. Der Graph setzt nicht zurück. Er wächst. Fakten werden zu Mustern. Muster werden zu Erkenntnissen. Erkenntnisse werden zu Wissen.

/wisdom .                      # absorb this project into the wisdom graph
/wisdom ask "what patterns repeat across all my projects?"
/wisdom reflect                # promote insights → wisdom, close the feedback loop

Der Schritt über graphify hinaus

graphify ist gut in dem, was es tut: Einen Ordner in eine Wissensgraphen-Momentaufnahme zu verwandeln. Ein Lauf, eine graph.json, ein GRAPH_REPORT.md. Lies es. In der nächsten Session beginnst du neu.

wisdomGraph macht etwas strukturell anderes.

Der Unterschied ist nicht inkrementell. Er ist architektonisch. graphify komprimiert eine Codebase in einen lesbaren Report. wisdomGraph baut eine künstliche Epistemologie – eine, die sich erinnert, verbindet und wächst.

Related MCP server: persistent-kb-mcp

Die DIKW-Pyramide, operationalisiert

Menschliche Experten speichern keine flachen Fakten. Sie organisieren Erfahrung in Ebenen:

Wisdom    ← actionable principles derived from patterns
  ↑
Insight   ← patterns detected across multiple experiences
  ↑
Experience ← events, decisions, outcomes with context
  ↑
Knowledge ← verified facts, documented behaviors, extracted structure

Jeder Knoten in wisdomGraph trägt ein tier-Label. Die Graphtopologie ist die kognitive Architektur. Wenn du etwas fragst, geht Cypher in den Ebenen nach oben – nicht Muster-Matching von Flachtext, sondern Reasoning entlang gelebter Erfahrung.

Die Feedback-Schleife ist entscheidend: Wenn ein Wisdom-Knoten abgefugt wird und nützlich ist, bestätigt er die verbundenen Knowledge-Knoten. Der Graph lernt, was zählt.

Installation

Erforderlich: Python 3.10+ und einer von: Claude Code, Codex, OpenClaw oder einem anderen MCP-Host

Und eines von: Neo5Aura Free (Cloud, keine Installation) oder Docker Desktop/Engine für einen verwalteten lokalen Neo4j-Container

pip install 'wisdomgraph[mcp]'
wisdom quickstart

wisdom quickstart ist die End-to-End-Erstinstallation. Sie bereitet den Speicher vor, prüft die Neo4j-Verbindung und registriert wisdomGraph bei erkannten MCP-Hosts.

# Local managed Neo4j backend + detected MCP hosts
wisdom quickstart

# Local backend + Codex only
wisdom quickstart --host codex

# Existing Neo4j or DozerDB instance
wisdom quickstart --storage existing --uri bolt://localhost:7689 --user neo4j --password <password>

# Neo4j Aura
wisdom quickstart --storage aura --uri bolt+s://xxxxxxxx.databases.neo4j.io --user neo4j --password <password>

Der MCP-Server selbst startet nie Docker oder erstellt Datenbanken. Das Speicher-Setup erfolgt explizit über quickstart, local, docker oder connect.

Option A – Verwaltetes lokales Backend (empfohlen beim ersten Lauf)

wisdom local up
wisdom doctor

Dadurch startet ein verwalteter neo4j:latest-Container mit dem Namen wisdomgraph-neo4j, speichert Daten unter ~/.wisdom/neo4j, verwendet den dokumentierten lokalen Login neo4j/password, speichert die Verbindung und lässt den MCP-Start sauber getrennt. Die Implementierung nutzt Docker direkt, daher funktioniert derselbe Befehl nur local up unter Windows PowerShell, Windows cmd.exe, macOS Terminal und Ubuntu Terminal, sobald Docker installiert ist.

Nützliche Befehle:

wisdom local status
wisdom local logs
wisdom local down

Option B – Neo4j in der Cloud (ohne lokale Datenbank)

1. Erstelle ein kostenloses Konto unter elapsed.neo4j.com/cloud/aura

2. Erstelle eine kostenlose AuraDB-Instanz – kopiere die Verbindungs-URI und das Passwort

3. Führe Folgendes aus:

wisdom connect bolt+s://xxxxxxxx.databases.neo4j.io --user neo4j --password <your-password>

Kostenlose Stufe: 200.000 Knoten. Mehr als genug für Jahre gesammelter Wiedergabe.

Option C – Optional/manuell DozerDB Docker (volle Kontrolle, APOC enthalten)

wisdom docker up        # pulls graphstack/dozerdb:5.26.3.0 and starts it
wisdom connect bolt://localhost:7687 --user neo4j --password password

Oder manuell:

docker run -d \
  -p 7474:7474 -p 7687:7687 \
  -v $HOME/neo4j-wisdom/data:/data \
  -v $HOME/neo4j-wisdom/logs:/logs \
  --env NEO4J_AUTH=neo4j/password \
  --env NEO4J_PLUGINS='["apoc"]' \
  graphstack/dozerdb:5.26.3.0

Öffne localhost:7474 – Neo4j Browser ist dein visuelles Fenster in den Wissensgraph.

Plattform-Unterstützung

Öffne danach deinen KI-Coding-Assistenten und tippe:

/wisdom .

MCP-Integration (v0.2.0+)

wisdomGraph wird als nativer Model Context Protocol (MCP)-Server ausgeliefert. Nach der Installation kann Claude, Codex oder ein anderer MCP-Host die wisdomGraph-Werkzeuge direkt aufrufen — ein /wind-Slash-Befehl wird nicht benötigt.

Claude Code Setup

wisdom mcp-install

Dieser Befehl schreibt den MCP-Server-Eintrag in .claude/settings.json deines aktuellen Projekts:

{
  "mcpServers": {
    "wisdomGraph": {
      "command": "wisdom",
      "args": ["mcp"]
    }
  }
}

Starte Claude Code neu. wisdomGraph ist in diesem Projekt jetzt live.

Codex Setup (v0.3.0+)

wisdom mcp-install --host codex

Damit wird die MCP-Registrierung für Codex ausgeführt:

codex mcp add wisdomGraph -- wisdom mcp

Starte eine neue Codex-Session. Codex kann jetzt wisdom mcp starten und denselben Neo4j-gestützten DIKW-Graphen verwenden wie Claude Code.

MCP-Werkzeuge

Beispiel – Claude erinnert sich über Sessions hinweg

Session 1:

Claude ruft wisdom_remember auf mit dem Label "DozerDB ignores NEO4J_AUTH if data dir exists", Stufe experience.

Session 2 (einige Tage später, neues Terminal):

Du fragst: „Wie setze ich DozerDB-Zugangsdaten zurück?“ Claude ruft wisdom_query auf → findet den Experience-Knoten → antwortet aus deinem eigenen Verlauf.

Der Graph hat sich erinnert. Claude hat nicht vergessen.

Globale vs. projektspezifische MCP-Installation

# Register for the current project only
wisdom mcp-install

# Register globally (all projects on this machine)
wisdom mcp-install --project ~

# Register globally with Codex
wisdom mcp-install --host codex

Verwendung

/wisdom                              # absorb current directory
/wisdom ./raw                        # absorb a specific folder
/wisdom ./raw --mode deep            # aggressive INFERRED edge extraction
/wisdom ./raw --update               # re-absorb only changed files, MERGE into graph
/wisdom ./raw --tier knowledge       # force all extractions into Knowledge tier only

/wisdom add https://arxiv.org/abs/1706.03762   # absorb a paper
/wisdom add https://x.com/...                  # absorb a tweet thread
/wisdom add https://...  --author "Name"        # tag the source author

/wisdom ask "what patterns repeat across all my projects?"
/wisdom ask "what do I know about authentication flows?"
/wisdom ask "trace the path from attention to optimizer"
/wisdom ask "..." --tier wisdom      # only traverse Wisdom-tier nodes in answer

/wisdom reflect                      # LLM promotion pass: Knowledge→Experience→Insight→Wisdom
/wisdom reflect --project ./raw      # reflect only on nodes from this corpus

/wisdom path "DigestAuth" "OAuth"    # shortest path between two concepts
/wisdom explain "CausalSelfAttention"  # full DIKW context for a node
/wisdom god-nodes                    # highest-degree concepts across all projects

/wisdom export --cypher              # dump all nodes/edges as Cypher CREATE statements
/wisdom export --json                # export to graph.json (graphify-compatible)
/wisdom export --obsidian            # export to Obsidian vault

/wisdom status                       # graph stats: node counts by tier, edge counts, last update
/wisdom purge --project ./raw        # remove nodes from one corpus, touch nothing else

Wie Wisdom wächst

Lauf 1 – nimm deine Auth-Bibliothek auf:

Knowledge: JWT, session tokens, cookie flags, PKCE flow
Experience: (none yet — single source)

Lauf 2 – nimm die Auth-Struktur eines anderen Projekts auf:

Knowledge: JWT, PKCE — MERGE deduplicates, adds a source link
Experience: two implementations, same pattern detected
Insight: JWT + PKCE is the converged pattern in your work

Lauf 3 – /wisdom reflect:

Wisdom: "Use stateless JWT for APIs, PKCE for browser flows.
         Shipped this pattern across 3 projects without incident."

Lauf 4 – /wisdom ask "wie sollte ich Auth in diesem neuen Dienst behandeln?":

Traversal: Knowledge → Experience → Insight → Wisdom
Answer: your own battle-tested principle, grounded in your actual history

Das ist kein Ordinary RAG. Das ist keine Zusammenfassung. Das ist der Graph, der dir auf Basis deiner gesammelten Erfahrung deine eigene Wisdom zurückgibt.

Graph-Schema

** Pyramid – DIKW:**

// DIKW node labels
(:Knowledge  {id, label, content, source_file, confidence, timestamp, project})
(:Experience {id, label, content, context, outcome, timestamp, project})
(:Insight    {id, label, content, pattern_strength, source_count, timestamp})
(:Wisdom     {id, label, principle, confidence, reinforcement_count, timestamp})

// Relationships
(Knowledge)-[:GROUNDS]->(Experience)
(Experience)-[:REVEALS]->(Insight)
(Insight)-[:CRYSTALLIZES_INTO]->(Wisdom)
(Wisdom)-[:REINFORCES]->(Knowledge)           // feedback loop — the graph learns

(Knowledge)-[:SEMANTICALLY_SIMILAR_TO]->(Knowledge)
(Insight)-[:CONTRADICTS]->(Insight)           // tension surfaces, needs reflection
(any)-[:SOURCED_FROM]->(Source {uri, author, ingested_at})

// Cross-agent composite index
CREATE INDEX wisdom_composite IF NOT EXISTS
FOR (n:Knowledge|Experience|Insight|Wisdom)
ON (n.id, n.timestamp, n.confidence)

Konfidenz fließt durch den Graphen. Ein Insight, der in 8 Experiences begründet ist, hat eine höhere pattern_strength als einer Mit nur 2. Wisdom-Knoten führen reinforcement_count – wie viele Traversen das Prinzip bestätigt haben.

Was du bekommst

Projektübergreifende God-Knoten – Konzepte, die über alle deine Projekte hinaus zentral sind, nicht nur in einem Repo.

Widerspruchserkennung – Zwei Insights in gegensätzliche Richtungen erzeugen CONTRADICTS-Verbindungen. Der Graph zeigt den Widerstand; du liebst ihn zu besserer Wisdom.

Zeitlicher Zerfall – Knoten tragen Zeitstempel. Alter Knowledge, das nicht durch frische Experience ausgedrückt wird, wird markiert. Der Graph altert elegant – wie ein erfahrenes Gedächtnis.

Volle Provenienz-Kette – Jeder Knoten zeigt zurück auf seine Source. Die Funktion kann Graf: /wind/explain Pfad: Fakt → Kontext → Muster → Prinzip.

Die „Warum“-Kette – nicht nur was, sondern warum es zählt – aus Docstrings, # NOTE:-Kommentaren, Design-Dokus in der Doku und der DIKW-Promotions-Logik.

Deployment-Optionen

Datenschutz

wisdomGraph sendet Dateiinhalte an die Modell-API deines KI-Coding-Assistenten zur semantischen Extraktion – insbesondere wenn das Modell von Anthropic oder vom Anbieter verwendet wird, den deine Plattform fest eingerichtet hat. Codeteilen werden lokal mit Ast von tree-sitter geparst. Alle Graphdaten liegen in deiner Neo4j-Instanz (Aura oder lokal). Keine Telemetrie, kein Usage-Tracking, keine Analyse.

Technologie-Stack

Neo4j (Aura oder DozerDB) + tree-sitter + APOC. Erstsemantische Extraktion über Claude (Claude Code) oder das Modell deiner Plattform. Die Graphdatenbank ist die Intelligenz-Schicht – Traversen, Pfadfindung und Community-Erkennung laufen nativ in Cypher über Neo4j GDS (Graph Data Science). Die-MCP-Integration erfolgt über das Model Context Protocol und das dortige Python-SDK.

Ausgearbeitete Beispiele sind die vertrauenswürdigste Art zu helfen: Führe /wisdom eines einen echten, Multi-Projekt-Korpus aus, lass ein- oder mehr­fach /wind reflect laufen und dokumentiere, welche Wisdom-Knoten entstanden sind – und ob sie deiner Intuition entsprechen. Gib sie unter worked/{slug}/ ab.

Schema-Vorschläge hast du einen Beziehungstyp, der etwas Beziehungswertes nicht abbildet, das aktuell im Schema fehlt? Öffne ein Issue mit Cypher-Muster und ausgearbeitetem Beispiel.

DIKW"-Promoting-Heuristiken – bessere Prompts oder Rules dafür, wann Wissen über Knowledge → Experience → Insight → Wisdom aufsteigen soll. Die Promotion-Logik ist das Herz des Systems.

Alles zur Architektur plus Cypher-Schemas und wie Stufen erweitert werden können, steht in ARCHITECTURE.md.