PgGraph
PgGraph turns existing PostgreSQL tables into a traversable graph so multi-hop queries run as index lookups instead of join chains.
If your hard queries are permission paths, fraud rings, or agent-memory hops and your data already lives in Postgres, PgGraph removes the second database from the picture entirely — that's the whole win. The engine is aimed, not general: it traverses, it does not do PageRank or community detection. Buy it for the query shape, not for the category.
Verified 5d ago · liveness 64/100 · cite: rightaichoice.com/tools/pggraph
- Developers building AI agents on Postgres who need graph traversal over relational data
- SaaS teams with complex permission models that map cleanly to path queries
- Fintech and marketplace platforms running real-time multi-hop fraud checks
- Platform engineers doing dependency mapping and blast-radius analysis
- Teams wanting a standalone graph database with its own storage engine
- Anyone needing graph visualization or a query UI out of the box
- Groups without the appetite to self-host and operate a Rust service
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip PgGraph if you want a standalone graph database with its own storage engine, out-of-the-box graph visualization, or heavy graph analytics like PageRank and community detection, rather than traversal over tables you already run in Postgres.
Evokoa publishes PgGraph as an open-source, self-hosted PostgreSQL extension and points buyers at Polygres for the commercial virtual layer — so the cost you actually carry is engineering time to run and operate a Rust service next to your database, not a licence line item. Price it against the operational load of keeping a second graph store in sync instead.
In short
PgGraph — PgGraph turns existing PostgreSQL tables into a traversable graph so multi-hop queries run as index lookups instead of join chains. Best for Developers building AI agents on Postgres who need graph traversal over relational data, SaaS teams with complex permission models that map cleanly to path queries, Fintech and marketplace platforms running real-time multi-hop fraud checks. Free to use.
What's new in PgGraph
Checked 5 days agoAcross the latest 3 updates: 3 news mentions.
Postgres as a Graph Database: Four Approaches Compared
Compares recursive CTEs, materialized paths, and in-memory traversal engines, showing when each breaks down and why PgGraph's approach wins for performance.
Buying pggraph.com: A Domain Meant to Be
Evokoa acquired pggraph.com for $10, signaling brand commitment and saving fifty grand.
Lessons from John Carmack: Why We Built pgGraph Like a Game Engine
Details how game engine design principles influenced PgGraph's memory layout, hot loop, and abstraction removal.
What people actually say about PgGraph — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
7 mentions across 3 sources (Hacker News, YouTube, GitHub), 24 more we could not attribute · researched Sep 23, 2026.
Weighted by the 31 posts each of 3 sources contributed.
- +Turns multi-hop graph traversal into index lookups instead of slow join chains
- +Zero data migration — works on your existing Postgres foreign keys and IDs
- +Rust engine with sub-millisecond target latency and 34x less RAM claim
- +Keeps Postgres as single source of truth — no second data store to sync
- +Actively maintained: composite-PK junction bug fixed the same day reported
- −shortest_path() missing edge_types filter that expand()/traverse() already support
- −~21% of per-call overhead spent on duplicate graph resolution, per open issue
- −Docs lack troubleshooting for common new-user errors like missing ::regclass cast
- −Memory footprint for large schemas is an unanswered community question
- −Only v0.1.5 — very early, with essentially no long-tail production case studies yet
- • RAM headroom for the in-memory graph index on large schemas
- • Engineering time to work around missing edge_types on shortest_path()
- • Potential migration cost later if you move from the OSS extension to Polygres
Viability Score
How well maintained and how widely used is PgGraph? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- BFS traversal executed as index lookups
- Dijkstra traversal executed as index lookups
- Multi-hop path queries without chained joins or recursive CTE chains
- Live hydration of rows from the PostgreSQL source of truth
- Lightweight in-memory relationship index
- Rust-based engine built on game-engine memory layout principles
- Builds the graph from existing foreign keys and primary IDs
- Zero data migration or schema rewrite
- Standard PostgreSQL compliant
- Open source under the Evokoa GitHub organization
- Concurrent read/write safe
- Path queries for permission and access checks
- Agentic memory for AI agents
- Real-time multi-hop fraud-ring detection
- Dependency and blast-radius analysis
About PgGraph
PgGraph is an open-source PostgreSQL extension from Evokoa, the San Francisco research and engineering company behind WonderSearch and Polygres. It reads the foreign keys and IDs already sitting in your schema, builds a lightweight in-memory relationship index, and traverses that index — so a multi-hop path query becomes a sequence of lookups rather than a recursive CTE or a pile of chained joins. Rows are then hydrated live from Postgres itself, which keeps your database the single source of truth. No ETL, no shadow datastore, no schema rewrite. Evokoa is unusually clear about where this sits. PgGraph is the graph engine; its sibling pgContext handles AI search and retrieval; both are the open-source foundations under Polygres, the company's commercial virtual layer that unifies graph, vector and full-text retrieval over PostgreSQL. The parent company calls Polygres its flagship and points buyers at polygres.com for docs and onboarding. That hierarchy matters when you're deciding what to actually install. Who it's for: developers who already live in Postgres but need graph-shaped answers — agent memory for AI applications, permission and access-path checks, fraud-ring detection, dependency and blast-radius mapping. The design intent is documented rather than implied. A 2026-05-17 post compares recursive CTEs, materialized paths and in-memory traversal engines and argues the last holds up where the others degrade; a 2026-05-13 piece traces the Rust memory layout and hot loop back to game-engine principles. On 2026-05-14 Evokoa bought pggraph.com for $10, which tells you how seriously they intend to keep the name. Positioning-wise this is not a Neo4j or Amazon Neptune replacement — it's graph capability bolted onto the database you already operate. Teams that want a managed, batteries-included graph platform should look at Polygres or a dedicated graph database instead.
Behind the Verdict
We'd reach for PgGraph the moment a query turns into three CTEs stacked on each other. That's the actual trigger. If you've ever written a recursive CTE to answer "can this user reach that record," you already understand the problem it solves, and you already know how ugly the workaround is. Pick this when the graph is a layer, not a product. Permission and access-path resolution, fraud-ring lookups, dependency and blast-radius mapping, agent memory over relational rows — all of these are traversals over relationships you already model with foreign keys. PgGraph builds that graph from what's in your schema, so adoption is an extension install rather than a migration project. The Rust engine and the pointer-chasing memory layout are the interesting engineering, and Evokoa's own writeup on why they copied game-engine hot-loop discipline is worth ten minutes before you commit. Pass when you need a graph platform rather than graph traversal. There's no query console, no visualization, no community-detection or centrality algorithms. Heavy analytics — PageRank, clustering, graph embeddings — belongs in Neo4j, Amazon Neptune, or something purpose-built. And if you don't want to self-host and operate a Rust service alongside your database, this is the wrong shape of tool; a hosted layer is the honest answer. Compared to the closest alternative, recursive CTEs: CTEs are free and already installed, and for two or three hops they are fine. The argument Evokoa makes, and the one that holds up in their May 2026 comparison post, is about where each approach degrades — materialized paths go stale, deep recursion gets expensive, in-memory index traversal stays roughly flat. Test that claim on your own data before you buy it wholesale. In practice, the caveats are operational, not
Researching PgGraph? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas PgGraph actually fits — and what changes day-one when you adopt it.
Install the pgGraph extension on the existing schema, let it read the foreign keys between customers, contracts and SLAs, then issue multi-hop path queries that return as index lookups with rows hydrated live from Postgres.
Outcome: The agent gets graph-shaped context without a second database, an ETL pipeline, or a denormalized copy of the data to keep in sync.
Model role-resource-workspace relationships as path queries instead of recursive CTEs, and run dependency and blast-radius checks before shipping a schema or service change.
Outcome: Permission resolution keeps working on the source-of-truth tables, and impact analysis answers 'what breaks if this changes' from the same database.
Traverse multi-hop connections between devices, accounts and merchants as they are recorded, looking for fraud rings that only appear two or three hops out.
Outcome: Ring detection runs in real time against live relational data, with no nightly export into a separate graph platform.
Use Cases
- Enable AI agents to traverse customer-to-contract-to-SLA relationships without chained joins.
- Detect fraud rings by querying multi-hop connections between devices, accounts, and merchants.
- Build support copilots that pull full customer context across tickets, invoices, and approvals.
- Enforce permission checks by resolving role-resource-workspace chains without denormalization.
- Perform impact analysis to see what breaks if a service, supplier, or record changes.
Limitations
- PgGraph is a PostgreSQL extension (pgGraph), one of the open-source engines Evokoa develops behind its commercial Polygres virtual layer.
- The evidence describes it as bringing graph queries and relationship traversal to Postgres as a relationship layer over existing data, so its usefulness depends on the underlying Postgres schema and permissions.
- Evokoa's product pages emphasize Polygres as the paid platform (graph, vector, and full-text search combined), while PgGraph itself is presented only as the open-source graph engine.
as of 2026-10-03
Verification history
We have re-verified PgGraph 9 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 9 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published PgGraph tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source
$0
Ideal for
Postgres-first engineering teams with the appetite to self-host an extension and a Rust traversal service alongside their existing database.
What this tier adds
Starting tier: no licence fee, self-hosted, and the graph engine sits on top of tables you already run.
Where the pricing makes sense
The company stage and team size where PgGraph's pricing actually pencils out — and where peers do it cheaper.
Evokoa publishes PgGraph as an open-source, self-hosted PostgreSQL extension and points buyers at Polygres for the commercial virtual layer — so the cost you actually carry is engineering time to run and operate a Rust service next to your database, not a licence line item. Price it against the operational load of keeping a second graph store in sync instead.
Setup time & first value
How long it actually takes to get something useful out of PgGraph — broken out by persona, not the marketing-page minute.
If you already operate Postgres, first value is short: install the extension, point it at your existing foreign keys and IDs, and run a traversal — there is no data migration or schema rewrite in the path. The longer tail is operational, since the open-source build is self-hosted and you are running a Rust service alongside your database.
Switching to or from PgGraph
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From recursive CTEs: replace multi-hop WITH RECURSIVE chains with pgGraph traversals that execute as index lookups and hydrate rows from Postgres.
- →From materialized paths: drop the maintained path column and let pgGraph's in-memory relationship index answer the same multi-hop queries.
- →From a separate graph database: keep your Postgres schema as the source of truth and move traversal queries onto pgGraph instead of syncing a second store.
- ↗To Neo4j or Amazon Neptune: export the relational data into a dedicated graph storage engine when you need property-graph modelling, native graph analytics, or graph visualization.
- ↗To Polygres: move up to Evokoa's commercial virtual layer when you want graph, vector and full-text retrieval unified and managed rather than self-hosted.
- ↗Back to plain Postgres: drop the extension and rewrite multi-hop traversals as recursive CTEs if graph-shaped queries stop being worth the extra service.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “PgGraph”, and we withheld 6: 6 could not be judged, because “PgGraph” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about PgGraph.
Official links
Tools that pair well with PgGraph
Common stack mates teams adopt alongside PgGraph, with the specific reason each pairing earns its keep.
TablePlus
TablePlus is a native database GUI for MySQL, PostgreSQL and SQLite with a one-time license.
Lance
Lance is an open lakehouse format for multimodal AI, pairing a file format, table format, and catalog spec with hybrid vector and full-text search on object
Dbhub
DBHub is a minimal database MCP server that connects Claude Code, Cursor, and VS Code to PostgreSQL, MySQL, SQL Server, MariaDB, Oracle,
Featured Head-to-Head Comparisons
Pggraph vs Spider Cloud
PgGraph and Spider Cloud solve entirely different problems: PgGraph is a virtual graph layer for querying relationships in your existing Postgres without moving data, while Spider Cloud is a web scraping API for feeding real-time web data into AI agents. Choose PgGraph if you need graph queries on your own database; choose Spider Cloud if you need to extract and structure external web content.
Pggraph vs Temporal Ai
PgGraph is ideal if you need fast graph queries on existing Postgres data without moving it; it's free and lightweight. Temporal AI is the better pick for teams needing durable, fault-tolerant orchestration of AI agents and workflows, with rich SDKs and cloud options. Your choice depends on whether your core need is graph analytics or reliable execution.
Pggraph vs Screenplayiq
If you are a developer needing graph queries on Postgres without data duplication, PgGraph is a free, high-performance open-source solution. If you are a screenwriter or producer seeking data-driven script analysis and box office predictions, ScreenplayIQ offers specialized AI features with tiered pricing. The tools serve entirely different audiences; choose based on your domain.
Alternatives to PgGraph
View all
Frequently Asked Questions
Used PgGraph? Help shape our editorial sentiment research.