Verwandle jede Sammlung von Dokumenten in einen Wissensgraphen. Extrahiere Entitäten und Beziehungen mittels LLM, dedupliziere mit deiner Zustimmung. Kartiere Domänen, finde versteckte Verbindungen, entdecke Muster über Dokumente hinweg — Wissen, das bestehen bleibt und sich vermehrt, für dich und deine KI-Agenten. Alles von der CLI.
Verwandle jede Sammlung von Dokumenten in einen Wissensgraphen.
Kein Code, keine Datenbank, keine Infrastruktur — nur eine CLI und deine Dokumente. Wirf PDFs, Papiere, Artikel oder Aufzeichnungen hinein — erhalte einen durchsuchbaren Wissensgraphen, der zeigt, wie alles zusammenhängt, in Minuten. sift-kg extrahiert Entitäten und Beziehungen mittels LLM, dedupliziert mit deiner Zustimmung und generiert einen interaktiven Betrachter, den du in deinem Browser erkunden kannst. Konzeptkarten für alles, direkt zur Hand.
Derselbe Graph, der deine Visualisierungen antreibt, funktioniert auch als AI Zweites Gehirn. Jeder verbringt Monate damit, Wissensdatenbanken in Notion und Obsidian aufzubauen. Wer hat Zeit dafür? sift-kg ist der strukturierte Speicher, den du in 2 Minuten statt in 2 Jahren aufbaust. Zeige einfach auf deine Dokumente und deine KI hat ein strukturiertes Verständnis davon, wie alles zusammenhängt.
Live-Demos → Graphen, vollständig von sift-kg generiert```bash pip install sift-kg
sift init # create sift.yaml + .env.example sift extract ./documents/ # extract entities & relations sift build # build knowledge graph sift resolve # find duplicate entities sift review # approve/reject merges interactively sift apply-merges # apply your decisions sift narrate # generate narrative summary sift view # interactive graph in your browser sift export graphml # export to Gephi, yEd, Cytoscape, SQLite, etc.
## Wie es funktioniert```
Documents (PDF, DOCX, text, HTML, and 75+ formats)
↓
Text Extraction (Kreuzberg, local) — with optional OCR (Tesseract, EasyOCR, PaddleOCR, or Google Cloud Vision)
↓
Schema Discovery (LLM designs entity/relation types from your data — or use a predefined domain)
↓
Entity & Relation Extraction (LLM, using discovered or predefined schema)
↓
Knowledge Graph (NetworkX, JSON)
↓
Entity Resolution (LLM proposes → you review)
↓
Narrative Generation (LLM)
↓
Interactive Viewer (browser) / Export (GraphML, GEXF, CSV, SQLite)
Jede Entität und Beziehung verweist zurück auf das Quelldokument und die Passage. Sie kontrollieren, was zusammengeführt wird. Der Graph gehört Ihnen.
sift.yaml in Ihrem Projekt ab, um dauerhafte Einstellungen zu speicherndiscovered_domain.yaml zur Wiederverwendung und Bearbeitung gespeichert wird. Oder verwenden Sie eine strukturierte Domain (general, osint, academic) für feste Schemata oder definieren Sie Ihr eigenes in YAMLsift search "SBF" findet Entitäten nach Namen oder Alias, mit optionaler Ausgabe von Beziehungen und Beschreibungen--neighborhood, --top, , , sift-kg generiert strukturiertes Wissen, von dem KI-Agenten direkt ausgehen können.
Richten Sie sift auf Ihre Dokumente, Notizen oder Projektdateien. Die Ausgabe — ein JSON-Wissensgraph — gibt jedem KI-Agenten ein dauerhaftes, strukturiertes Verständnis davon, wie alles in Ihrer Welt zusammenhängt. Keine manuelle Organisation, kein Tagging, keine Wiki-Links. Die Struktur entsteht aus dem Inhalt.```bash sift extract ./my-stuff/ sift build sift topology # structural overview (JSON, for agents) sift query "topic" # entity neighborhood subgraph (JSON, for agents) sift search "X" --json # entity lookup (JSON, for agents) sift info --json # project stats (JSON, for agents)
Der Graph bleibt über Sitzungen hinweg bestehen und wächst inkrementell — extrahieren Sie neue Dokumente in dasselbe Ausgabeverzeichnis und bauen Sie neu auf. Die Entitätsdeduplizierung stellt sicher, dass der Graph beim Wachsen kohärent bleibt.
**Was dies Ihrem Agenten gibt:**
- **Struktur** — nicht nur Textabschnitte, sondern Entitäten, Beziehungen, Communities und wie sie verbunden sind
- **Topologie** — welche Wissenscluster existieren, was sie verbindet, was isoliert ist
- **Beständigkeit** — der Graph übersteht Kontextfenster-Resets. Ihr Agent beginnt nicht mehr jede Sitzung von Null
**Mitgelieferte Agenten-Fähigkeit:** sift-kg wird mit einer Fähigkeit unter `.agents/skills/sift-kg/SKILL.md` ausgeliefert, die Agenten beibringt, wie sie den Wissensgraphen als persistenten Speicher nutzen – Sitzungsorientierung, Entitätserkundung, Verknüpfung von Wissensinseln und logisches Denken sowie fundierte Vorschlagserstellung.
## Bundled Domains
sift-kg wird mit spezialisierten Domänen ausgeliefert, die Sie sofort nutzen können:```bash
sift domains # list available domains
sift extract ./docs/ --domain-name osint # use a bundled domain
Setzen Sie eine Domain in sift.yaml fest, damit Sie das Flag nicht jedes Mal benötigen:```yaml
domain: academic
Funktioniert mit gebündelten Namen (`schema-free`, `general`, `osint`, `academic`) oder einem Pfad zu einer benutzerdefinierten YAML-Datei.
| Bereich | Schwerpunkt | Wichtige Entitätstypen | Wichtige Beziehungstypen |
|--------|-------|------------------|--------------------|
| `schema-free` | Automatisch aus Ihren Daten ermittelt (Standard) | *(LLM entwirft pro Korpus)* | *(LLM entwirft pro Korpus)* |
| `general` | Allgemeine Dokumentenanalyse | PERSON, ORGANIZATION, LOCATION, EVENT, DOCUMENT | ASSOCIATED_WITH, MEMBER_OF, LOCATED_IN |
| `osint` | Ermittlungen & FOIA | SHELL_COMPANY, FINANCIAL_ACCOUNT | BENEFICIAL_OWNER_OF, TRANSACTED_WITH, SIGNATORY_OF |
| `academic` | Literaturübersicht & Themenkartierung | CONCEPT, THEORY, METHOD, SYSTEM, FINDING, PHENOMENON, RESEARCHER, PUBLICATION, FIELD, DATASET | SUPPORTS, CONTRADICTS, EXTENDS, IMPLEMENTS, EXPLAINS, PROPOSED_BY, USES_METHOD, APPLIED_TO, INVESTIGATES |
Die **academic**-Domäne kartiert die intellektuelle Landschaft eines Forschungsbereichs — geben Sie Artikel ein und erhalten Sie einen Graphen, wie Theorien, Methoden, Systeme, Ergebnisse und Konzepte verbunden sind. Sie unterscheidet abstrakte Ideen (THEORY, METHOD) von konkreten Artefakten (SYSTEM — z. B. GPT-2, BERT, GLUE). Entwickelt für Literaturübersichten, Themenkartierung und das Verständnis, wo Ideen übereinstimmen, widersprechen oder aufeinander aufbauen.
Die **schema-free**-Domäne (Standard) führt vor der Extraktion einen **Schema-Discovery**-Schritt durch — ein LLM-Aufruf mustert Ihre Dokumente und entwirft Entitäts- und Beziehungstypen, die auf das Korpus zugeschnitten sind. Das entdeckte Schema wird unter `output/discovered_domain.yaml` gespeichert und bei nachfolgenden Läufen wiederverwendet, sodass die Typen über alle Blöcke und Dokumente hinweg konsistent bleiben. Sie können die Datei einsehen, von Hand bearbeiten oder als Ausgangspunkt für eine benutzerdefinierte Domäne kopieren. Verwenden Sie `--force`, um neu zu entdecken. Anstatt Beziehungen in vordefinierte Kategorien wie ASSOCIATED_WITH zu zwingen, erzeugt es spezifische Typen wie FUNDED, TESTIFIED_AGAINST oder ENROLLED_AT. Verwenden Sie eine strukturierte Domäne wie `general` oder `osint`, wenn Sie ein festes, von Ihnen vorab definiertes Schema wünschen.
Die **general**-Domäne bietet ein festes Schema mit den Entitätstypen PERSON, ORGANIZATION, LOCATION, EVENT und DOCUMENT sowie allgemeine Beziehungstypen. Nützlich, wenn Sie vorhersagbare, konsistente Typen über Dokumente hinweg wünschen.
Die **osint**-Domäne fügt Entitätstypen für Briefkastenfirmen, Finanzkonten und Offshore-Gerichtsbarkeiten sowie Beziehungstypen zur Verfolgung von wirtschaftlichem Eigentum und Finanzströmen hinzu.
Nichts wird ohne Ihre Zustimmung zusammengeführt — der LLM schlägt vor, Sie prüfen. Jede Extraktion verweist auf das Quellendokument und die Passage zurück.
Siehe [`examples/transformers/`](https://github.com/juanceresa/sift-kg/blob/HEAD/examples/transformers/) für 12 grundlegende KI-Papiere, die als Konzeptgraph abgebildet sind (425 Entitäten, ~$0.72), und [`examples/ftx/`](https://github.com/juanceresa/sift-kg/blob/HEAD/examples/ftx/) für den FTX-Zusammenbruch (431 Entitäten aus 9 Artikeln). [**Erkunden Sie die Live-Demos**](https://juanceresa.github.io/sift-kg/) — keine Installation, kein API-Schlüssel.
## Civic Table
Suchen Sie nach einer gehosteten Plattform mit forensischer Rechtsanalyse und Analystenverifizierung?
[**Civic Table**](https://github.com/juanceresa/forensic_analysis_platform) ist eine forensische Intelligence-Plattform, die auf der sift-kg-Pipeline aufbaut. Sie fügt ein 4-stufiges Verifikationssystem hinzu, bei dem Analysten und JDs KI-extrahierte Fakten validieren, bevor sie als Beweismittel behandelt werden, LaTeX-Dossier-Generierung für rechtliche Einreichungen und eine Weboberfläche zum Teilen von Ergebnissen mit Mandanten und Familien. Entwickelt für Eigentumsrückgabe, investigativen Journalismus und alle Kontexte, in denen die Herkunft von Dokumenten wichtig ist.
sift-kg ist die Open-Source-CLI. Civic Table ist die vollständige Plattform — und dort wird die Ausgabe von Analysten und JDs geprüft, bevor sie Beweisgewicht erhält.
## Installation
Erfordert Python 3.11+.```bash
pip install sift-kg
Für OCR-Unterstützung (gescannte PDFs, Bilder):```bash
brew install tesseract # macOS sudo apt install tesseract-ocr # Ubuntu/Debian
Für Google Cloud Vision OCR als alternatives Backend (optional):```bash
pip install sift-kg[ocr]
# Then use: sift extract ./docs/ --ocr --ocr-backend gcv
Für semantisches Clustering während der Entitätsauflösung (optional, ~2GB für PyTorch):```bash pip install sift-kg[embeddings]
Für die Entwicklung:```bash
git clone https://github.com/juanceresa/sift-kg.git
cd sift-kg
pip install -e ".[dev]"
sift init # creates sift.yaml + .env.example cp .env.example .env # copy and add your API key
`sift init` generiert eine `sift.yaml`-Projektkonfiguration, so dass man nicht bei jedem Befehl Flags benötigt:```yaml
# sift.yaml
domain: domain.yaml # or a bundled name like "osint"
model: openai/gpt-4o-mini
ocr: true # enable OCR for scanned PDFs
# extraction:
# backend: kreuzberg # kreuzberg (default, 75+ formats) | pdfplumber
# ocr_backend: tesseract # tesseract | easyocr | paddleocr | gcv
# ocr_language: eng
Setzen Sie Ihren API-Schlüssel in .env:```
SIFT_OPENAI_API_KEY=sk-...
Oder verwenden Sie Anthropic, Mistral, Ollama oder einen beliebigen LiteLLM-Anbieter:```
SIFT_ANTHROPIC_API_KEY=sk-ant-...
SIFT_MISTRAL_API_KEY=...
Settings priority: CLI flags > Umgebungsvariablen > .env > sift.yaml > Standardwerte. Sie können alles aus der sift.yaml mit einem Flag in einem beliebigen Befehl überschreiben.
sift extract ./my-documents/ sift extract ./my-documents/ --ocr # local OCR via Tesseract sift extract ./my-documents/ --ocr --ocr-backend gcv # Google Cloud Vision OCR sift extract ./my-documents/ --extractor pdfplumber # legacy pdfplumber backend
Liest 75+ Dokumentformate — PDFs, DOCX, XLSX, PPTX, HTML, EPUB, Bilder und mehr. Extrahiert Entitäten und Relationen mithilfe Ihres konfigurierten LLM. Ergebnisse werden als JSON in `output/extractions/` gespeichert.
Das Flag `--ocr` aktiviert lokale Texterkennung per Tesseract für gescannte PDFs – keine API-Schlüssel oder Cloud-Dienste erforderlich. Sie können die OCR-Engine mit `--ocr-backend` wechseln:```bash
sift extract ./docs/ --ocr # Tesseract (default, local)
sift extract ./docs/ --ocr --ocr-backend easyocr # EasyOCR (local)
sift extract ./docs/ --ocr --ocr-backend paddleocr # PaddleOCR (local)
sift extract ./docs/ --ocr --ocr-backend gcv # Google Cloud Vision (requires credentials)
Es erkennt automatisch, welche PDFs OCR benötigen – textreiche PDFs verwenden die Standardextraktion, nur nahezu leere Seiten greifen auf OCR zurück. Sicher für gemischte Ordner. Ohne --ocr gibt sift eine Warnung aus, wenn ein PDF gescannt zu sein scheint.
Sie können die Extraktions-Backend auch vollständig mit --extractor pdfplumber auf das alte pdfplumber-Backend umstellen (nur PDF/DOCX/TXT/HTML).
sift build
Erstellt einen NetworkX-Graphen aus allen Extraktionen. Entfernt automatisch Duplikate nahezu identischer Entitätsnamen (Plural, Unicode-Varianten, Groß-/Kleinschreibung) bevor sie zu Graphknoten werden. Korrigiert umgekehrte Kantenrichtungen, wenn das LLM Quell-/Zieltypen gegenüber dem Domänenschema vertauscht. Markiert Beziehungen mit geringer Konfidenz zur Überprüfung. Speichert in `output/graph_data.json`.
### 4. Duplikate von Entitäten auflösen
Siehe [Entity Resolution Workflow](#entity-resolution-workflow) unten für die vollständige Anleitung – besonders wichtig für genealogische, rechtliche und ermittlungstechnische Anwendungsfälle, bei denen Genauigkeit entscheidend ist.
### 5. Erkunden und exportieren
**Interaktiver Viewer** – erkunden Sie Ihre Konzeptkarte im Browser:```bash
sift view # full graph
sift view --neighborhood "Palantir Technologies" # 1-hop ego graph around an entity
sift view --neighborhood "Palantir" --depth 3 # 3-hop neighborhood
sift view --top 10 # top 10 hubs + their neighbors
sift view --community "Community 1" # focus on a specific community
sift view --source-doc palantir_nsa_surveillance # entities from one document
sift view --min-confidence 0.8 # hide low-confidence nodes/edges
Öffnet einen kraftgerichteten Graphen in Ihrem Browser. Die Übersicht zeigt Community-Regionen — farbige konvexe Hüllen, die verwandte Entitäten gruppieren — sodass Sie die Graphstruktur auf einen Blick ohne Label-Überlagerung sehen können. Bewegen Sie die Maus über einen Knoten, um dessen Namen und Verbindungen anzuzeigen. Enthält Suche, Typ-/Community-/Beziehungs-Umschalter, Quellendokument-Filter, Grad-Filter und eine Detail-Seitenleiste.
Vorauswahl-Flags (--top, --neighborhood, --source-doc, --min-confidence) reduzieren den Graphen vor dem Rendern. --community wählt eine Community in der Seitenleiste vor. --neighborhood akzeptiert Entitäts-IDs (person:alice) oder Anzeigenamen (Groß-/Kleinschreibung wird ignoriert).
Fokusmodus: Doppelklicken Sie auf eine Entität, um deren Nachbarschaft zu isolieren. Verwenden Sie die Pfeiltasten, um Schritt für Schritt durch die Verbindungen zu navigieren – jedes Paar wird isoliert mit beschrifteten Kanten angezeigt. Drücken Sie Eingabetaste/Nach-rechts, um den Fokus auf einen Nachbarn zu verschieben, Rücktaste/Nach-links, um entlang Ihres Pfades zurückzugehen, Escape zum Beenden. Ihre Erkundung wird als Breadcrumb-Spur in der Seitenleiste verfolgt – ein beständiger Pfad, der jeden besuchten Knoten und die Beziehungen zwischen ihnen zeigt. Pfadkanten bleiben auf der Leinwand hervorgehoben, sodass Sie Ihren Weg durch den Graphen sehen können. Dies ist die vorgesehene Methode, um dichte Graphen zu erkunden – zoomen Sie auf das Wesentliche, verfolgen Sie Verbindungen, lesen Sie die Beweise.
CLI-Suche — Entitäten direkt vom Terminal aus abfragen:```bash sift search "Sam Bankman" # search by name sift search "SBF" # search by alias sift search "Caroline" -r # show relations sift search "FTX" -d -t ORGANIZATION # descriptions + type filter
**Statische Exporte** — für Analysetools, bei denen Sie ein benutzerdefiniertes Layout, Filter oder Styling wünschen:```bash
sift export graphml # → output/graph.graphml (Gephi, yEd, Cytoscape)
sift export gexf # → output/graph.gexf (Gephi native)
sift export sqlite # → output/graph.sqlite (SQL queries, DuckDB, Datasette)
sift export csv # → output/csv/entities.csv + relations.csv
sift export json # → output/graph.json
Verwenden Sie GraphML/GEXF, wenn Sie Knotengrößen, Kantengewichtung, benutzerdefinierte Farbschemata steuern oder Graphenalgorithmen (Zentralität, Gemeinschaftserkennung) in dedizierten Werkzeugen anwenden möchten. SQLite ist nützlich für Ad-hoc-SQL-Abfragen, Datasette-Veröffentlichung oder das Laden in DuckDB.
sift narrate sift narrate --communities-only # regenerate community labels only (~$0.01)
Produces `output/narrative.md` — ein Prosa-Bericht mit einer Übersicht, wichtigen Beziehungsketten zwischen den Top-Entitäten, einer Zeitleiste (wenn Datumsangaben in den Daten vorhanden sind) und Entitätsprofilen, gruppiert nach thematischer Community (ermittelt mittels Louvain-Community-Erkennung). Entitätsbeschreibungen sind im Aktiv verfasst mit spezifischen Aktionen, nicht als Rollenzusammenfassungen.
## Domain-Konfiguration
sift-kg wird mit vier mitgelieferten Domänen ausgeliefert (siehe [Mitgelieferte Domänen](#bundled-domains) oben für Details). Die Standardeinstellung ist `schema-free`.
Verwende eine mitgelieferte Domäne:```bash
sift extract ./docs/ --domain-name osint
Oder erstellen Sie Ihr eigenes domain.yaml:```yaml
name: My Domain
fallback_relation: RELATED_TO # optional — catch-all for relations that don't fit defined types
entity_types:
PERSON:
description: People and individuals
extraction_hints:
- Look for full names with titles
COMPANY:
description: Business entities
DEPARTMENT:
description: Named departments within a company
canonical_names: # closed vocabulary — only these values allowed
- Engineering
- Sales
- Legal
- Marketing
canonical_fallback_type: ORGANIZATION # non-canonical names get retyped
relation_types:
EMPLOYED_BY:
description: Employment relationship
source_types: [PERSON]
target_types: [COMPANY]
OWNS:
description: Ownership relationship
symmetric: false
review_required: true
RELATED_TO: # define the fallback type if you use one
description: General relationship
**Schema-Durchsetzung:** In Ihrer Domäne definierte Entitätstypen und Beziehungstypen werden als geschlossene Menge behandelt — der LLM wird angewiesen, nur diese Typen zu verwenden und keine neuen zu erfinden. Wenn `fallback_relation` gesetzt ist, werden Beziehungen, die in keinen definierten Typ passen, auf den Fallback abgebildet. Falls nicht gesetzt, verwendet der LLM den nächstgelegenen definierten Typ mit geringerer Konfidenz. Wenn Sie viele Beziehungen sehen, die auf Ihren Fallback-Typ landen, fehlt Ihrem Schema wahrscheinlich ein Beziehungstyp, den die Daten benötigen — fügen Sie ihn hinzu und extrahieren Sie erneut.
Entitätstypen mit `canonical_names` erzwingen ein geschlossenes Vokabular. Die erlaubten Namen werden in den LLM-Extraktionsprompt eingefügt, sodass exakte Übereinstimmungen ausgegeben werden. Als Sicherheitsnetz wird jeder extrahierte Name, der nicht in der Liste ist, beim Graph-Aufbau in `canonical_fallback_type` umgewandelt (oder unverändert gelassen, wenn kein Fallback gesetzt ist). Nützlich für kontrollierte Taxonomien — Abteilungen, Rechtsgebiete, vordefinierte Klassifikationen.```bash
sift extract ./docs/ --domain path/to/domain.yaml
Verwenden Sie sift-kg von Python aus — Jupyter-Notebooks, Skripte, Web-Apps:```python from sift_kg import load_domain, run_extract, run_build, run_narrate, run_resolve, run_export, run_view from sift_kg import KnowledgeGraph from pathlib import Path
domain = load_domain() # or load_domain(bundled_name="osint")
results = run_extract( Path("./docs"), "openai/gpt-4o-mini", domain, Path("./output"), ocr=True, ocr_backend="tesseract", # enable OCR for scanned PDFs extractor="kreuzberg", # or "pdfplumber" concurrency=4, chunk_size=10000, )
kg = run_build(Path("./output"), domain) print(f"{kg.entity_count} entities, {kg.relation_count} relations")
merges = run_resolve(Path("./output"), "openai/gpt-4o-mini", domain=domain, use_embeddings=True)
run_export(Path("./output"), "sqlite")
run_narrate(Path("./output"), "openai/gpt-4o-mini", communities_only=True)
run_view(Path("./output")) # full graph run_view(Path("./output"), neighborhood="person:alice", depth=2) # ego graph run_view(Path("./output"), top_n=10) # top hubs
from sift_kg import run_pipeline run_pipeline(Path("./docs"), "openai/gpt-4o-mini", domain, Path("./output"))
## Projektstruktur
Nach dem Ausführen der Pipeline enthält Ihr Ausgabeverzeichnis:```
output/
├── extractions/ # Per-document extraction JSON
│ ├── document1.json
│ └── document2.json
├── discovered_domain.yaml # Auto-discovered schema (schema-free mode)
├── graph_data.json # Knowledge graph (native format)
├── merge_proposals.yaml # Entity merge proposals (DRAFT/CONFIRMED/REJECTED)
├── relation_review.yaml # Flagged relations for review
├── narrative.md # Generated narrative summary
├── entity_descriptions.json # Entity descriptions (loaded by viewer)
├── communities.json # Community assignments (shared by narrate + viewer)
├── graph.html # Interactive graph visualization
├── graph.graphml # GraphML export (if exported)
├── graph.gexf # GEXF export (if exported)
├── graph.sqlite # SQLite export (if exported)
└── csv/ # CSV export (if exported)
├── entities.csv
└── relations.csv
Wenn du einen Wissensgraphen aus Familienaufzeichnungen, rechtlichen Einreichungen oder anderen Dokumenten erstellst, bei denen Genauigkeit wichtig ist, möchtest du die volle Kontrolle darüber haben, welche Entitäten zusammengeführt werden. sift-kg führt niemals ohne deine Zustimmung etwas zusammen.
Der Workflow besteht aus drei Ebenen, die jeweils verschiedene Arten von Duplikaten erkennen:
sift build)Bevor Entitäten zu Graphknoten werden, kollabiert sift deterministisch Namen, die offensichtlich gleich sind. Kein LLM erforderlich, keine Kosten, keine Überprüfung nötig:
Dies geschieht automatisch jedes Mal, wenn du sift build ausführst. Dies sind die trivialen Fälle — Schreibvarianten, die deinen Graphen überladen würden, ohne Informationen hinzuzufügen.
sift resolve)Das LLM sieht Batches von Entitäten (alle Typen außer DOCUMENT) und identifiziert diejenigen, die sich wahrscheinlich auf dasselbe reale Objekt beziehen. Es erkennt auch typübergreifende Duplikate (gleicher Name, unterschiedlicher Entitätstyp) und schlägt Variantenbeziehungen (EXTENDS) vor, wenn es Eltern-Kind-Muster findet. Ergebnisse gehen in merge_proposals.yaml (Entitätszusammenführungen) und relation_review.yaml (Variantenbeziehungen), alle beginnen als DRAFT:```bash
sift resolve # uses domain from sift.yaml
sift resolve --domain osint # or specify explicitly
Wenn Sie eine Domain konfiguriert haben, nutzt das LLM diesen Kontext, um bessere Entscheidungen über Entitätsnamen zu treffen, die für Ihr Fachgebiet spezifisch sind.
Dies erzeugt Vorschläge wie:```yaml
proposals:
- canonical_id: person:samuel_benjamin_bankman_fried
canonical_name: Samuel Benjamin Bankman-Fried
entity_type: PERSON
status: DRAFT # ← you decide
members:
- id: person:bankman_fried
name: Bankman-Fried
confidence: 0.99
reason: Same person referenced with full name vs. surname only.
- canonical_id: person:stephen_curry
canonical_name: Stephen Curry
entity_type: PERSON
status: DRAFT # ← you decide
members:
- id: person:steph_curry
name: Steph Curry
confidence: 0.99
reason: Same basketball player referenced with nickname 'Steph' and full name 'Stephen'.
Noch ist nichts zusammengeführt.
Du hast zwei Optionen zur Überprüfung von Vorschlägen:
Option A: Interaktive Terminal-Überprüfung```bash sift review
Geht jeden `DRAFT`-Vorschlag einzeln durch. Für jeden sehen Sie die kanonische Entität, die vorgeschlagenen Zusammenführungsmitglieder sowie die Konfidenz und Begründung des LLM. Sie genehmigen, lehnen ab oder überspringen.
Vorschläge mit hoher Konfidenz (>0,85 standardmäßig) werden automatisch genehmigt, und Beziehungen mit niedriger Konfidenz (<=0,5 standardmäßig) werden automatisch abgelehnt:```bash
sift review # uses defaults: --auto-approve 0.85, --auto-reject 0.5
sift review --auto-approve 0.90 # raise the auto-approve threshold
sift review --auto-reject 0.3 # lower the auto-reject threshold
sift review --auto-approve 1.0 # disable auto-approve, review everything manually
Option B: YAML direkt bearbeiten
Öffnen Sie output/merge_proposals.yaml in einem beliebigen Texteditor. Ändern Sie status: DRAFT in CONFIRMED oder REJECTED:```yaml
canonical_id: person:stephen_curry canonical_name: Stephen Curry entity_type: PERSON status: CONFIRMED # ← approve this merge members:
canonical_id: person:winklevoss_twins canonical_name: Winklevoss twins entity_type: PERSON status: REJECTED # ← these are distinct people, don't merge members:
**Für hochpräzise Anwendungsfälle** (Genealogie, rechtliche Prüfung) empfehlen wir, die YAML-Datei direkt zu bearbeiten, damit Sie jeden Vorschlag sorgfältig prüfen können. Die Datei ist so gestaltet, dass sie für Menschen lesbar ist.
### Layer 3b: Relationsprüfung
Während `sift build` werden Beziehungen, die unter dem Konfidenzschwellenwert (Standard 0.7) liegen oder von Typen sind, die in Ihrer Domain-Konfiguration als `review_required` markiert sind, in `output/relation_review.yaml` gekennzeichnet:```yaml
review_threshold: 0.7
relations:
- source_name: Alice Smith
target_name: Acme Corp
relation_type: WORKS_FOR
confidence: 0.45
evidence: "Alice mentioned she used to work near the Acme building."
status: DRAFT # ← you decide: CONFIRMED or REJECTED
flag_reason: Low confidence (0.45 < 0.7)
Gleicher Workflow: Überprüfen mit sift review oder die YAML bearbeiten, dann anwenden.
Wenn Sie alles überprüft haben:```bash sift apply-merges
Dies bewirkt drei Dinge:
1. **Bestätigte Entitätszusammenführungen** — Mitgliedsentitäten werden in die kanonische Entität absorbiert. Alle ihre Beziehungen werden umgeleitet. Quelldokumente werden kombiniert. Die Mitgliedsknoten werden entfernt.
2. **Abgelehnte Beziehungen** — vollständig aus dem Graphen entfernt.
3. **ENTWURF-Vorschläge** — unberührt gelassen. Sie können später darauf zurückkommen.
Der Graph wird zurück in `output/graph_data.json` gespeichert. Sie können den bereinigten Graphen erneut exportieren, erzählen oder visualisieren.
### Iterating
Die Entitätsauflösung ist nicht immer ein Durchgang. Nach dem Zusammenführen können neue Dubletten sichtbar werden. Sie können erneut ausführen:```bash
sift resolve # find new duplicates in the cleaned graph
sift review # review the new proposals
sift apply-merges # apply again
Jeder Durchlauf ist additiv – frühere CONFIRMED/REJECTED-Entscheidungen in merge_proposals.yaml werden beibehalten.
Die Techniken zur Vor-Deduplizierung und zum LLM-Batching sind inspiriert von KGGen (NeurIPS 2025) von @stochastic-sisyphus. KGGen verwendet SemHash zur deterministischen Entitätsdeduplizierung und einbettungsbasiertes Clustering zur Gruppierung von Entitäten vor dem LLM-Vergleich. sift-kg passt diese in seinen menschlichen Prüfworkflow ein.
Standardmäßig sortiert sift resolve Entitäten alphabetisch und teilt sie in überlappende Batches für den LLM-Vergleich. Das funktioniert gut, wenn Duplikate ähnliche Schreibweisen haben – aber „Robert Smith“ (R) und „Bob Smith“ (B) landen in verschiedenen Batches und werden nie verglichen.```bash
pip install sift-kg[embeddings] # sentence-transformers + scikit-learn (~2GB, pulls PyTorch)
sift resolve --embeddings
Dies ersetzt die alphabetische Batchverarbeitung durch KMeans-Clustering auf Satz-Embeddings (all-MiniLM-L6-v2). Semantisch ähnliche Namen gruppieren sich unabhängig von der Schreibweise.
| | Standard (alphabetisch) | `--embeddings` |
|---|---|---|
| Installationsgröße | Enthalten | ~2 GB (PyTorch) |
| Erstausführungs-Overhead | Keiner | ~90 MB Modelldownload |
| Ausführungs-Overhead | Nur Sortierung | Codierung (<1 s für Hunderte von Entitäten) |
| Alphabetübergreifende Duplikate | Unentdeckt bei verschiedenen Batches | Erkannt |
| Kleine Graphen (<100/Typ) | Gleiches Ergebnis | Gleiches Ergebnis |
Fällt auf alphabetische Batchverarbeitung zurück, wenn Abhängigkeiten nicht installiert sind oder das Clustering fehlschlägt.
## Lizenz
--community--source-doc--min-confidence--ocr-Flag), mit optionalem Google Cloud Vision Fallback (--ocr-backend gcv)--max-cost, um die LLM-Ausgaben zu begrenzen| Anwendungsfall | Empfohlener Ansatz |
|---|
| Schnelle Erkundung | sift review --auto-approve 0.85 – Hochvertrauenswürdiges automatisch genehmigen, Rest prüfen |
| Genealogie / Familienaufzeichnungen | YAML manuell bearbeiten, --auto-approve 1.0 – jede einzelne Zusammenführung prüfen |
| Rechtlich / Ermittlung | sift resolve --embeddings, YAML manuell bearbeiten, zwischendurch mit sift view inspizieren |
| Großer Korpus (1000+ Entitäten) | sift resolve --embeddings für bessere Stapelverarbeitung, dann interaktive Prüfung |