Zero ETL

Query Data Where It Lives

Memgraph Zero connects to the databases you already run and lets you query across them as a unified graph. No pipelines. One GQL interface.

MemgraphMemgraph

Neo4jNeo4j

PostgreSQLPostgreSQL

ClickHouseClickHouse

DuckDBDuckDB

IcebergIceberg

MemGQL

Routing...

One GQL query

MATCH (u:User)-[:PLACED]->(o:Order)
RETURN u.name, o.total

Done. No data moved.

The problem

Data is scattered. Copying it doesn't scale.

Data lives in silos

Postgres, ClickHouse, Neo4j, Iceberg - each serves a purpose. None holds the full picture.

ETL is expensive and stale

Expensive to build, expensive to maintain, and outdated by the time it runs. It creates a new silo while trying to solve the silo problem.

Agents make it harder

They need data from multiple systems per task and spend tokens rediscovering what other agents already found.

Memgraph Zero

Federated graph queries across any backend

Memgraph Zero is a product line built around a single principle: leave data where it is, query it as a graph.

Postgres

Iceberg

Clickhouse

Memgraph

Zero ETL

MemGQL

idle64

Bolt

MCP

Model Context Protocol

Agent

Calling MCP tool...

GQL

MATCH (n)-[v]-(m) RETURN n, v, m LIMIT 500

Run query

Ready

Run a query to see results

MemGQL

A federated GQL query engine implementing the ISO/IEC 39075 standard. Write a single GQL query - MemGQL translates it into the native language of each target backend and pushes execution down to the source. Zero ETL needed.

How it works

  1. Input

  • GQL query arrives

    A GQL query is sent via Bolt protocol on port 7688 (the default).

    MATCH (u:User)-[:PLACED]->(o:Order)
WHERE o.status = 'PENDING'
  1. Resolution

  • MemGQL resolves target backends

    Reads configured graph mappings to determine which backend holds each part of the query.

    Users → Memgraph

    Orders → PostgreSQL

  1. Translation

  • Query transpiled to native language

    GQL is translated into Cypher or SQL and execution is pushed down to each source.

    → Cypher → SQL

  1. Output

  • Results return

    Results from each backend are merged and returned through a single interface.

    Unified result set returned to client or agent

Built in Rust Bolt protocol (port 7688) Existing drivers, mgconsole, and Memgraph Lab work out of the box

Connectors

Eight connectors. One query layer.

Graph databases

  • Memgraph
  • Neo4j

Relational databases

  • PostgreSQL
  • MySQL

Real-time OLAP

  • ClickHouse
  • Apache Pinot

Embedded & lakehouse

  • DuckDB
  • Apache Iceberg

On the roadmap: MongoDB, Redis, Elasticsearch, Oracle, CSV/Parquet, REST and GraphQL APIs, unstructured data sources.

Usecases

What you can do today

Federated GQL

Execute GQL queries across heterogeneous backends in a single session. Query Memgraph and Postgres in one statement. Union results from Neo4j and ClickHouse. The engine handles translation and routing.

Public-private data

GDPR-regulated records stay in Postgres. Public product catalogs stay in Memgraph. One GQL query joins both without moving regulated data across system boundaries.

Agentic data access

Agents connect via MCP, discover available data sources, and execute GQL queries without knowing where each dataset lives. When one agent finds something, others don't repeat the work.

Cross-system context

Org charts in one database. Product hierarchies in another. Ontologies in a third. MemGQL gives every team a unified graph view without forcing migration.

Two products

Complementary engines. Different trade-offs

Use them independently or together.

Memgraph

The in-memory graph engine

  • Sub-millisecond traversals, real-time writes, deep path algorithms, graph analytics. Data lives in memory for maximum performance.
  • Best for: GraphRAG, AI Memory, fraud detection, network analysis.

Memgraph Zero

The federated query layer

  • Data stays in source systems. Queries are translated and pushed down. Best when data is distributed and copying it is impractical or prohibited.
  • Best for: distributed data, regulated data, multi-system agents.

Together

Best of both

Memgraph serves as the high-performance caching and analytics layer inside Memgraph Zero. Pull data from Postgres or Iceberg into Memgraph for deep traversals, then let MemGQL route queries to whichever backend fits.

Editions

Community and Enterprise

01 Community

Free · Available on Docker Hub

For developers evaluating and building with Memgraph Zero.

  • 2 connectors
  • 2 simultaneous connections
  • MCP server
  • Agentic mapping
  • Full GQL query support

02 Enterprise

Custom pricing

For teams running Memgraph Zero in production.

  • Unlimited connectors
  • Unlimited simultaneous connections
  • Priority support
  • Compliance and security features as they ship

What's next

Early and moving fast

Launched May 2025. GQL-to-Cypher translation has the strongest coverage today. SQL push-down support is expanding across all backends.