● GRAPH-INFRASTRUKTUR / NEO4J + RUBY
Animiertes Graph-Netzwerk

Nicht Tabellen.
Beziehungen.

SQL denkt in Zeilen. Graphen denken in Verbindungen. Wenn deine Queries drei JOINs brauchen um eine Verfügbarkeit zu prüfen, ist das kein Abfrageproblem — es ist ein Modellierungsproblem.

01 / Das Problem

SQL bei vernetzten
Daten.

Relationale Datenbanken sind brillant für das, wofür sie gebaut wurden: strukturierte Tabellen, einfache Beziehungen, ACID-Transaktionen. Aber sie haben eine Achillesferse: wenn Daten vernetzt sind, nicht nur verknüpft.

Drei JOINs für eine einfache Verfügbarkeitsabfrage. N+1-Queries weil der ORM nicht weiß wohin. Discriminator-Spalten für polymorphe Typen. Hierarchien als Adjazenzlisten — und jede Ebene kostet eine weitere Sub-Query.

Das sind keine Fehler. Das ist SQL das tut was es tut. Das Problem ist das Mismatch zwischen dem Datenmodell und dem Abfragemodell.

Der JOIN ist die Lüge.
Die Beziehung ist der Wert.

SQL / JOIN-Hölle
-- Wer ist morgen für Mission #47 verfügbar?
SELECT p.name
FROM persons p
JOIN person_missions pm ON pm.person_id = p.id
JOIN missions m ON pm.mission_id = m.id
JOIN time_slots ts ON ts.mission_id = m.id
LEFT JOIN absences a ON a.person_id = p.id
  AND a.date = '2026-06-18'
WHERE m.id = 47
  AND a.id IS NULL
-- 3 JOINs. Kein Polymorph. Kein Hop über Gang.
CYPHER / Ein Hop
// Dieselbe Frage — als Graph
MATCH (p:Person) -[:ASSIGNED_TO]->
   (m:Mission {id: 47 }) -[:HAS_SLOT]-> (t:TimeSlot)
WHERE NOT (p) -[:ABSENT_ON]-> (t)
RETURN p.name
// Polymorphe Ressourcen: Person ODER Gang ODER Device
02 / Geschichte

15 Jahre Neo4j in Ruby:
die API-Evolution.

Sechs Produktionsprojekte. 2008 bis heute. Die Ruby-Bindings haben sich dreimal neu erfunden — von handgestrickter DSL bis zu ActiveRecord-naher Konvention.

2008 — dingdealer / roboterliebe
Vendored Neo4j, Rails 2.2.2, Ruby 1.8.x — mehrsprachiges Konzept-System
is_a_neo_node do
  property :name
  has_n(:items)
end
# localized_name(locale) traversiert direkt
2013–2014 — conegger
Neo4j::Rails::Model — JRuby, Immobilienverwaltung, Metadaten auf Kanten
class TraitValue < Neo4j::Rails::Relationship
  property :value, type: String
  property :unit
# Daten direkt auf der Kante
2015–2019 — dinghub
Neo4j::ActiveNode — Maker-Wissensnetz, semantische Relationen
include Neo4j::ActiveNode
has_many :out, :concepts,
  type: :instance_of,
  model_class: Concept
has_one :in, :owner,
  origin: :owns
2018–2022 — dispofox
ActiveGraph::Node — 79 Modelle, polymorphe Ressourcenplanung
include ActiveGraph::Node
has_many :out, :resources,
  model_class: [:Device, :Person, :Gang]
# Polymorphe Typen: ein Relationship-Typ,
# drei Ziel-Labels — kein STI-Hack

Die 6 Projekte im Überblick

dispofox (2018–2022) — Musterprojekt

Ressourcenplanung für Baustellenbetrieb. 79 Modelle, 57 Migrationen. Person ↔ Device ↔ Mission ↔ TimeSlot (als Linked List). Multi-Hop-Queries für Verfügbarkeit, polymorphe Buchungen, Blocking-Dependencies zwischen Missionen.

Rails 5.2 · ActiveGraph · Neo4j 3.5.28
railconnect (2018–2020) — Anti-Pattern

Prüfungsmanagement für Eisenbahnwagen. Neo4j + MongoDB gleichzeitig: Split-Brain-Architektur. VehicleReadinessControl referenziert MongoDB-Dokumente per String-ID — keine referentielle Integrität. Neo4j für simple 1:N-Beziehungen die SQL besser kann.

