Transforme qualquer coleção de documentos em um grafo de conhecimento. Extraia entidades e relacionamentos via LLM, deduplique com sua aprovação. Mapeie domínios, encontre conexões ocultas, identifique padrões entre documentos — conhecimento que persiste e se acumula, para você e seus agentes de IA. Tudo a partir da CLI.
Converta qualquer coleção de documentos em um grafo de conhecimento.
Sem código, sem banco de dados, sem infraestrutura — apenas uma CLI e seus documentos. Insira PDFs, artigos, publicações ou registros — obtenha um grafo de conhecimento navegável que mostra como tudo se conecta, em minutos. sift-kg extrai entidades e relacionamentos via LLM, desduplica com sua aprovação e gera um visualizador interativo que você pode explorar no seu navegador. Mapas conceituais para qualquer coisa, ao seu alcance.
O mesmo grafo que alimenta suas visualizações também funciona como um segundo cérebro de IA. Todo mundo passa meses construindo bases de conhecimento no Notion e Obsidian. Quem tem tempo para isso? sift-kg é a memória estruturada que você constrói em 2 minutos em vez de 2 anos. Aponte para seus documentos e sua IA terá uma compreensão estruturada de como tudo se conecta.
Demonstrações ao vivo → grafos gerados inteiramente pelo 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.
## Como Funciona```
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)
Cada entidade e relação remete ao documento e à passagem de origem. Você controla o que é mesclado. O grafo é seu.
sift.yaml no seu projeto para configurações persistentesdiscovered_domain.yaml para reutilização e edição. Ou use um domínio estruturado (general, osint, academic) para esquemas fixos, ou defina o seu próprio em YAMLsift search "SBF" encontra entidades por nome ou apelido, com saída opcional de relações e descrição--neighborhood, --top, , , O sift-kg gera conhecimento estruturado que agentes de IA podem operar diretamente.
Aponte o sift para seus documentos, anotações ou arquivos de projeto. O resultado — um grafo de conhecimento em JSON — dá a qualquer agente de IA uma compreensão estruturada e persistente de como tudo no seu mundo se conecta. Sem organização manual, sem tags, sem links wiki. A estrutura emerge do conteúdo.```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)
The graph persists across sessions and grows incrementally — extract new documents into the same output directory and rebuild. Entity deduplication ensures the graph stays coherent as it grows.
**What this gives your agent:**
- **Structure** — not just text chunks, but entities, relationships, communities, and how they connect
- **Topology** — which knowledge clusters exist, what bridges them, what's isolated
- **Durability** — the graph survives context window resets. Your agent stops starting from zero every session
**Bundled agent skill:** sift-kg ships with a skill at `.agents/skills/sift-kg/SKILL.md` that teaches agents how to use the knowledge graph as persistent memory — session orientation, entity exploration, link-knowledge-islands reasoning, and grounded suggestion generation.
## Bundled Domains
sift-kg ships with specialized domains you can use out of the box:```bash
sift domains # list available domains
sift extract ./docs/ --domain-name osint # use a bundled domain
Defina um domínio em sift.yaml para não precisar da flag toda vez:```yaml
domain: academic
Funciona com nomes incluídos (`schema-free`, `general`, `osint`, `academic`) ou um caminho para um arquivo YAML personalizado.
| Domínio | Foco | Tipos de Entidade Principais | Tipos de Relação Principais |
|---------|------|------------------------------|-----------------------------|
| `schema-free` | Auto-descoberto a partir dos seus dados (padrão) | *(LLM projeta por corpus)* | *(LLM projeta por corpus)* |
| `general` | Análise geral de documentos | PERSON, ORGANIZATION, LOCATION, EVENT, DOCUMENT | ASSOCIATED_WITH, MEMBER_OF, LOCATED_IN |
| `osint` | Investigações e FOIA | SHELL_COMPANY, FINANCIAL_ACCOUNT | BENEFICIAL_OWNER_OF, TRANSACTED_WITH, SIGNATORY_OF |
| `academic` | Revisão de literatura e mapeamento de tópicos | CONCEPT, THEORY, METHOD, SYSTEM, FINDING, PHENOMENON, RESEARCHER, PUBLICATION, FIELD, DATASET | SUPPORTS, CONTRADICTS, EXTENDS, IMPLEMENTS, EXPLAINS, PROPOSED_BY, USES_METHOD, APPLIED_TO, INVESTIGATES |
O domínio **academic** mapeia o panorama intelectual de uma área de pesquisa — insira artigos e obtenha um grafo de como teorias, métodos, sistemas, resultados e conceitos se conectam. Distingue ideias abstratas (THEORY, METHOD) de artefatos concretos (SYSTEM — e.g. GPT-2, BERT, GLUE). Projetado para revisões de literatura, mapeamento de tópicos e compreensão de onde as ideias concordam, contradizem ou se baseiam umas nas outras.
O domínio **schema-free** (o padrão) executa uma etapa de **descoberta de esquema** antes da extração — uma chamada LLM amostra seus documentos e projeta tipos de entidade e relação adaptados ao corpus. O esquema descoberto é salvo em `output/discovered_domain.yaml` e reutilizado em execuções subsequentes, para que os tipos permaneçam consistentes em todos os trechos e documentos. Você pode inspecionar, editar manualmente ou copiar o arquivo como ponto de partida para um domínio personalizado. Use `--force` para redescobrir. Em vez de forçar relacionamentos em categorias predefinidas como ASSOCIATED_WITH, ele produz tipos específicos como FUNDED, TESTIFIED_AGAINST ou ENROLLED_AT. Use um domínio estruturado como `general` ou `osint` quando quiser um esquema fixo definido previamente.
O domínio **general** fornece um esquema fixo com tipos de entidade PERSON, ORGANIZATION, LOCATION, EVENT e DOCUMENT, além de tipos de relação comuns. Útil quando você deseja tipos previsíveis e consistentes entre documentos.
O domínio **osint** adiciona tipos de entidade para empresas de fachada, contas financeiras e jurisdições offshore, além de tipos de relação para rastrear propriedade beneficiária e fluxos financeiros.
Nada é mesclado sem sua aprovação — o LLM propõe, você verifica. Cada extração faz referência ao documento e passagem de origem.
Veja [`examples/transformers/`](https://github.com/juanceresa/sift-kg/blob/HEAD/examples/transformers/) para 12 artigos fundamentais de IA mapeados como um grafo de conceitos (425 entidades, ~$0,72), e [`examples/ftx/`](https://github.com/juanceresa/sift-kg/blob/HEAD/examples/ftx/) para o colapso da FTX (431 entidades de 9 artigos). [**Explore as demonstrações ao vivo**](https://juanceresa.github.io/sift-kg/) — sem instalação, sem chave de API.
## Civic Table
Procurando uma plataforma hospedada com análise forense legal e verificação por analistas?
[**Civic Table**](https://github.com/juanceresa/forensic_analysis_platform) é uma plataforma de inteligência forense construída sobre o pipeline sift-kg. Ela adiciona um sistema de verificação em 4 níveis onde analistas e JDs validam fatos extraídos por IA antes de serem tratados como evidência, geração de dossiês em LaTeX para submissões legais, e uma interface web para compartilhar resultados com clientes e famílias. Construída para restituição de propriedades, jornalismo investigativo e qualquer contexto onde a proveniência documental seja importante.
sift-kg é a CLI de código aberto. Civic Table é a plataforma completa — e onde a saída é revisada por analistas e JDs antes de ter peso probatório.
## Instalação
Requer Python 3.11+.```bash
pip install sift-kg
Para suporte a OCR (PDFs digitalizados, imagens):```bash
brew install tesseract # macOS sudo apt install tesseract-ocr # Ubuntu/Debian
Para o Google Cloud Vision OCR como um backend alternativo (opcional):```bash
pip install sift-kg[ocr]
# Then use: sift extract ./docs/ --ocr --ocr-backend gcv
Para agrupamento semântico durante a resolução de entidades (opcional, ~2GB para PyTorch):```bash pip install sift-kg[embeddings]
Para desenvolvimento:```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` gera um arquivo de configuração do projeto `sift.yaml` para que você não precise de flags em cada comando:```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
Defina sua chave de API no .env:```
SIFT_OPENAI_API_KEY=sk-...
Ou use Anthropic, Mistral, Ollama, ou qualquer provedor LiteLLM:```
SIFT_ANTHROPIC_API_KEY=sk-ant-...
SIFT_MISTRAL_API_KEY=...
Prioridade das configurações: CLI flags > variáveis de ambiente > .env > sift.yaml > padrões. Você pode sobrescrever qualquer coisa do sift.yaml com uma flag em qualquer comando.
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
Lê mais de 75 formatos de documento — PDFs, DOCX, XLSX, PPTX, HTML, EPUB, imagens e muito mais. Extrai entidades e relações usando o LLM configurado. Resultados salvos como JSON em `output/extractions/`.
A flag `--ocr` habilita OCR local via Tesseract para PDFs digitalizados — sem necessidade de chaves de API ou serviços em nuvem. Você pode alternar os mecanismos de OCR com `--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)
Ele detecta automaticamente quais PDFs precisam de OCR — PDFs ricos em texto usam extração padrão, apenas páginas quase vazias recorrem ao OCR. Seguro para pastas mistas. Sem --ocr, o sift avisará se um PDF parecer digitalizado.
Você também pode alternar completamente o backend de extração com --extractor pdfplumber para o backend legado pdfplumber (apenas PDF/DOCX/TXT/HTML).
sift build
Constrói um grafo NetworkX a partir de todas as extrações. Remove automaticamente duplicatas de nomes de entidades quase idênticos (plurais, variantes Unicode, diferenças de maiúsculas/minúsculas) antes que se tornem nós do grafo. Corrige direções de arestas reversas quando o LLM troca os tipos de origem/destino em relação ao esquema do domínio. Sinaliza relações de baixa confiança para revisão. Salva em `output/graph_data.json`.
### 4. Resolver entidades duplicadas
Veja o [Fluxo de Resolução de Entidades](#entity-resolution-workflow) abaixo para o guia completo — especialmente importante para casos de uso genealógico, jurídico e investigativo onde a precisão é crucial.
### 5. Explorar e exportar
**Visualizador interativo** — explore seu mapa conceitual no navegador:```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
Abre um gráfico direcionado por força no seu navegador. A visão geral mostra regiões de comunidade — cascos convexos coloridos agrupando entidades relacionadas — para que você veja a estrutura do gráfico rapidamente sem poluição de rótulos. Passe o mouse sobre qualquer nó para visualizar seu nome e conexões. Inclui pesquisa, alternâncias de tipo/comunidade/relação, filtro de documento fonte, filtro de grau e uma barra lateral de detalhes.
Os sinalizadores de pré-filtro (--top, --neighborhood, --source-doc, --min-confidence) reduzem o gráfico antes da renderização. --community pré-seleciona uma comunidade na barra lateral. --neighborhood aceita IDs de entidade (person:alice) ou nomes de exibição (não diferencia maiúsculas de minúsculas).
Modo foco: Clique duas vezes em qualquer entidade para isolar sua vizinhança. Use as teclas de seta para percorrer as conexões uma a uma — cada par é mostrado isoladamente com arestas rotuladas. Pressione Enter/Seta para a direita para mudar o foco para um vizinho, Backspace/Seta para a esquerda para voltar no seu caminho, Escape para sair. Sua exploração é rastreada como uma migalha de trilha na barra lateral — um caminho persistente mostrando cada nó que você visitou e as relações entre eles. As arestas da trilha permanecem destacadas na tela para que você veja seu caminho através do gráfico. Esta é a maneira pretendida de explorar grafos densos — ampliar o que importa, rastrear conexões, ler as evidências.
Pesquisa CLI — consulte entidades diretamente do 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
**Exportações estáticas** — para ferramentas de análise onde você deseja layout personalizado, filtragem ou estilo:```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
Use GraphML/GEXF quando quiser controlar o dimensionamento dos nós, a ponderação das arestas, esquemas de cores personalizados ou aplicar algoritmos de grafos (centralidade, detecção de comunidades) em ferramentas dedicadas. SQLite é útil para consultas SQL ad hoc, publicação no Datasette ou carregamento no DuckDB.
sift narrate sift narrate --communities-only # regenerate community labels only (~$0.01)
Produz `output/narrative.md` — um relatório em prosa com uma visão geral, cadeias de relacionamento-chave entre as principais entidades, uma linha do tempo (quando existem datas nos dados) e perfis de entidades agrupados por comunidade temática (descoberta via detecção de comunidades de Louvain). As descrições das entidades são escritas em voz ativa com ações específicas, não resumos de papéis.
## Configuração de Domínio
O sift-kg vem com quatro domínios integrados (consulte [Domínios Integrados](#bundled-domains) acima para obter detalhes). O padrão é `schema-free`.
Use um domínio integrado:```bash
sift extract ./docs/ --domain-name osint
Ou crie o seu próprio 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
**Imposição de esquema:** Os tipos de entidade e tipos de relação definidos no seu domínio são tratados como um conjunto fechado — o LLM é instruído a usar apenas esses tipos e não inventará novos. Se `fallback_relation` estiver definido, relacionamentos que não se encaixam em nenhum tipo definido são mapeados para o fallback. Se omitido, o LLM usa o tipo definido mais próximo com menor confiança. Se você vir muitas relações caindo no seu tipo fallback, seu esquema provavelmente está perdendo um tipo de relação que os dados precisam — adicione-o e reextraia.
Tipos de entidade com `canonical_names` impõem um vocabulário fechado. Os nomes permitidos são injetados no prompt de extração do LLM para que ele produza correspondências exatas. Como rede de segurança, qualquer nome extraído que não esteja na lista é reclassificado para `canonical_fallback_type` durante a construção do grafo (ou mantido como está se nenhum fallback estiver definido). Útil para taxonomias controladas — departamentos, jurisdições, classificações predefinidas.```bash
sift extract ./docs/ --domain path/to/domain.yaml
Use o sift-kg a partir do Python — Jupyter notebooks, scripts, aplicações 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"))
## Estrutura do Projeto
Após executar o pipeline, seu diretório de saída contém:```
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
Quando você está construindo um grafo de conhecimento a partir de registros familiares, petições legais ou quaisquer documentos onde a precisão importa, você deseja controle total sobre quais entidades são mescladas. O sift-kg nunca mescla nada sem sua aprovação.
O fluxo de trabalho possui três camadas, cada uma capturando diferentes tipos de duplicatas:
sift build)Antes que as entidades se tornem nós do grafo, o sift colapsa deterministicamente nomes que são obviamente iguais. Sem envolvimento de LLM, sem custo, sem necessidade de revisão:
Isso acontece automaticamente toda vez que você executa sift build. Estes são os casos triviais — variantes ortográficas que poluiriam seu grafo sem adicionar informação.
sift resolve)O LLM vê lotes de entidades (todos os tipos exceto DOCUMENT) e identifica aquelas que provavelmente se referem à mesma coisa do mundo real. Ele também detecta duplicatas entre tipos (mesmo nome, tipo de entidade diferente) e propõe relações de variante (EXTENDS) quando encontra padrões de pai/filho. Os resultados vão para merge_proposals.yaml (mesclagens de entidades) e relation_review.yaml (relações variantes), todos começando como DRAFT:```bash
sift resolve # uses domain from sift.yaml
sift resolve --domain osint # or specify explicitly
Se você tiver um domínio configurado, o LLM usa esse contexto para fazer melhores julgamentos sobre nomes de entidades específicas do seu campo.
Isso gera propostas como:```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'.
Nada foi mesclado ainda. O LLM está propondo, não decidindo.
Você tem duas opções para revisar propostas:
Opção A: Revisão interativa no terminal```bash sift review
Percorre cada proposta `DRAFT` uma por uma. Para cada, você vê a entidade canônica, os membros propostos para mesclagem, a confiança do LLM e a justificativa. Você aprova, rejeita ou pula.
Propostas de alta confiança (>0.85 por padrão) são aprovadas automaticamente, e relações de baixa confiança (<=0.5 por padrão) são rejeitadas automaticamente:```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
Opção B: Editar o YAML diretamente
Abra output/merge_proposals.yaml em qualquer editor de texto. Altere status: DRAFT para 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:
**Para casos de uso de alta precisão** (genealogia, revisão legal), recomendamos editar o YAML diretamente para que você possa estudar cada proposta cuidadosamente. O arquivo foi projetado para ser legível por humanos.
### Camada 3b: Revisão de Relações
Durante `sift build`, relações abaixo do limiar de confiança (padrão 0.7) ou de tipos marcados como `review_required` na sua configuração de domínio são sinalizadas em `output/relation_review.yaml`:```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)
Mesmo fluxo de trabalho: revise com sift review ou edite o YAML, depois aplique.
Depois de revisar tudo:```bash sift apply-merges
Isto faz três coisas:
1. **Mesclagens de entidades confirmadas** — as entidades membros são absorvidas na entidade canônica. Todas as suas relações são religadas. Os documentos de origem são combinados. Os nós membros são removidos.
2. **Relações rejeitadas** — removidas do grafo completamente.
3. **Propostas EM RASCUNHO** — deixadas intocadas. Você pode voltar a elas mais tarde.
O grafo é salvo de volta em `output/graph_data.json`. Você pode reexportar, narrar ou visualizar o grafo limpo.
### Iterando
A resolução de entidades nem sempre é feita em uma única passagem. Após a mesclagem, novas duplicatas podem se tornar aparentes. Você pode executar novamente:```bash
sift resolve # find new duplicates in the cleaned graph
sift review # review the new proposals
sift apply-merges # apply again
Cada execução é aditiva — decisões anteriores de CONFIRMED/REJECTED em merge_proposals.yaml são preservadas.
As técnicas de pré-deduplicação e agrupamento LLM são inspiradas no KGGen (NeurIPS 2025) por @stochastic-sisyphus. O KGGen usa SemHash para deduplicação determinística de entidades e agrupamento baseado em embeddings para agrupar entidades antes da comparação LLM. O sift-kg adapta esses conceitos ao seu fluxo de trabalho de revisão com intervenção humana.
Por padrão, sift resolve classifica as entidades alfabeticamente e as divide em lotes sobrepostos para comparação LLM. Isso funciona bem quando duplicatas têm grafia semelhante — mas "Robert Smith" (R) e "Bob Smith" (B) acabam em lotes diferentes e nunca são comparados.```bash
pip install sift-kg[embeddings] # sentence-transformers + scikit-learn (~2GB, pulls PyTorch)
sift resolve --embeddings
Isso substitui o agrupamento alfabético pelo agrupamento KMeans em embeddings de frases (all-MiniLM-L6-v2). Nomes semanticamente semelhantes se agrupam independentemente da ortografia.
| | Padrão (alfabético) | `--embeddings` |
|---|---|---|
| Tamanho da instalação | Incluído | ~2GB (PyTorch) |
| Sobrecarga na primeira execução | Nenhum | download do modelo de ~90MB |
| Sobrecarga por execução | Apenas ordenação | Codificação (<1s para centenas de entidades) |
| Duplicatas entre alfabetos | Perdidos se em lotes diferentes | Capturados |
| Grafos pequenos (<100/tipo) | Mesmo resultado | Mesmo resultado |
Recorre ao agrupamento alfabético se as dependências não estiverem instaladas ou se o agrupamento falhar.
## Licença
--community--source-doc--min-confidence--ocr), com fallback opcional para Google Cloud Vision (--ocr-backend gcv)--max-cost para limitar gastos com LLM| Caso de Uso | Abordagem Sugerida |
|---|
| Exploração rápida | sift review --auto-approve 0.85 — aprovar alta confiança, revisar o restante |
| Genealogia / registros familiares | Editar YAML manualmente, --auto-approve 1.0 — revisar cada mesclagem |
| Jurídico / investigativo | sift resolve --embeddings, editar YAML manualmente, usar sift view para inspecionar entre rodadas |
| Corpus grande (1000+ entidades) | sift resolve --embeddings para melhor agrupamento, depois revisão interativa |