A distributed graph query engine for your existing data.

  • Petabytes
  • Subsecond
  • No data movement

PuppyGraph separates graph modeling and compute from the underlying data storage. Define relationships across your databases, warehouses, and lakehouses, then let applications and AI agents query them without loading a separate graph database.

01 / Architecture

One graph layer across your existing data.

Traditionally, using a separate graph database adds data copies, synchronization pipelines, and another system to operate. PuppyGraph separates graph compute from storage, so applications and AI agents can query relationships across your existing tables.

Before / A separate graph database

More copies. More pipelines. More to maintain.

A separate graph database means copying source data, keeping that copy synchronized, and maintaining another database as your data changes.

Schema changesSync lagIndex tuning
LakehousesWarehousesDatabases
ExtractTransformLoad & sync
Graph databaseAnother copy to keep current
AI agentsApplications
↻ Retries & backfillsBackups & recoveryStorage & capacity

After / With PuppyGraph

Add graph compute to the data you have.

PuppyGraph brings graph modeling and compute to your existing tables. Applications and AI agents can query their relationships without a separate graph database to load and keep in sync.

Your data

Existing data sources

Lakehouses · Warehouses · Databases

  • Apache Iceberg
  • ClickHouse
  • PostgreSQL
  • Databricks
  • Snowflake
  • BigQuery

View all connectors →

PuppyGraph

Graph query engine: no data movement required

Connect

Catalog connections

Locate tables and configure access to each source.

Model

Graph schema

Map tables to entities, relationships, and properties.

Compute

Query execution

Plan graph queries and execute the work across compute nodes.

AI agents

Built-in assistant · Your agents

MCP & query tools

Applications & clients

Product integrations · Query clients

openCypher & Gremlin

02 / Inside the query engine

Graph compute that scales beyond one machine.

Leader nodes compile graph queries into a plan of node and edge operators and optimize it. Compute nodes execute that plan in parallel with a vectorized engine, while your sources only serve the data each query reads.

Inside PuppyGraph / Distributed execution
Compute scales independently of source storageExplore cluster architecture →
Clients & agentsWeb UI · AI Chat · Management APIs · Gremlin · openCypher (Bolt)
Admin, catalog & modeling tools
Query Results
Leader nodesRun 3+ leaders for HA

Parse queries and map graph patterns onto tables using the graph schema.

Graph patternsOptimized graph operator plan

Coordinate distributed execution.

Also serve catalog and modeling tools for the Control Plane.

Distributed execution plan

Compute nodes / Scale out for query capacity

Compute nodeVectorized execution
Compute nodeVectorized execution
Compute nodeVectorized execution
Parallel execution · Data exchange · Caching
Fetch source data in place, filtered at the source where possible
Your existing dataLakehouses & databases

Iceberg · ClickHouse · PostgreSQL · Databricks · Snowflake · BigQuery, and more supported sources →

Load local tables when you need them. External tables are queried directly from your sources. Optional local tables store a copy on compute nodes for faster reads; their freshness depends on your loading and refresh settings.

Explore data access options →

See how PuppyGraph performs on published benchmarks, then test it on your own data and query patterns.

Explore benchmarks →

03 / How it works

Connect. Model. Query.

Connect the tables you already have, define their relationships, and put the graph to work. Follow one supply-chain example from source tables to a supplier-dependency answer.

Step 1 / Connect

Start with your existing tables.

Add a catalog connection with the access settings for your source. The catalog makes its tables available for graph modeling.

Product and component data live in Iceberg; supplier records live in PostgreSQL. One graph model connects them.

Explore supported connectors →

Apache Iceberg

REST catalog + S3
Example catalog
iceberg_supply_chain
  • products
  • components
  • product_components

PostgreSQL

PostgreSQL JDBC
Example catalog
postgres_supply_chain
  • suppliers

Step 2 / Model

Define the relationships.

PuppyGraph uses a labeled property graph: typed nodes and directed edges, with properties on both. A graph schema defines how your source data becomes that model.

Flexible modeling for complex data. Combine multiple tables, use composite identifiers, filter rows, derive fields with expressions, and expand nested arrays.

AI can help build the model. PuppyGraph’s built-in AI assistant can propose entities, relationships, and property mappings for you to review and approve.

A simple mapping example

Source tables & columnsLabeled property graph
Icebergproductsproduct_id · name
Productid · name
Icebergproduct_componentsfrom: product_id
to: component_id
USESProduct to Component
Icebergcomponentscomponent_id
Componentid
Icebergcomponentsfrom: component_id
to: supplier_id
SUPPLIED_BYComponent to Supplier
PostgreSQLsupplierssupplier_id · name
Supplierid · name
This example uses direct column mappings. ID columns identify nodes and are also exposed as id properties; endpoint columns connect the edges.

Step 3 / Query

Query the graph, directly or with agents.

Use openCypher or Gremlin to traverse relationships and retrieve connected records. Agents can use the same engine through MCP or graph query tools.

Agent feedback loop

  1. Understand the ontology

    Entities, relationships, and properties give agents a semantic model for choosing paths and retrieving connected context.

  2. Query with ontology enforcement

    PuppyGraph checks queries against the relationships defined in the model, bringing those semantics into execution.

  3. Query results

    Use connected records to answer or explore further.

    Ontology feedback

    An undefined relationship prompts the agent to revise its approach or recognize a gap in the model.

Refine the next step

Explore GraphRAG & AI agents →
Example question

Which products depend on Supplier S42?

openCypher
MATCH (p:Product)-[:USES]->
      (:Component)-[:SUPPLIED_BY]->
      (s:Supplier {id: "S42"})
RETURN DISTINCT p.id, p.name
ORDER BY p.id
Example result
P100 / PumpP200 / Valve

Both products use Component C10, supplied by S42.

04 / See it work

Put your data’s connections to work.

Download PuppyGraph to model your own data, book a demo to discuss your workload, or join our community to ask questions.

$ docker run -p 8081:8081 \
  -p 8182:8182 -p 7687:7687 \
  puppygraph/puppygraph:latestPulling puppygraph/puppygraph:latestStarting PuppyGraphWeb console listening on 0.0.0.0:8081Gremlin endpoint listening on 0.0.0.0:8182PuppyGraph is running# no pipelines · no second database · no data movement