> Einen Wissensgraphen mit LLMs bauen: kleine Ontologie, Extraktionsprompts, Entitätsauflösung, Herkunft, inkrementelle Updates, Evaluierung und Speicher.
>
> Web page: https://balazscsorba.com/de/blog/knowledge-graph-extraction-llm · Language: Deutsch · Also available in: [English](https://balazscsorba.com/blog/knowledge-graph-extraction-llm.md) · [Magyar](https://balazscsorba.com/hu/blog/knowledge-graph-extraction-llm.md)
> Author: Balázs Csorba · Published: 2026-09-25 · Updated: 2026-10-12 · Keywords: knowledge graph extraction with LLMs, GraphRAG indexing, entity resolution knowledge graph, triple extraction prompt, ontology design for LLM extraction, entity deduplication embeddings, knowledge graph provenance, incremental knowledge graph updates, GraphRAG cost, Neo4j SimpleKGPipeline

[Blog](https://balazscsorba.com/de/blog)/Retrieval & Suche

# Wissensgraphen mit LLMs extrahieren: Ontologie, Entitätsauflösung, Herkunft

Einen Wissensgraphen mit LLMs bauen: kleine Ontologie, Extraktionsprompts, Entitätsauflösung, Herkunft, inkrementelle Updates, Evaluierung und Speicher.

[Balázs Csorba](https://balazscsorba.com/de/about)·25\. September 2026·aktualisiert 12\. Oktober 2026·8 Min. Lesezeit

-   Knowledge graphs
-   GraphRAG
-   Entity resolution
-   RAG
-   Neo4j

![Knoten verlassen einen Seitenstapel und bilden ein Netz, in dem zwei Kreise verschmelzen.](https://balazscsorba.com/images/blog/knowledge-graph-extraction-llm/cover.webp?v=8a8d21666a)

## Das Wichtigste in Kürze

-   Einen Graphen mit einem LLM zu bauen heißt parsen, chunken, extrahieren, auflösen und laden; Ontologie und Entitätsauflösung entscheiden über die Qualität weit mehr als das Modell.
-   Das Schema bestimmt die Größe des Graphen: Auf einem Podcast-Korpus erzeugte der Standardprompt von GraphRAG 1.796 Entitäten, automatisch angepasste Prompts 4.896.
-   Die eingebaute Auflösung von GraphRAG ist ein exakter Abgleich von Titel und Typ; echte Korpora brauchen unscharfen oder Embedding-Abgleich plus LLM- oder menschliche Entscheidung für unsichere Paare.
-   Halten Sie an jedem Knoten und jeder Kante die Quelltexteinheit fest, damit Sie prüfen, löschen und nur Geändertes neu extrahieren können, statt den ganzen Graphen neu zu bauen.
-   Volles GraphRAG-Indexieren ist teuer: Microsoft beziffert das Indexieren von LazyGraphRAG auf 0,1 Prozent davon, also prüfen Sie, ob sich ein Graph lohnt, bevor Sie für die Extraktion zahlen.

Auf dieser Seite

1.  [Was der Aufbau braucht](https://balazscsorba.com/#what-it-takes-to-build-one)
2.  [Mit einer kleinen Ontologie beginnen](https://balazscsorba.com/#start-with-a-minimal-ontology)
3.  [Der Extraktionsschritt in der Praxis](https://balazscsorba.com/#the-extraction-step-in-practice)
4.  [Entitätsauflösung und Deduplizierung](https://balazscsorba.com/#entity-resolution-and-deduplication)
5.  [Herkunft und inkrementelle Updates](https://balazscsorba.com/#provenance-and-incremental-updates)
6.  [Was es kostet](https://balazscsorba.com/#cost)
7.  [Extraktionsqualität bewerten](https://balazscsorba.com/#evaluating-extraction-quality)
8.  [Speicherwahl](https://balazscsorba.com/#storage-choices)
9.  [Eine Checkliste für den Aufbau](https://balazscsorba.com/#a-build-checklist)
10.  [Quellen](https://balazscsorba.com/#sources)

Diesen Artikel anhören

0:000:00

**Wissensgraphen mit LLMs extrahieren** heißt, unstrukturierte Dokumente in Entitäten und typisierte Beziehungen zu verwandeln, die eine Graphabfrage oder ein GraphRAG-System nutzen kann. Der Extraktionsaufruf ist der leichte Teil; jedes fähige Modell liefert plausible Tripel. Ob der Graph nützlich ist, entscheidet alles darum herum: ein Schema, das klein genug zum Abfragen ist, eine Entitätsauflösung, die denselben Lieferanten in drei Schreibweisen zusammenführt, Herkunftsangaben, die jede Kante auf einen Satz zurückführen, und ein Kostenmodell, das eine erneute Extraktion übersteht.

Dieser Artikel behandelt die Aufbauseite: eine kleine Ontologie, den Extraktionsschritt, Entitätsauflösung, Herkunft und inkrementelle Updates, Evaluierung und Speicher. Ob Sie überhaupt einen Graphen statt Vektorsuche brauchen, diskutiert [GraphRAG gegen Vektor-RAG](https://balazscsorba.com/de/blog/graphrag-knowledge-graph-rag), und Microsofts Werkzeug bespricht [die GraphRAG-Besprechung](https://balazscsorba.com/de/blog/graphrag) vollständig. Versionen und Zahlen gelten Stand Oktober 2026.

## Was der Aufbau braucht

Jeder mit einem LLM gebaute Graph folgt derselben Pipeline: Dokumente parsen, in Texteinheiten teilen, pro Einheit Entitäten und Beziehungen extrahieren, Dubletten zusammenführen und auflösen und das Ergebnis laden. Der Standard-Datenfluss von Microsoft GraphRAG ist eine klare Referenz: Texteinheiten zu 1.200 Tokens, Extraktion pro Einheit, Zusammenführen von Entitäten mit identischem Titel und Typ, zusammengefasste Beschreibungen, optionale Extraktion von Behauptungen, dann Community-Erkennung und Berichte ([GraphRAG-Datenfluss](https://github.com/microsoft/graphrag/blob/main/docs/index/default_dataflow.md)). Jedes extrahierte Element verweist auf die Texteinheiten und liefert so „die Herkunft zurück zum ursprünglichen Quelltext“.

![Pipeline zum Aufbau eines Wissensgraphen Fünf Schritte von links nach rechts: Dokumente werden in Texteinheiten mit Herkunfts-ID geteilt; ein LLM extrahiert pro Einheit Entitäten und Beziehungen gegen ein festes Schema; extrahierte Elemente werden zusammengeführt und ihre Beschreibungen zusammengefasst; die Entitätsauflösung gleicht Dubletten ab, zuerst exakt, dann unscharf oder per Embedding, unsichere Paare entscheidet ein LLM oder ein Mensch; und der bereinigte Graph wird mit Quell-IDs an jedem Knoten und jeder Kante geladen.](https://balazscsorba.com/images/blog/knowledge-graph-extraction-llm/diagram-4.webp?v=3980bee16d)

Über die Qualität wird an zwei Stellen entschieden: beim Schema vor der Extraktion und bei der Entitätsauflösung vor dem Laden.

Zwei Schritte entscheiden über den Großteil der Qualität: die Ontologie, die festlegt, was extrahiert werden kann, und die Entitätsauflösung, die festlegt, ob das Ergebnis ein Graph ist oder ein Haufen beinahe doppelter Knoten. Das Extraktionsmodell zählt weniger als beide. GraphRAG selbst ist inzwischen weitgehend im Wartungsmodus; die README beschreibt es als Demonstration statt offiziell unterstütztes Angebot und warnt, dass Indexieren teuer sein kann ([GraphRAG](https://github.com/microsoft/graphrag)).

Ein Graph lohnt sich, wenn die Fragen Beziehungen betreffen statt Textstellen: welche Lieferanten nach einer bestimmten Norm zertifizierte Teile liefern, welche Verträge auf eine zurückgezogene Vorschrift verweisen, welche Werke ein Bauteil gemeinsam nutzen. Vektorsuche beantwortet „finde ähnlichen Text“; ein Graph beantwortet „folge diesen Verbindungen“. Stellen Ihre Nutzer überwiegend die erste Art von Frage, bringt der Extraktionsaufwand unten wenig.

## Mit einer kleinen Ontologie beginnen

Beginnen Sie mit den wenigen Entitäts- und Beziehungstypen, die Sie tatsächlich abfragen, denn das Schema bestimmt Größe und Nutzen des Graphen. Microsofts Beitrag zum Auto-Tuning zeigt, wie stark: Auf demselben Podcast-Korpus mit GPT-4-Turbo erzeugte der nachrichtenorientierte Standardprompt von GraphRAG 1.796 Entitäten, 2.851 Beziehungen und 352 Communities, auf die Domäne abgestimmte Prompts dagegen 4.896, 8.210 und 1.027 ([Auto-Tuning](https://www.microsoft.com/en-us/research/blog/graphrag-auto-tuning-provides-rapid-adaptation-to-new-domains/)). Mehr ist nicht automatisch besser; es ist nur besser, wenn die zusätzlichen Entitäten solche sind, die Ihre Fragen brauchen.

Das offizielle GraphRAG-Paket von Neo4j macht das Schema explizit: Knotentypen, Beziehungstypen und erlaubte Muster wie `("Supplier","SUPPLIES","Product")`. Mit `schema="EXTRACTED"`, dem Standard, leitet ein LLM einmal ein Schema aus dem Text ab und nutzt es für jeden Chunk; mit `schema="FREE"` gibt es gar keine Bindung ([Neo4j](https://neo4j.com/docs/neo4j-graphrag-python/current/user_guide_kg_builder.html)). Für die Produktion schreiben Sie das Schema selbst, halten es unter Versionskontrolle und behandeln eine Änderung als Migration. Mein Jira-MCP-Server folgt demselben Prinzip von der anderen Seite: Ein Modell mit einer kleinen, typisierten Oberfläche aus 20 Werkzeugen hört auf zu raten.

## Der Extraktionsschritt in der Praxis

Der Extraktionsschritt ist ein LLM-Aufruf pro Texteinheit, der Entitäten und Beziehungen in einem strukturierten Format liefert, manchmal gefolgt von zusätzlichen Durchläufen für das, was der erste übersehen hat. Nutzen Sie strukturierte Ausgabe, wo der Anbieter sie unterstützt: Die Neo4j-Pipeline prüft Ergebnisse gegen ein Pydantic-Graphmodell, wenn das Modell strukturierte Ausgabe bietet, statt JSON nachträglich zu reparieren, und ihr Graph-Pruner verwirft Knoten und Beziehungen, die das Schema verletzen oder keine Eigenschaften haben ([Neo4j](https://neo4j.com/docs/neo4j-graphrag-python/current/user_guide_kg_builder.html)).

Die Bindung an den Quelltext ist die zweite Absicherung. Googles LangExtract ordnet jede Extraktion ihrer genauen Zeichenspanne im Quelltext zu, und eine Extraktion, die das Modell in der Eingabe nicht finden kann, erhält kein Zeichenintervall und soll verworfen werden ([LangExtract](https://github.com/google/langextract)). Diese eine Regel entfernt die meisten erfundenen Beziehungen. Dasselbe Muster gilt für Produktdaten, wo ein Wert ohne Quellspanne nicht in den Katalog gelangen sollte, siehe [Produktdatenanreicherung mit LLMs](https://balazscsorba.com/de/blog/llm-product-data-enrichment).

Die Chunk-Größe zählt mehr, als es aussieht. Kleinere Einheiten geben dem Modell pro Aufruf weniger zu lesen und erhöhen tendenziell den Recall von Entitäten, trennen aber Beziehungen, deren beide Enden in verschiedenen Absätzen stehen; größere Einheiten halten diese zusammen und kosten pro Aufruf mehr. Der GraphRAG-Standard von 1.200 Tokens ist ein vernünftiger Start; passen Sie ihn erst an, nachdem Sie in einer Stichprobe Ihrer Dokumente gemessen haben, wie viele Beziehungen Einheitsgrenzen überschreiten.

```
# Sketch with neo4j-graphrag: fixed schema, extraction, then resolution limited to new entities
from neo4j_graphrag.experimental.pipeline.kg_builder import SimpleKGPipeline
from neo4j_graphrag.experimental.components.resolver import SinglePropertyExactMatchResolver

schema = {
    "node_types": ["Supplier", "Product", "Standard", "Plant"],
    "relationship_types": ["SUPPLIES", "COMPLIES_WITH", "PRODUCED_AT"],
    "patterns": [("Supplier", "SUPPLIES", "Product"),
                 ("Product", "COMPLIES_WITH", "Standard"),
                 ("Product", "PRODUCED_AT", "Plant")],
}
pipeline = SimpleKGPipeline(llm=llm, driver=driver, embedder=embedder, schema=schema, from_pdf=False)
await pipeline.run_async(text=document_text)            # chunks keep their ids in the lexical graph

resolver = SinglePropertyExactMatchResolver(driver, filter_query="WHERE NOT entity:Resolved")
await resolver.run()                                    # only touches entities from this run
```

## Entitätsauflösung und Deduplizierung

Die Entitätsauflösung entscheidet, ob „Siemens AG“, „Siemens“ und „der Münchner Lieferant“ ein Knoten werden oder drei. Die eingebaute Logik von GraphRAG führt nur Entitäten mit identischem Titel und Typ zusammen ([GraphRAG-Datenfluss](https://github.com/microsoft/graphrag/blob/main/docs/index/default_dataflow.md)), was für eine Demo genügt und für echte Korpora nicht. Das Paket von Neo4j bietet drei Resolver: exakten Abgleich auf einer Eigenschaft, semantischen Abgleich mit spaCy-Embeddings und Kosinusähnlichkeit sowie unscharfen Abgleich mit RapidFuzz, schneller und weniger präzise ([Neo4j](https://neo4j.com/docs/neo4j-graphrag-python/current/user_guide_kg_builder.html)).

Am besten funktioniert ein Stufenansatz: exakte Treffer automatisch zusammenführen, unscharfe und Embedding-Treffer über einer Schwelle vorschlagen und das unsichere Mittelfeld mit dem Kontext beider Kandidaten an ein LLM oder einen Menschen geben. Für Entitäten mit mehreren strukturierten Feldern ist die probabilistische Datensatzverknüpfung von Splink ausgereift und verknüpft etwa eine Million Datensätze auf einem Laptop in rund einer Minute, aber die README hält fest, dass sie nicht für eine einzelne Spalte mit einem „Bag of Words“ gedacht ist, Entitätsknoten nur mit Namen liegen also außerhalb ihrer Stärke ([Splink](https://github.com/moj-analytical-services/splink)). Dasselbe Abgleichproblem tritt in Produktkatalogen auf, siehe [PIM-Datenqualität mit LLMs](https://balazscsorba.com/de/blog/pim-data-quality-llm).

Blocking hält die Auflösung bezahlbar. Jede Entität mit jeder anderen zu vergleichen wächst quadratisch, gruppieren Sie Kandidaten also zuerst nach einem günstigen Schlüssel wie Entitätstyp plus normalisiertem Namenspräfix oder nach nächsten Nachbarn im Embedding-Raum und vergleichen Sie nur innerhalb dieser Gruppen. Legen Sie die Schwelle dann an einer gelabelten Stichprobe von Paaren fest statt nach Gefühl, denn der richtige Schnitt ist für Firmennamen, Produktcodes und Personen verschieden.

**Resolver ersetzen Knoten**

Die Resolver von Neo4j ersetzen die von der Pipeline geschriebenen Knoten, Auflösung ist also kein reiner Leseschritt. Führen Sie sie wiederholbar aus: aufgelöste Entitäten markieren, eine Filterabfrage wie `WHERE NOT entity:Resolved` übergeben, damit Wiederholungen nur neue berühren, und die ursprünglichen Erwähnungen mit ihren Texteinheiten behalten, damit eine falsche Zusammenführung rückgängig gemacht werden kann.

## Herkunft und inkrementelle Updates

Herkunftsangaben sind das Rückgrat, das einen Graphen wartbar macht. Halten Sie Texteinheits-ID und Dokument-ID an jedem Knoten und jeder Kante fest, damit eine Antwort ihren Satz zitieren, ein gelöschtes Dokument genau seine Beiträge entfernen und ein geändertes Dokument neu extrahiert werden kann, ohne den Rest zu berühren. Die Texteinheiten von GraphRAG und der lexikalische Graph von Neo4j, der Chunks mit den daraus extrahierten Entitäten verbindet, liefern beide diese Struktur.

Einen dokumentierten inkrementellen Indexiermodus konnte ich in der aktuellen GraphRAG-Doku nicht bestätigen; dokumentiert ist, einen eigenen Graphen mitzubringen und darauf nur die Community-Workflows auszuführen ([BYOG](https://github.com/microsoft/graphrag/blob/main/docs/index/byog.md)). In der Praxis heißt inkrementell, nur neue oder geänderte Dokumente zu extrahieren und ihre Entitäten gegen den bestehenden Graphen aufzulösen. Graphen, die Fakten über die Zeit verfolgen, ergänzen pro Kante ein Gültigkeitsfenster; Zeps Engine Graphiti pflegt historische Beziehungen auf diese Weise für Agenten-Gedächtnis ([Zep-Paper](https://arxiv.org/abs/2501.13956)), beschrieben in [der Zep-Besprechung](https://balazscsorba.com/de/blog/zep).

Neuextraktion ist der Kostenpunkt, den man einplanen muss. Eine Änderung am Schema oder am Extraktionsprompt entwertet jedes unter dem alten erzeugte Tripel; versionieren Sie Prompts also wie Code, halten Sie die Prompt-Version an jedem extrahierten Element fest und planen Sie eine vollständige Neuextraktion als Migration statt als Überraschung.

## Was es kostet

Microsoft veröffentlicht für GraphRAG keinen absoluten Preis pro Dokument, nur relative Zahlen, und die sind groß. LazyGraphRAG-Indexieren kostet etwa so viel wie Vektor-RAG und 0,1 Prozent des vollen GraphRAG-Indexierens, und LazyGraphRAG-Abfragen kosten bei vergleichbarer Qualität mehr als 700-mal weniger als die globale Suche von GraphRAG ([LazyGraphRAG](https://www.microsoft.com/en-us/research/blog/lazygraphrag-setting-a-new-standard-for-quality-and-cost/)). Die praktische Regel: eine repräsentative Stichprobe extrahieren, Tokens pro Dokument selbst messen und hochrechnen, bevor Sie sich auf den ganzen Korpus festlegen.

![Relative Kosten für Aufbau und Abfrage eines Graphen Vier horizontale Balken relativ zum Indexieren mit LazyGraphRAG. Vektor-RAG-Indexieren kostet etwa so viel wie LazyGraphRAG-Indexieren, dargestellt als eine Einheit. Volles GraphRAG-Indexieren kostet etwa das Tausendfache, da LazyGraphRAG 0,1 Prozent davon ist. Auf der Abfrageseite kostet die globale Suche von GraphRAG mehr als das 700-Fache einer LazyGraphRAG-Abfrage vergleichbarer Qualität. Ein Hinweis besagt, dass ein Prompt- oder Schemawechsel die Extraktionskosten erneut fällig macht.](https://balazscsorba.com/images/blog/knowledge-graph-extraction-llm/diagram-26.webp?v=ed5799926b)

Relative Kosten aus Microsofts Beitrag zu LazyGraphRAG, logarithmisch dargestellt; ein absoluter Preis pro Dokument ist nicht veröffentlicht.

## Extraktionsqualität bewerten

Extraktionsqualität ist ein offenes Forschungsproblem, kein gelöstes. Die Autoren von KGGen halten fest, dass automatisch extrahierte Graphen von fragwürdiger Qualität sind und menschlich erstellte Vergleichsgraphen selten; sie ergänzen Entitäts-Clustering gegen dünn besetzte Graphen und veröffentlichen den Benchmark MINE für die Extraktion von Text zu Graph ([KGGen](https://arxiv.org/abs/2502.09956)). GraphEval stellt Inhalte als Tripel dar, um wahrscheinliche Halluzinationen auf Tripelebene zu finden ([GraphEval](https://arxiv.org/abs/2407.10793)).

Für den eigenen Graphen funktioniert ein einfaches Protokoll: pro Lauf 50 Tripel ziehen, von einem Menschen jeweils als richtig, falsch oder nicht durch die Quellspanne gedeckt markieren lassen und diese Präzision über Prompt- und Schemaversionen verfolgen. Ein LLM-Richter kann vorsortieren, aber kalibrieren Sie ihn zuerst gegen die menschlichen Labels. Protokollieren Sie pro Lauf die Zahl der Entitäten, Beziehungen, Zusammenführungen, verworfenen ungedeckten Tripel und die Prompt-Version, damit ein plötzlicher Sprung sichtbar wird.

Bewerten Sie den Graphen auch an den Fragen, für die er existiert. Schreiben Sie zehn bis zwanzig Beziehungsfragen mit bekannten Antworten, führen Sie sie nach jedem Neuaufbau über Ihre Graphabfragen oder die GraphRAG-Suche aus und vergleichen Sie. Die Tripelpräzision zeigt, ob die Extraktion stimmt; die Genauigkeit bei den Fragen zeigt, ob Schema und Auflösung einen Graphen erzeugt haben, der beantworten kann, wofür Sie ihn gebaut haben.

## Speicherwahl

Komponente

Rolle

Lizenz

Herkunft

Entitätsauflösung

Microsoft GraphRAG 3.3

volle Pipeline, Wartungsmodus

MIT

Texteinheiten

exakt Titel und Typ

neo4j-graphrag

modularer KG-Builder

Apache-2.0

lexikalischer Graph

exakt, spaCy-semantisch, unscharf

LangExtract

gebundene Extraktion

Apache-2.0

Zeichenspannen

keine eingebaut

Splink

Datensatzverknüpfung

MIT

k. A.

probabilistisch, mehrere Felder

Neo4j, Kùzu, NetworkX

Graphspeicher

unterschiedlich; Kùzu archiviert

als Eigenschaften

über Ihre Pipeline

Beim Speicher ist Neo4j die übliche Serverwahl und das Ziel des offiziellen GraphRAG-Pakets. Kùzu, eine MIT-lizenzierte eingebettete Graphdatenbank, die für lokale Pipelines attraktiv war, wurde archiviert, und die README kündigt an, dass das Team an etwas Neuem arbeitet ([Kùzu](https://github.com/kuzudb/kuzu)), beginnen Sie darauf also nichts Neues. Für kleine Graphen oder Experimente reicht NetworkX im Speicher mit Parquet-Dateien auf der Platte, und GraphRAG selbst schreibt Parquet-Tabellen, die sich in jedes davon laden lassen.

Welchen Speicher Sie auch wählen, halten Sie die extrahierten Entitäten und Beziehungen als einfache Dateien daneben, mit Prompt-Version und Quell-IDs. Dieser Export erlaubt es, den Speicher neu aufzubauen, die Engine zu wechseln oder die Auflösung erneut auszuführen, ohne die Extraktion noch einmal zu bezahlen.

## Eine Checkliste für den Aufbau

1.  Ein kleines Schema aus den Fragen schreiben, die Sie stellen werden, und versionieren.
2.  Extraktionsprompts wie Code versionieren und die Version an jedem Element festhalten.
3.  Strukturierte Ausgabe nutzen und Tripel ohne Quellspanne verwerfen.
4.  Entitäten stufenweise auflösen und die ursprünglichen Erwähnungen behalten.
5.  Texteinheits- und Dokument-IDs an jedem Knoten und jeder Kante halten.
6.  Präzision an 50 gezogenen Tripeln pro Lauf messen.
7.  Extraktion an einer Stichprobe bepreisen, bevor der ganze Korpus indexiert wird.
8.  Nur neue oder geänderte Dokumente extrahieren und gegen den bestehenden Graphen auflösen.

Wenn Sie einen Wissensgraphen aus Dokumenten aufbauen und er auch nach der ersten Demo sauber bleiben soll, sehen Sie sich meine [KI-Engineering-Arbeit](https://balazscsorba.com/de/expertise/ai-engineer) an.

## Quellen

1.  [Microsoft GraphRAG: default dataflow](https://github.com/microsoft/graphrag/blob/main/docs/index/default_dataflow.md)
2.  [Microsoft GraphRAG on GitHub](https://github.com/microsoft/graphrag)
3.  [Microsoft Research: LazyGraphRAG (Nov 2024)](https://www.microsoft.com/en-us/research/blog/lazygraphrag-setting-a-new-standard-for-quality-and-cost/)
4.  [Microsoft Research: GraphRAG auto-tuning (Sep 2024)](https://www.microsoft.com/en-us/research/blog/graphrag-auto-tuning-provides-rapid-adaptation-to-new-domains/)
5.  [neo4j-graphrag-python on GitHub](https://github.com/neo4j/neo4j-graphrag-python)
6.  [Neo4j GraphRAG: knowledge graph builder guide](https://neo4j.com/docs/neo4j-graphrag-python/current/user_guide_kg_builder.html)
7.  [Splink on GitHub](https://github.com/moj-analytical-services/splink)
8.  [Google LangExtract on GitHub](https://github.com/google/langextract)
9.  [KGGen (arXiv 2502.09956)](https://arxiv.org/abs/2502.09956)
10.  [GraphEval (arXiv 2407.10793)](https://arxiv.org/abs/2407.10793)
11.  [Zep temporal knowledge graph (arXiv 2501.13956)](https://arxiv.org/abs/2501.13956)
12.  [Kùzu on GitHub](https://github.com/kuzudb/kuzu)

## Häufige Fragen

Wie baut man einen Wissensgraphen mit einem LLM?

Teilen Sie Dokumente in Texteinheiten, lassen Sie ein LLM aus jeder Einheit Entitäten und Beziehungen gegen ein festgelegtes Schema extrahieren, führen Sie die Entitäten zusammen und deduplizieren Sie sie, und laden Sie das Ergebnis in einen Graphspeicher, mit einem Verweis von jedem Knoten und jeder Kante auf den Quelltext. Schema und Deduplizierung entscheiden den Großteil der Qualität.

Was ist Entitätsauflösung in einem Wissensgraphen?

Die Entscheidung, welche extrahierten Erwähnungen dieselbe reale Entität meinen, etwa „Siemens AG“, „Siemens“ und „der Münchner Lieferant“. Die Optionen reichen vom exakten Namensabgleich über unscharfe und Embedding-Ähnlichkeit bis zur Entscheidung unsicherer Paare durch ein LLM oder einen Menschen. Ohne sie füllt sich der Graph mit doppelten Knoten.

Was kostet das Indexieren mit GraphRAG?

Microsoft nennt keinen absoluten Preis, nur relative Zahlen: Das Indexieren mit LazyGraphRAG kostet etwa so viel wie Vektor-RAG und 0,1 Prozent des vollen GraphRAG-Indexierens. Volles Indexieren macht mehrere LLM-Aufrufe pro Texteinheit, messen Sie es also an einer Stichprobe Ihres Korpus, bevor Sie alles indexieren.

Sollte das LLM das Schema selbst erfinden?

Beginnen Sie mit einer kleinen, festen Ontologie der Entitäts- und Beziehungstypen, die Sie tatsächlich abfragen, und lassen Sie das LLM sie füllen. Freie Extraktion erzeugt viele Typen und beinahe doppelte Beziehungen, die schwer abzufragen sind. Die Neo4j-Pipeline kann ein Schema einmal aus dem Text ableiten und dann für jeden Chunk wiederverwenden.

Wie hält man einen Wissensgraphen aktuell?

Speichern Sie Quelltexteinheit und Dokument-ID an jedem Knoten und jeder Kante, extrahieren Sie nur neue oder geänderte Dokumente und lösen Sie neue Entitäten gegen den bestehenden Graphen auf, statt ihn neu zu bauen. Die Resolver von Neo4j akzeptieren eine Filterabfrage, sodass Wiederholungen nur nicht aufgelöste Entitäten berühren.

Geschrieben von Balázs Csorba

Senior Fullstack & AI Engineer in der Steiermark – über 10 Jahre Vue, Nuxt, Node.js und PHP, heute baue ich Werkzeuge für KI-Agenten.

[KI-Entwicklung & MCP-Server →](https://balazscsorba.com/de/expertise/ai-engineer)[Über mich →](https://balazscsorba.com/de/about)

## Weitere Artikel

-   [Embedding-Modell wählen 2026: Leaderboards, Kosten und ein Vergleichstest mit eigenen Daten](https://balazscsorba.com/de/blog/embedding-model-selection-2026)
-   [Contextual Retrieval und Late Chunking: RAG-Chunks ihren Kontext zurückgeben](https://balazscsorba.com/de/blog/contextual-retrieval-late-chunking)
-   [Zugriffskontrolle für RAG: berechtigungsbewusstes Retrieval ohne Datenlecks](https://balazscsorba.com/de/blog/rag-access-control-permissions)
-   [RAG über Produktkataloge: aus PIM-Daten Antworten machen, die halten](https://balazscsorba.com/de/blog/rag-product-catalog-pim-data)

## Klingt nach dem, was du suchst?

Erzähl mir von deinem Projekt oder deiner Stelle – ich freue mich, von dir zu hören.

[Kontakt aufnehmen](mailto:contact@balazscsorba.com) [Auf LinkedIn vernetzen](https://www.linkedin.com/in/balazs-csorba)