15 Modelle · eingestellt 2020
dinghub (2015–2019) — Maker-Wissensnetz

:instance_of / :has_property / :performs Relationen. Semantisches Web ohne RDF-Overhead. Custom Cypher-Node-Extensions direkt auf Query-Ergebnissen.

megorei · Neo4j::ActiveNode
conegger (2013), dingdealer (2008)

TraitValue als Relationship-Metadaten auf der Kante (conegger). Mehrsprachige Konzepte als Word-Nodes pro Sprache — localized_name(locale) traversiert direkt (dingdealer, 2008).

JRuby · Rails 2.2 · vendored Neo4j
03 / Deep Dive

dispofox:
79 Modelle, ein Graph.

Dispofox ist das Lehrbuch für legitimen Graph-Einsatz. 79 Modelle. 57 Migrationen zwischen 2018 und 2022. Das Herzstück: eine polymorphe Buchungsstruktur die SQL nicht elegant modellieren kann.

Eine Mission kann Person, Device oder Gang buchen — drei verschiedene Node-Typen hinter einem einzigen Relationship-Typ :ASSIGNED_TO. In SQL: Discriminator-Spalten, nullable Foreign Keys, oder drei Tabellen mit Union-Queries. Im Graph: ein Label-Array.

TimeSlots sind eine Linked List — jeder Slot zeigt auf den nächsten. Das erlaubt Traversal entlang der Zeitachse ohne Range-Queries auf Timestamps.

30+ Relationen an einem Person-Node.
In SQL wäre das ein Schema-Alptraum.

Node-Struktur: dispofox

:Person ─[:ASSIGNED_TO]─▶ :Mission
:Device ─────────────▶ :Mission
:Gang ─────────────▶ :Mission
:Mission ─[:HAS_SLOT]─▶ :TimeSlot
:TimeSlot ─[:NEXT]─────▶ :TimeSlot
:Person ─[:ABSENT_ON]─▶ :TimeSlot
Modelle total 79
Migrationen 57 (2018–2022)
Polymorphe Buchungstypen 3 (Person / Device / Gang)
TimeSlot-Struktur Linked List
Relationen an :Person 30+
Datenbankversion Neo4j 3.5.28 · ActiveGraph
04 / Query-Vergleich

Cypher vs. SQL:
konkrete Gegenüberstellung.

Nicht abstrakt. Drei echte Query-Szenarien aus Produktionsprojekten. Jeweils SQL und Cypher — damit der Unterschied greifbar wird.

Query 1 — Multi-Hop Verfügbarkeit (dispofox)
SQL — 4 JOINs
SELECT p.name, p.skill
FROM persons p
JOIN missions m ON m.site_id = 42
JOIN p_missions pm ON pm.person_id = p.id
JOIN time_slots ts ON ts.mission_id = m.id
LEFT JOIN absences a ON a.person_id = p.id
  AND a.slot_id = ts.id
WHERE a.id IS NULL
-- Gang/Device? Weitere UNION-Query.
Cypher — ein MATCH
MATCH (s:Site {id:42})
  <-[:AT_SITE]- (m:Mission)
  <-[:ASSIGNED_TO]- (r)
  -[:HAS_SLOT]-> (t:TimeSlot)
WHERE NOT (r) -[:ABSENT_ON]-> (t)
RETURN r.name, labels(r)
// r kann Person, Gang oder Device sein
Query 2 — Metadaten auf Kanten (conegger / TraitValue)
SQL — Junction-Tabelle
SELECT t.name, tv.value, tv.unit
FROM traits t
JOIN trait_values tv
  ON tv.trait_id = t.id
  AND tv.unit_id = 7
-- Extra Tabelle nur für Metadaten
Cypher — Daten auf der Kante
MATCH (u:Unit {id:7})
  -[tv:HAS_TRAIT]-> (t:Trait)
RETURN t.name, tv.value, tv.unit
// tv ist die Kante selbst — mit Attributen
Query 3 — Mehrsprachigkeit als Struktur (dingdealer, 2008)
SQL — i18n-Spalten oder Extra-Tabelle
SELECT ct.name
FROM concepts c
JOIN concept_translations ct
  ON ct.concept_id = c.id
  AND ct.locale = 'de'
WHERE c.id = 99
Cypher — Traversal zu Word-Node
MATCH (c:Concept {id:99})
  -[:LOCALIZED_AS]->
  (w:Word {locale: 'de'})
RETURN w.name
// Synonyme als weitere :SYNONYM_OF Kanten
05 / Anti-Patterns

