Introducing Memgraph Zero and MemGQL: Easy Graph Intelligence for Everyone

We've spent years building the fastest in-memory graph databases on the planet. Today, we're announcing something that takes that work in a new, complementary direction, one that doesn't ask you to move your data at all.

Memgraph Zero is a product line from Memgraph built on an incredibly simple idea: your data should stay where it is, and you should still be able to query it as a graph. No pipelines. No ETL. No waiting for batch jobs before you can ask a question. And the first product in that line, MemGQL, is available today.

The Problems We're Solving

Redundant ETL

The data engineering stack has grown dramatically in complexity over the last decade. Want knowledge graph intelligence over your PostgreSQL tables? You build an ETL job. Want to join your data lake with your graph database? You build another pipeline. Want to keep everything in sync? You hire a team to babysit it all. Even worse, you have 10+ DBMSes, each with many datasets (namespaces, tables, graphs, etc.). The result is a mess of moving parts, stale extracts, and storage duplication. All of this just to ask a question that could theoretically be answered by querying the source data directly.

Memgraph Zero takes the opposite approach: connect, don't collect. Query in place, don't copy. This eliminates:

• Pipeline maintenance: the engineering hours spent keeping ETL jobs alive and up to date
• Data staleness: you're querying the live source, not yesterday's extract
• Storage bloat: no more duplicating data into another warehouse just to join it
• High TCO: copying data just adds to the cost

Agents

Another tectonic shift across the whole software space is the rise of agents, which has rewritten the rules of data access entirely. Agents ask thousands of granular questions per second, dynamically and unpredictably, in response to whatever the world throws at them. Want your agent to reason over a knowledge graph? You point it at a vector store, a graph DB, and a relational table, and pray the data is fresh enough to be useful.

Want it to plan multi-step workflows over live operational data? You build bespoke retrieval pipelines for each tool it might call. Want it to pick the right database engine for the right subtask? You don't, you just pick one and hope it's good enough for everything. The result: agents are bottlenecked by the very infrastructure they depend on.

Memgraph Zero is built for the agentic era: one connection, every engine, live data. Agents query what they need, when they need it, through a single interface that routes to the best underlying technology for each task: graph traversal, relational joins, vector search. This enables:

• Fresh context: agents reason over live source data, not a snapshot from days ago
• Agentic blind spots: modeling benefits from the full power of agentic data mapping and orchestration, in other words, agents benefit from the full power of the data layer beneath them
• Centralized feedback repository: once an agent discovers new data, it should share findings with all other agents in an efficient way

Introducing MemGQL

MemGQL is a federated GQL query engine that implements ISO/IEC 39075, the new international standard for graph query language. It translates standard GQL queries into the native language of whatever backend holds your data, executes them in place, and returns unified results.

Clients connect via the Bolt protocol, which means any Bolt-compatible driver works out of the box. No new protocol. No new client library.

At launch, MemGQL connects to:

• Memgraph and Neo4j (native graph backends)
• PostgreSQL and MySQL (relational databases)
• DuckDB and Apache Iceberg (embedded and data lakes)
• ClickHouse and Apache Pinot (real-time OLAP)

Of course, MemGQL's long-term vision is broader: to serve as a universal semantic layer where agents and humans alike can discover and query any data in the organization. That data may be structured, semi-structured, and unstructured, but it can all be queried through a single interface.

Use Cases

Public-Private Data and Data Sovereignty

You have GDPR-regulated customer profiles in PostgreSQL and a public product catalog in Memgraph. You want to query them together. Today, that means either moving regulated data (bad) or building a custom federation layer (expensive). With MemGQL, you write a single GQL query. The regulated data never leaves PostgreSQL. The join happens at the query layer.

Enterprise Context Sharing

Your organizational chart lives in one system. Your product hierarchy in another. Your ontology lives in a third. Every team that needs a unified view builds its own extract, but with the appropriate access control. MemGQL gives every team a unified graph view without forcing anyone to migrate or share the whole database.

Horizontally Scalable Distributed Compute

Some workloads simply exceed what a single instance can handle. MemGQL can partition queries and materialize intermediate results across a cluster, spreading graph computation horizontally.

Agentic Data Access

AI agents are only as good as the data they can reach. MemGQL provides a single semantic layer where agents can discover and traverse relationships across relational databases, graph stores, and lakehouses using standard GQL, without needing to know where each dataset lives or how to query it natively.

Community and Enterprise

MemGQL is available in two editions, and soon the third one.

MemGQL Community is free. It includes GQL-to-Cypher and GQL-to-SQL translation, the Bolt protocol interface, all eight connector types, multi-connection mode, and MCP server support for agentic workflows. You can connect up to four data sources simultaneously.

MemGQL Enterprise lifts those limits: unlimited connectors, unlimited simultaneous connections, and adds SLA-backed support. Contact us if you're interested.

MemGQL Cloud (Coming Soon) removes the need to manage any underlying infrastructure (physical servers, Linux machines, Docker, k8s, AWS/Azure/GCP). You just need to have a working payment card :)

MemGQL Is Just the Beginning

Memgraph Zero is designed as an extensible platform. MemGQL is the first component, focused on federated querying across existing data sources. Additional capabilities are in development. The philosophy stays the same: graph intelligence should meet your data where it lives, not demand that your data move to meet it; agents need a centralized place to access and share data.

Get Started in Minutes

# 1. Create a Docker network
docker network create memgql-net
 
# 2. Start Memgraph
docker run -d --name memgraph-dev --network memgql-net \
  -p 7687:7687 memgraph/memgraph-mage:latest
 
# 3. Start MemGQL
docker run --name memgql --network memgql-net \
  -p 7688:7688 \
  --env CONNECTOR_TYPE=memgraph-gql \
  --env MEMGRAPH_URI=memgraph-dev:7687 \
  --env BOLT_LISTEN_ADDR=0.0.0.0:7688 \
  memgraph/memgql:latest
 
# 4. Connect
mgconsole --port 7688

The MemrGQL docs includes:

• Quick start guide
• Full list of features
• Working Docker Compose to create setups for every pattern described above
• Much more

We're excited to hear what you build. Find us on Discord or open an issue/discussion under memgraph/memgraph. And if you need it in your Enterprise environment, contact us!

Zero ETL. Query data where it lives. Welcome to Memgraph Zero!