Vibeleaderboard
Index / tool
Visit github.com
Category
Developer Tools
Rank
No. 1604Tools index

Previous survey · No. 1528 ·

Pricing
Open Source
Type
TOOL
Use case
Data, Retrieval & Knowledge
Interfaces
SDK · CLI
GitHub
12 stars
Date

About

A Python library that implements GraphRAG natively inside PostgreSQL, using an LLM to extract entities and relations into a property graph stored alongside pgvector embeddings, then answering queries by fusing vector similarity, graph traversal, and full-text search. Its key feature is temporal fact resolution — newer documents can supersede or close earlier extracted facts rather than creating contradictory edges — and it reports benchmark results beating Graphiti and other GraphRAG systems on LongMemEval and ECT-QA.

What it does

A Python retrieval layer that turns a document collection into a knowledge graph kept in ordinary Postgres tables. A language model reads each chunk and pulls out named things plus the specific links between them. At question time it blends meaning-based lookup, hops along those links, and keyword matching. The distinctive part is time: when a later filing says the CFO changed, the old fact is marked as ended instead of kept as a rival. Each link records both when it held in the world and when the system learned it, so you can ask what was true then or what was believed then.

Why it's ranked here

Most graph retrieval tools only accumulate, so a corpus spanning years hands the model contradictions. This one closes superseded facts from the order documents arrive, with no dates required from the extractor. The authors report 94.0% on the full 500-question LongMemEval set against 71.2% published for Graphiti with gpt-4o, and list the caveats themselves: different judges, different model generations, one question excluded. Those numbers are self-reported, but the harness and failing cases are said to ship in the repository. Apache 2.0, a database most teams already run, and unusually candid engineering notes make it worth a serious look.

What's good

The code refuses to fail quietly. If the vector extension was missing when a table was built, startup raises an error instead of letting every search return nothing. Embedding failures raise by default, because a stand-in vector from another model would corrupt the index. Vague links such as "relates to" are rejected at extraction, pronouns never become graph nodes, and bare money figures are filtered out. Low-value entities can be archived by an importance score, but archiving is reversible and nothing is deleted. Comments explain the concrete failure behind each choice, such as 80 transcripts collapsing onto one document key.

Tradeoffs

Every indexed chunk costs language model calls for extraction, and more for contradiction checks and cluster summaries, so ingestion is slower and pricier than plain vector search. Answer quality rests on the extraction model; the headline row uses one specific model and a three-model judging panel. The package declares Python 3.9 and up, yet its own config notes that continuous integration exercises 3.11 only. The storage layer reaches into private methods of its companion graph package, which ties upgrades of the two together. Native clustering libraries install by default.

How to use it well

Best fit: teams already on Postgres who need agent memory, contract histories, org charts or quarterly filings where the newest statement should win and older ones stay auditable. Feed documents in the order they were written, give each a stable source and title so re-indexing replaces rather than duplicates, and enable the vector extension before first start. Turn on retrieval telemetry if you want coverage reports or archiving. It is a library, not a service: you bring the database, an OpenAI-compatible endpoint and your own agent loop. For a small, static corpus with no changing facts, plain vector search is cheaper.

Technical notes+

post_graph_rag/engine.py holds the async GraphRAG orchestrator; _valid_at filters by validity time and _known_at by belief time via lexical ISO-8601 comparison. post_graph_rag/graph_store.py builds vertex and edge tables on post_graph's AsyncPostGraph, adds a unique index on (realm, space, lower(name)) and payload indexes on t_created, t_expired and dormant_since, raises SchemaError from _verify_vector_columns, and calls private client methods such as _execute and _fetch. post_graph_rag/extractor.py rejects VAGUE_PREDICATES, pronouns and BARE_QUANTITY names. post_graph_rag/llm.py fails over completions across fallback_models but never embeddings. post_graph_rag/retention.py archives rather than deletes. pyproject.toml notes CI covers Python 3.11 only.

Observed

License
Apache-2.0, with the OSI classifier declared.
Language
Python, requires 3.9 or later; a project comment states CI exercises Python 3.11 only.
Packaging
Published on PyPI as post-graph-rag and installed with pip; built with hatchling.
Dependencies
post-graph, openai, pydantic, igraph, leidenalg.
Interface
Async Python library; no command-line entry point is declared.
Platform
Requires PostgreSQL with the pgvector extension; schema setup raises if the embedding column is missing.
Model backend
Any OpenAI-compatible endpoint for completions and embeddings, with optional fallback completion models.
Benchmarks
LongMemEval and ECT-QA figures are self-reported by the authors with stated methodological caveats.
Data retention
Entity archiving is reversible demotion, not deletion, and requires retrieval telemetry to be enabled.

Read from README.md, pyproject.toml, docs/index.md, post_graph_rag/__init__.py, post_graph_rag/engine.py, post_graph_rag/graph_store.py, post_graph_rag/extractor.py, post_graph_rag/models.py, post_graph_rag/retention.py, post_graph_rag/llm.py.

What it can do

  • Extract entities and relations from documents using an LLM

    Text documents → Property graph of entities and relations

  • Store knowledge graph and vector embeddings natively in PostgreSQL

    Extracted graph data and embeddings → PostgreSQL database records

  • Answer queries by fusing vector similarity, graph traversal, and full-text search

    User query → Query answer

  • Resolve temporal facts by superseding or closing earlier extracted facts with newer documents

    New documents and existing facts → Updated fact graph without contradictions

  • Benchmark performance against other GraphRAG systems

    Benchmark datasets (LongMemEval, ECT-QA) → Comparative performance results

Tags

graphragpostgresqlpgvectorragknowledge-graphllmpythonretrieval

Tech Stack

Python

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.