Wann Graph
falsch ist.

railconnect ist das Gegenbeweis-Projekt. Prüfungsmanagement für Eisenbahnwagen. Neo4j plus MongoDB gleichzeitig — das klassische Split-Brain-Problem.

VehicleReadinessControl in Neo4j referenziert Wagons in MongoDB per String-ID. Keine referentielle Integrität. Wenn ein Wagon in MongoDB gelöscht wird, zeigt der Graph ins Leere. Zwei Datenbanken, zwei Konsistenzmodelle, null Garantien.

Das eigentliche Schema: Wagon → Company. 1:N. Das kann SQL in einer Zeile. Für diesen Use Case war Neo4j falsch gewählt — nicht weil Neo4j schlecht ist, sondern weil die Struktur es nicht braucht.

Neo4j + MongoDB = Split-Brain.
Zwei Quellen der Wahrheit sind keine.

Entscheidungsmatrix

Szenario Graph SQL
Multi-Hop Queries (3+ Hops) JA mühsam
Beziehungen tragen Daten JA Junction-Tabelle
Polymorphe Assoziationen JA STI / Discriminator
Variable Hierarchien JA Adjazenzlisten
Einfaches 1:N (Wagon→Company) Overkill JA
ACID-kritische Transaktionen begrenzt JA
Team kennt Cypher nicht Risiko JA
Zweite DB daneben (MongoDB) Split-Brain besser unified
06 / KI-Relevanz 2025/2026

GraphRAG + Agentic Memory:
Neo4j als Knowledge Layer.

Oktober 2025: Neo4j erhält $100M Investment in Agentic-AI-Infrastruktur. Das ist kein Pivot — das ist die Beschleunigung einer Entwicklung die seit Jahren läuft. Graphen sind nicht nur Speicher. Sie sind Reasoning-Schicht.

01 / GRAPHRAG
GraphRAG schlägt Vector-RAG

GraphRAG-Bench 2025 bestätigt: bei komplexen Reasoning-Aufgaben outperformt GraphRAG klassisches Vector-RAG. Vector-RAG findet ähnliche Textstellen. GraphRAG traversiert Beziehungen und begründet Antworten über mehrere Hops. LazyGraphRAG (Juni 2025) senkt Indexierungskosten — jetzt auch für Streaming-Daten sinnvoll.

02 / GRAPHITI
Temporales KG für Agenten

Graphiti (Zep, Open Source, Jan 2025): ein temporales Knowledge-Graph-Framework. Jede Tatsache hat ein Gültigkeitsfenster. "Peter ist CEO" galt bis Q3 2025. Danach "Maria ist CEO". Agenten lernen Veränderungen — nicht nur Fakten. Outperformt MemGPT auf Deep Memory Retrieval Benchmark.

03 / HNSW-VEKTOREN
Neo4j 2025.10: native Vektoren

VECTOR<FLOAT32>(1024) als First-Class-Datentyp. HNSW-Index (Hierarchical Navigable Small World) für Approximate Nearest Neighbor Search. Euklidische und Kosinus-Distanz. Neo4j ist jetzt nicht mehr "Graph-DB die auch Vektoren kann" — sondern vollwertige Hybrid-Datenbank: Graph + Vector in einer Query.

04 / ENTERPRISE
Merck, Finance, Supply Chain

Merck "Synaptix": Drug Repurposing auf Neo4j, verbindet Pre-Clinical mit Clinical mit Regulatory als Agentic GenAI. Finance: GNNs auf Neo4j — +200% Fraud-Detection bei gleicher False-Positive-Rate. Supply Chain: Agenten traversieren Lieferanten-Netzwerke, erkennen Engpässe in Echtzeit.

07 / Ruby + MCP

Die Brücke ohne Python.

Der ehrliche Stand: Python dominiert den KI-Stack. LangChain, LlamaIndex, GraphRAG-Frameworks — alles Python. Es gibt kein Ruby-Äquivalent für GraphCypherQAChain.

Aber seit Dezember 2024 existiert der offizielle Neo4j MCP Server. Model Context Protocol (Anthropic). Kein Code notwendig — der Agent fragt Neo4j per Cypher direkt via MCP. Sprachunabhängig. Funktioniert mit Aura, Self-Managed, Docker, Desktop.

Das bedeutet: ein Claude-Agent — der in Rails, in der Shell, in Claude Desktop läuft — kann direkt Cypher gegen eine Neo4j-Datenbank feuern. Ohne Python-Microservice als Bridge. Ohne LangChain-Adapter. Das Protokoll übernimmt die Brückenfunktion.

