Transformez n'importe quel ensemble de documents en un graphe de connaissances. Extrayez des entités et des relations via un LLM, dédupliquez avec votre approbation. Cartographiez des domaines, trouvez des connexions cachées, repérez des motifs à travers les documents — une connaissance qui persiste et s'accumule, pour vous et vos agents IA. Le tout depuis la CLI.
Transformez n'importe quelle collection de documents en un graphe de connaissances.
Pas de code, pas de base de données, pas d'infrastructure — juste une CLI et vos documents. Déposez des PDFs, articles, documents ou enregistrements — obtenez un graphe de connaissances consultable qui montre comment tout est connecté, en quelques minutes. sift-kg extrait les entités et les relations via LLM, déduplique avec votre approbation, et génère une visionneuse interactive que vous pouvez explorer dans votre navigateur. Des cartes conceptuelles pour tout, à portée de main.
Le même graphe qui alimente vos visualisations fonctionne également comme un second cerveau IA. Tout le monde passe des mois à construire des bases de connaissances dans Notion et Obsidian. Qui a le temps pour cela ? sift-kg est la mémoire structurée que vous construisez en 2 minutes au lieu de 2 ans. Pointez simplement vers vos documents et votre IA a une compréhension structurée de la façon dont tout est connecté.
Démos en direct → graphes entièrement générés par sift-kg```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.
## Comment ça marche```
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)
Every entity and relation links back to the source document and passage. You control what gets merged. The graph is yours.
sift.yaml dans votre projet pour des paramètres persistantsdiscovered_domain.yaml pour réutilisation et édition. Ou utilisez un domaine structuré (general, osint, academic) pour des schémas fixes, ou définissez le vôtre en YAMLsift search "SBF" trouve des entités par nom ou alias, avec sortie optionnelle des relations et descriptions--neighborhood, --top, , , sift‑kg génère des connaissances structurées que les agents IA peuvent exploiter directement.
Pointez sift vers vos documents, notes ou fichiers de projet. Le résultat — un graphe de connaissances au format JSON — offre à tout agent IA une compréhension persistante et structurée de la façon dont tout ce qui vous entoure se connecte. Pas d’organisation manuelle, pas d’étiquetage, pas de liens wiki. La structure émerge du contenu.```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)
Le graphe persiste entre les sessions et croît de manière incrémentielle — extrayez de nouveaux documents dans le même répertoire de sortie et reconstruisez. La déduplication des entités garantit que le graphe reste cohérent à mesure qu'il se développe.
**Ce que cela apporte à votre agent :**
- **Structure** — pas seulement des fragments de texte, mais des entités, des relations, des communautés et la manière dont elles se connectent
- **Topologie** — quels clusters de connaissances existent, ce qui les relie, ce qui est isolé
- **Durabilité** — le graphe survit aux réinitialisations de la fenêtre de contexte. Votre agent cesse de repartir de zéro à chaque session
**Compétence d'agent intégrée :** sift-kg est livré avec une compétence à `.agents/skills/sift-kg/SKILL.md` qui enseigne aux agents comment utiliser le graphe de connaissances comme mémoire persistante — orientation de session, exploration d'entités, raisonnement sur les îlots de connaissances liés et génération de suggestions fondées.
## Domaines intégrés
sift-kg est livré avec des domaines spécialisés que vous pouvez utiliser directement :```bash
sift domains # list available domains
sift extract ./docs/ --domain-name osint # use a bundled domain
Définissez un domaine dans sift.yaml pour ne pas avoir à utiliser le flag à chaque fois :```yaml
domain: academic
Fonctionne avec des noms intégrés (`schema-free`, `general`, `osint`, `academic`) ou un chemin vers un fichier YAML personnalisé.
| Domaine | Focalisation | Types d’entités clés | Types de relations clés |
|---------|-------------|----------------------|--------------------------|
| `schema-free` | Découverte automatique à partir de vos données (par défaut) | *(l’LLM conçoit selon le corpus)* | *(l’LLM conçoit selon le corpus)* |
| `general` | Analyse générale de documents | PERSONNE, ORGANISATION, LIEU, ÉVÉNEMENT, DOCUMENT | ASSOCIÉ_À, MEMBRE_DE, SITUÉ_DANS |
| `osint` | Enquêtes & FOIA | SOCIÉTÉ_ÉCRAN, COMPTE_FINANCIER | PROPRIÉTAIRE_EFFECTIF_DE, A_TRANSACTIONNÉ_AVEC, SIGNATAIRE_DE |
| `academic` | Revue de littérature & cartographie thématique | CONCEPT, THÉORIE, MÉTHODE, SYSTÈME, RÉSULTAT, PHÉNOMÈNE, CHERCHEUR, PUBLICATION, DOMAINE, JEU_DE_DONNÉES | SOUTIENT, CONTREDIT, ÉTEND, IMPLÉMENTE, EXPLIQUE, PROPOSÉ_PAR, UTILISE_MÉTHODE, APPLIQUÉ_À, CHERCHE |
Le domaine **academic** cartographie le paysage intellectuel d’un domaine de recherche — alimentez-le avec des articles et obtenez un graphe de la façon dont les théories, méthodes, systèmes, résultats et concepts se connectent. Il distingue les idées abstraites (THÉORIE, MÉTHODE) des artefacts concrets (SYSTÈME — ex. GPT-2, BERT, GLUE). Conçu pour les revues de littérature, la cartographie thématique et la compréhension des points d’accord, de contradiction ou de construction mutuelle entre idées.
Le domaine **schema-free** (par défaut) exécute une étape de **découverte de schéma** avant l’extraction — un appel LLM échantillonne vos documents et conçoit des types d’entités et de relations adaptés au corpus. Le schéma découvert est sauvegardé dans `output/discovered_domain.yaml` et réutilisé lors des exécutions suivantes, de sorte que les types restent cohérents entre tous les fragments et documents. Vous pouvez inspecter, modifier manuellement ou copier le fichier comme point de départ pour un domaine personnalisé. Utilisez `--force` pour redécouvrir. Au lieu de forcer les relations dans des catégories prédéfinies comme ASSOCIÉ_À, il produit des types spécifiques comme FINANCÉ, A_TÉMOIGNÉ_CONTRE, ou INSCRIT_À. Utilisez un domaine structuré comme `general` ou `osint` lorsque vous voulez un schéma fixe que vous définissez à l’avance.
Le domaine **general** fournit un schéma fixe avec les types d’entités PERSONNE, ORGANISATION, LIEU, ÉVÉNEMENT et DOCUMENT, ainsi que des types de relations courants. Utile lorsque vous souhaitez des types prévisibles et cohérents dans tous les documents.
Le domaine **osint** ajoute des types d’entités pour les sociétés écrans, les comptes financiers et les juridictions offshore, ainsi que des types de relations pour tracer la propriété effective et les flux financiers.
Rien n’est fusionné sans votre approbation — l’LLM propose, vous vérifiez. Chaque extraction renvoie au document source et au passage.
Voir [`examples/transformers/`](https://github.com/juanceresa/sift-kg/blob/main/examples/transformers) pour 12 articles fondateurs sur l’IA cartographiés en graphe de concepts (425 entités, ~0,72 $), et [`examples/ftx/`](https://github.com/juanceresa/sift-kg/blob/main/examples/ftx) pour l’effondrement de FTX (431 entités provenant de 9 articles). [**Explorez les démos en direct**](https://juanceresa.github.io/sift-kg/) — pas d’installation, pas de clé API.
## Civic Table
Vous cherchez une plateforme hébergée avec analyse légale forensique et vérification par analyste ?
[**Civic Table**](https://github.com/juanceresa/forensic_analysis_platform) est une plateforme de renseignement forensique construite sur le pipeline sift-kg. Elle ajoute un système de vérification à 4 niveaux où les analystes et les juristes valident les faits extraits par l’IA avant qu’ils ne soient considérés comme des preuves, une génération de dossier LaTeX pour les soumissions légales, et une interface web pour partager les résultats avec les clients et les familles. Conçue pour la restitution de biens, le journalisme d’investigation et tout contexte où la provenance documentaire compte.
sift-kg est l’interface en ligne de commande open-source. Civic Table est la plateforme complète — et là où les résultats sont examinés par des analystes et des juristes avant d’avoir un poids probant.
## Installation
Nécessite Python 3.11+.```bash
pip install sift-kg
Pour la prise en charge de l'OCR (PDF scannés, images) :```bash
brew install tesseract # macOS sudo apt install tesseract-ocr # Ubuntu/Debian
Pour Google Cloud Vision OCR en tant que backend alternatif (optionnel) :```bash
pip install sift-kg[ocr]
# Then use: sift extract ./docs/ --ocr --ocr-backend gcv
Pour le regroupement sémantique lors de la résolution d'entités (optionnel, ~2GB pour PyTorch) :```bash pip install sift-kg[embeddings]
Pour le développement :```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` génère un fichier de configuration de projet `sift.yaml` afin que vous n'ayez pas besoin de drapeaux sur chaque commande :```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
Définissez votre clé API dans .env :```
SIFT_OPENAI_API_KEY=sk-...
Ou utilisez Anthropic, Mistral, Ollama, ou tout fournisseur LiteLLM :```
SIFT_ANTHROPIC_API_KEY=sk-ant-...
SIFT_MISTRAL_API_KEY=...
Priorité des paramètres : flags CLI > variables d'env > .env > sift.yaml > valeurs par défaut. Vous pouvez remplacer n'importe quel paramètre depuis sift.yaml par un flag sur n'importe quelle commande.
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
Reads 75+ document formats — PDFs, DOCX, XLSX, PPTX, HTML, EPUB, images, and more. Extracts entities and relations using your configured LLM. Results saved as JSON in `output/extractions/`.
The `--ocr` flag enables local OCR via Tesseract for scanned PDFs — no API keys or cloud services needed. You can switch OCR engines with `--ocr-backend`:```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)
Il détecte automatiquement quels PDF nécessitent une OCR — les PDF riches en texte utilisent l'extraction standard, seules les pages presque vides recourent à l'OCR. Sûr pour les dossiers mixtes. Sans --ocr, sift avertira si un PDF semble être scanné.
Vous pouvez également changer complètement le moteur d'extraction avec --extractor pdfplumber pour le moteur pdfplumber hérité (PDF/DOCX/TXT/HTML uniquement).
sift build
Construit un graphe NetworkX à partir de toutes les extractions. Déduplique automatiquement les noms d'entités quasi identiques (pluriels, variantes Unicode, différences de casse) avant qu'ils ne deviennent des nœuds du graphe. Corrige les directions d'arêtes inversées lorsque le LLM échange les types source/cible par rapport au schéma du domaine. Signale les relations de faible confiance pour révision. Sauvegarde dans `output/graph_data.json`.
### 4. Résoudre les entités en double
Voir [Workflow de résolution d'entités](#entity-resolution-workflow) ci-dessous pour le guide complet — particulièrement important pour les cas d'utilisation en généalogie, droit et enquête où la précision compte.
### 5. Explorer et exporter
**Visionneuse interactive** — explorez votre carte conceptuelle dans le navigateur :```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
Ouvre un graphe orienté par force dans votre navigateur. La vue d'ensemble montre les régions de communauté — des enveloppes convexes colorées regroupant des entités liées — afin que vous puissiez voir la structure du graphe d'un coup d'œil sans encombrement des étiquettes. Survolez un nœud pour prévisualiser son nom et ses connexions. Inclut la recherche, les bascules de type/communauté/relation, le filtre de document source, le filtre de degré et une barre latérale de détails.
Les indicateurs de pré-filtrage (--top, --neighborhood, --source-doc, --min-confidence) réduisent le graphe avant le rendu. --community présélectionne une communauté dans la barre latérale. --neighborhood accepte les identifiants d'entité (person:alice) ou les noms affichés (insensibles à la casse).
Mode focus : Double-cliquez sur une entité pour isoler son voisinage. Utilisez les touches fléchées pour parcourir les connexions une par une — chaque paire est affichée isolément avec des arêtes étiquetées. Appuyez sur Entrée/Droite pour déplacer le focus sur un voisin, Retour arrière/Gauche pour revenir en arrière le long de votre chemin, Échap pour quitter. Votre exploration est suivie comme un fil d'Ariane dans la barre latérale — un chemin persistant montrant chaque nœud visité et les relations entre eux. Les arêtes du chemin restent mises en évidence sur le canevas afin que vous puissiez voir votre chemin à travers le graphe. C'est la manière prévue pour explorer les graphes denses — zoomer sur ce qui compte, tracer les connexions, lire les preuves.
Recherche CLI — interrogez les entités directement depuis le terminal :```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
**Exportations statiques** — pour les outils d'analyse où vous souhaitez une mise en page, un filtrage ou un style personnalisés :```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
Utilisez GraphML/GEXF lorsque vous souhaitez contrôler la taille des nœuds, le poids des arêtes, les jeux de couleurs personnalisés, ou appliquer des algorithmes de graphe (centralité, détection de communautés) dans des outils dédiés. SQLite est utile pour les requêtes SQL ad-hoc, la publication via Datasette, ou le chargement dans DuckDB.
sift narrate sift narrate --communities-only # regenerate community labels only (~$0.01)
Produces `output/narrative.md` — a prose report with an overview, key relationship chains between top entities, a timeline (when dates exist in the data), and entity profiles grouped by thematic community (discovered via Louvain community detection). Entity descriptions are written in active voice with specific actions, not role summaries.
## Domain Configuration
sift-kg est livré avec quatre domaines intégrés (voir [Domaines intégrés](#bundled-domains) ci-dessus pour plus de détails). La valeur par défaut est `schema-free`.
Utiliser un domaine intégré :```bash
sift extract ./docs/ --domain-name osint
Ou créez votre propre 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
**Respect du schéma :** Les types d'entités et les types de relations définis dans votre domaine sont traités comme un ensemble fermé — le LLM est invité à n'utiliser que ces types et n'en inventera pas de nouveaux. Si `fallback_relation` est défini, les relations qui ne correspondent à aucun type défini sont mappées sur le type de repli. Si omis, le LLM utilise le type défini le plus proche avec une confiance moindre. Si vous voyez de nombreuses relations atterrir sur votre type de repli, votre schéma manque probablement d'un type de relation dont les données ont besoin — ajoutez-le et extrayez à nouveau.
Les types d'entités avec `canonical_names` imposent un vocabulaire fermé. Les noms autorisés sont injectés dans l'invite d'extraction du LLM afin qu'il produise des correspondances exactes. En guise de filet de sécurité, tout nom extrait ne figurant pas dans la liste est re-typé en `canonical_fallback_type` lors de la construction du graphe (ou conservé tel quel si aucun type de repli n'est défini). Utile pour les taxonomies contrôlées — départements, juridictions, classifications prédéfinies.```bash
sift extract ./docs/ --domain path/to/domain.yaml
Utilisez sift-kg depuis Python — Jupyter notebooks, scripts, applications web :```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"))
## Structure du projet
Après avoir exécuté le pipeline, votre répertoire de sortie contient :```
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
Lorsque vous construisez un graphe de connaissances à partir de registres familiaux, de documents juridiques ou de tout document où la précision est cruciale, vous souhaitez un contrôle total sur les entités à fusionner. sift-kg ne fusionne jamais rien sans votre approbation.
Le flux de travail comporte trois couches, chacune capturant différents types de doublons :
sift build)Avant que les entités ne deviennent des nœuds du graphe, sift regroupe de manière déterministe les noms qui sont manifestement identiques. Aucun LLM impliqué, aucun coût, aucune révision nécessaire :
Cela se produit automatiquement à chaque exécution de sift build. Ce sont les cas triviaux — des variantes orthographiques qui encombreraient votre graphe sans ajouter d'information.
sift resolve)Le LLM examine des lots d'entités (tous les types sauf DOCUMENT) et identifie celles qui se réfèrent vraisemblablement à la même chose réelle. Il détecte également les doublons entre types (même nom, type d'entité différent) et propose des relations de variante (EXTENDS) lorsqu'il trouve des motifs parent/enfant. Les résultats vont dans merge_proposals.yaml (fusions d'entités) et relation_review.yaml (relations de variante), tous commençant comme DRAFT :```bash
sift resolve # uses domain from sift.yaml
sift resolve --domain osint # or specify explicitly
Si vous avez un domaine configuré, le LLM utilise ce contexte pour prendre de meilleures décisions concernant les noms d'entités spécifiques à votre domaine.
Cela génère des propositions comme :```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'.
Rien n'est encore fusionné. Le LLM propose, mais ne décide pas.
Vous avez deux options pour examiner les propositions :
Option A : Revue interactive en terminal```bash sift review
Parcourt chaque proposition `DRAFT` une par une. Pour chacune, vous voyez l'entité canonique, les membres de fusion proposés, la confiance et le raisonnement du LLM. Vous approuvez, rejetez ou sautez.
Les propositions à haute confiance (>0.85 par défaut) sont automatiquement approuvées, et les relations à faible confiance (<=0.5 par défaut) sont automatiquement rejetées :```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 : Modifier le YAML directement
Ouvrez output/merge_proposals.yaml dans un éditeur de texte. Remplacez status: DRAFT par CONFIRMED ou 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:
Pour les cas d'utilisation de haute précision (généalogie, révision juridique), nous recommandons de modifier directement le YAML afin que vous puissiez étudier chaque proposition attentivement. Le fichier est conçu pour être lisible par l'homme.
### Couche 3b : Révision des relations
Lors de `sift build`, les relations en dessous du seuil de confiance (par défaut 0.7) ou de types marqués `review_required` dans votre configuration de domaine sont signalées dans `output/relation_review.yaml` :
```yaml
# Relations below threshold or review_required
relations:
- source: alice
target: bob
``````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)
Même workflow : examinez avec sift review ou modifiez le YAML, puis appliquez.
Une fois que vous avez tout examiné :```bash sift apply-merges
This does three things:
1. **Fusions d'entités confirmées** — les entités membres sont absorbées dans l'entité canonique. Toutes leurs relations sont reconnectées. Les documents sources sont combinés. Les nœuds membres sont supprimés.
2. **Relations rejetées** — supprimées entièrement du graphe.
3. **Propositions DRAFT** — laissées intactes. Vous pourrez y revenir plus tard.
Le graphe est sauvegardé dans `output/graph_data.json`. Vous pouvez réexporter, narrer ou visualiser le graphe nettoyé.
### Itération
La résolution d'entités n'est pas toujours un processus en une seule passe. Après la fusion, de nouveaux doublons peuvent apparaître. Vous pouvez relancer :
```bash
python -m entity_resolution
``````bash
sift resolve # find new duplicates in the cleaned graph
sift review # review the new proposals
sift apply-merges # apply again
Chaque exécution est additive — les décisions CONFIRMED/REJECTED précédentes dans merge_proposals.yaml sont conservées.
Les techniques de pré-déduplication et de traitement par lots LLM sont inspirées de KGGen (NeurIPS 2025) par @stochastic-sisyphus. KGGen utilise SemHash pour la déduplication déterministe des entités et le clustering basé sur les embeddings pour regrouper les entités avant la comparaison LLM. sift-kg adapte ces techniques dans son flux de révision avec intervention humaine.
Par défaut, sift resolve trie les entités par ordre alphabétique et les divise en lots chevauchants pour la comparaison LLM. Cela fonctionne bien lorsque les doublons ont une orthographe similaire — mais « Robert Smith » (R) et « Bob Smith » (B) se retrouvent dans des lots différents et ne sont jamais comparés.```bash
pip install sift-kg[embeddings] # sentence-transformers + scikit-learn (~2GB, pulls PyTorch)
sift resolve --embeddings
Ce remplace le groupement alphabétique par un clustering KMeans sur les embeddings de phrases (all-MiniLM-L6-v2). Les noms sémantiquement similaires se regroupent indépendamment de l'orthographe.
| | Défaut (alphabétique) | `--embeddings` |
|---|---|---|
| Taille d'installation | Incluse | ~2 Go (PyTorch) |
| Surcharge au premier lancement | Aucune | téléchargement du modèle ~90 Mo |
| Surcharge par exécution | Tri uniquement | Encodage (<1 s pour des centaines d'entités) |
| Doublons inter-alphabets | Manqués si dans des lots différents | Détectés |
| Petits graphes (<100/type) | Même résultat | Même résultat |
En cas d'absence de dépendances ou d'échec du clustering, on revient au groupement alphabétique.
## Licence
MIT
--community--source-doc--min-confidence--ocr), avec option de repli Google Cloud Vision (--ocr-backend gcv)--max-cost pour plafonner les dépenses LLM| Cas d'utilisation | Approche suggérée |
|---|
| Exploration rapide | sift review --auto-approve 0.85 — approuver les hautes confiances, vérifier le reste |
| Généalogie / registres familiaux | Modifier manuellement le YAML, --auto-approve 1.0 — vérifier chaque fusion individuellement |
| Juridique / enquête | sift resolve --embeddings, modifier manuellement le YAML, utiliser sift view pour inspecter entre les tours |
| Grand corpus (1000+ entités) | sift resolve --embeddings pour un meilleur traitement par lots, puis une révision interactive |