Ruby + MCP + Neo4j ist jetzt eine valide Production-Stack-Entscheidung. Nicht trotz fehlender Python-Bindings — weil MCP sie überflüssig macht.

MCP-Flow: Agent fragt Neo4j

01 Claude-Agent formuliert Intention: "Wer ist nächste Woche verfügbar für Site 12?"
02 MCP-Tool: neo4j_query — Agent generiert Cypher-Query basierend auf Schema-Kontext
03 Neo4j MCP Server führt Query aus, gibt strukturierte JSON-Ergebnisse zurück
04 Agent interpretiert Ergebnisse, schreibt ggf. neue Nodes / Edges zurück via neo4j_write
05 Kein Python. Kein Adapter. Rails-App bleibt Rails-App.
// Community MCP-Server-Varianten
neo4j-contrib/mcp-neo4j
— offiziell, Anthropic-MCP-kompatibel
mcp-neo4j-agent-memory
— Working/Episodic/Semantic Memory
mcp-neo4j-memory-server
— Graphiti-basiert, temporale Facts
// CVE-2024-8309: Prompt-Injection via Cypher
// in GraphCypherQAChain — in aktuellen
// Versionen mitigiert, aber beachten.
08 / Ruby-Synergien

Warum Ruby
und Neo4j passen.

Das ist kein Zufall. Ruby und Neo4j teilen eine Designphilosophie: Konvention vor Konfiguration, lesbare APIs, Metaprogrammierung als erstes Werkzeug.

  • has_many :out / :in — liest sich wie ActiveRecord, ist aber Graph-Traversal. define_method unter der Haube. Kein Umlernen.
  • model_class: [:Device, :Person, :Gang] — polymorphe Targets in einem Array. SQL braucht STI oder Union-Queries.
  • Callbacks funktionieren — before_save, after_create_commit, Validierungen — alles standard Rails-Konventionen.
  • Method Chaining für Cypher — .query_as(:m).where(...).pluck(:m) — fluent wie ActiveRecord-Scopes, gibt Cypher-Objekte zurück.
  • Labels aus Klassennamen — Person wird automatisch :Person-Label. Keine explizite Deklaration notwendig.

Inline-Graph: Agentic Knowledge Layer

NEO4J KG AGENT MCP MEMORY GRAPHRAG RAILS LLM
Die echten Pain Points
  • Alle Produktionsprojekte stecken auf Neo4j 3.5.x — Upgrade auf 5.x unklar
  • Monkey-Patching notwendig (dispofox: eigener neo4j_shrine_plugin.rb)
  • 30+ Relationen an einem Node: Testing und Onboarding komplex
  • Kein LangChain-Ruby-Binding — Python bleibt KI-Stack-Sprache
  • MCP schließt die Ruby-Lücke — aber Graphiti/GraphRAG brauchen Python
09 / Querverbindungen

Dieselbe Idee,
andere Domäne.

Graph-Infrastruktur ist kein isoliertes Werkzeug. Dieselben Patterns tauchen in anderen Kontexten auf — und die Verbindungen sind nicht zufällig.

agenten-in-labor

SPARQL auf dem Chemotion-Wissensgraphen ist dieselbe Idee wie Cypher auf Neo4j — semantisches Querying über strukturierte Beziehungen. Chemische Verbindungen, Reaktionen, Reagenzien: alles vernetzt. Der Agent traversiert den Graphen statt Text-Chunks zu suchen.

SPARQL ≈ Cypher — über Domänengrenzen
c3po-und-r2d2

MCP ist die R2-D2-Infrastruktur: das Protokoll das Agenten mit Werkzeugen verbindet ohne dass sie dieselbe Sprache sprechen müssen. Neo4j MCP Server ist R2-D2 für Graphen — Claude spricht MCP, Neo4j spricht Bolt, das Protokoll übersetzt.

MCP als universelle Brücke

Der Graph
denkt in Pfaden.

15 Jahre, 6 Projekte, eine Erkenntnis: Graph-Datenbanken lösen das richtige Problem wenn das Problem Beziehungen sind und nicht Zeilen. dispofox hat das bewiesen. railconnect hat gezeigt was passiert wenn man den Hammer falsch einsetzt. $100M in Oktober 2025 zeigen wohin die Reise geht: GraphRAG, Agentic Memory, temporale Knowledge Graphs. Ruby ist dabei — via MCP ohne Python-Umweg.

megorei — Juni 2026