The context layer for AI agents

Open-Source
Multi-Model Graph Database

Supporting Graphs, Documents, Key/Value, Search Engine, Vectors, and Time-Series

ArcadeDB is an open-source, Apache 2.0 licensed multi-model database developed by Arcade Data Ltd. It natively stores graphs, documents, key-value pairs, BM25-ranked full-text search, vectors, and time-series in a single engine, with no polyglot persistence required. ArcadeDB supports SQL, OpenCypher, Gremlin, GraphQL, and the MongoDB query protocol, delivering over 10 million records per second with full ACID compliance. Manage complex data models without compromise: native multi-model support means no translation layers and no performance penalties.

⚡ Open Source • Apache 2.0 Licensed

docker run --rm -p 2480:2480 -e JAVA_OPTS="-Darcadedb.server.rootPassword=playwithdata" arcadedata/arcadedb:26.11.1

Running in 30 seconds. Then open http://localhost:2480. Prefer Kubernetes, Maven or Python? See all deployment options.

Partner Tom Sawyer Software builds its Digital Engineering suite on ArcadeDB as the graph database backbone. Case study

“Graph structure is useful only when the connections are trustworthy.”

Oleg Cohen, Founder, Kainora Case study

“It gives you graph traversal, vector search, and genuine ease of use in a single engine.”

Muzi Khuzwayo, Founder & CEO, Dubstrata Verified Tested with Jepsen Consistency checked with the open-source Jepsen framework: 44 of 44 tests passing.

What is ArcadeDB?

ArcadeDB is an open-source multi-model graph database built for modern applications that need more than one data shape. A single engine handles graph traversals, JSON documents, key-value lookups, vector similarity, BM25-ranked full-text search (fusable with vectors in one query), and time-series workloads, with full ACID transactions and a query engine that speaks SQL, Cypher, Gremlin, GraphQL, and MongoDB. Whether you run it embedded inside a Java application or as a distributed server, ArcadeDB is built for speed: fast on a laptop, fast in production, and free forever under the Apache 2.0 license.

True Multi-Model Architecture

Manage complex models using ArcadeDB without any compromise. Forget about Polyglot Persistence: no need for multiple databases. You can store graphs, documents, key values, search engine, vectors and time-series all in one ArcadeDB Multi-Model database. Since each model is native to the database engine, you don't have to worry about translations slowing you down. New to the idea? Our guide to what a multi-model database is explains how it differs from polyglot persistence.

Explore the Multi-Model

ArcadeDB multi-model diagram: graph, document, key-value, search, vector and time-series data in one engine

How ArcadeDB Works

One server, six query languages, six data models, zero compromises.

HTTP / Protocol flow

Data model routing

Storage layer

SELECT FROM Person
WHERE name = 'John'
AND age > 25
ORDER BY age DESC
LIMIT 10

MATCH (p:Person)
WHERE p.name = 'John'
  AND p.age > 25
RETURN p
ORDER BY p.age DESC
LIMIT 10

g.V().hasLabel('Person')
  .has('name', 'John')
  .has('age', gt(25))
  .order().by('age', desc)
  .limit(10)

query {
  persons(
    where: {
      name: { _eq: "John" }
      age: { _gt: 25 }
    }
    orderBy: { age: DESC }
    limit: 10
  ) {
    name
    age
  }
}

ResultSet result = database.select()
    .from("Person")
    .where()
    .property("name").eq().value("John")
    .and()
    .property("age").gt().value(25)
    .orderBy("age", false)
    .limit(10)
    .vertices()

db.Person.find({
  name: "John",
  age: { $gt: 25 }
})
.sort({ age: -1 })
.limit(10)

Multiple Query Languages

Query your data using the language you're most comfortable with. ArcadeDB natively supports SQL, Cypher (latest OpenCypher 25 grammar, with ISO GQL syntax in the same engine), Gremlin, GraphQL, MongoDB query language, and a native Java API. The same query, your choice of language. No compromises, no performance penalties.

Explore Query Languages

Fast and Scalable

ArcadeDB's engine was built with Alien Technology. It's able to crunch millions of records per second. With ArcadeDB, the traversing speed is not affected by the database size. It is always constant, whether your database has a few records or billions. The fastest OLTP graph engine, now paired with a built-in Graph OLAP engine delivering up to 400x faster analytics, verified by LDBC Graphalytics benchmarks. ArcadeDB can work as an embedded database, as a client/server with 8 wire protocols, and can scale up using multiple servers with Kubernetes. Flexible enough to run on any platform with a small footprint.

Indestructible

Your data is secure. Our unbreakable fully transactional engine assures durability for mission-critical production databases. All the changes are saved to a persistent Journal (Write Ahead Log). In case of a crash of the server, the uncommitted transactions are automatically rolled back. ArcadeDB uses a Raft Consensus Algorithm to maintain consistency across multiple servers. The cluster is put through an open-source Jepsen test suite with network partitions, crashes, pauses, clock skew and power loss, checked with Knossos and Elle. Read how Raft high availability, ACID transactions with MVCC and durability settings work on our HA and Reliability page.

Integration & Compatibility

ArcadeDB supports SQL, GraphQL, OpenCypher 25 (the latest Cypher specification) and Gremlin for queries. ArcadeDB Server supports HTTP/JSON natively and is compatible with Postgres wire protocol, Redis and MongoDB. You can easily migrate your existing database from OrientDB and Neo4j in just a few minutes. Plug ArcadeDB into your stack with ready-made integrations for LangChain, LlamaIndex, Haystack, Cognee, Grafana, Prometheus and OpenTelemetry. Give AI agents direct access through the built-in MCP server, and find official drivers, wire protocols and runnable samples for Java, Python, TypeScript, Go and .NET in the Developer Center.

How ArcadeDB Compares

One database. Every model. Truly open source.

Feature	ArcadeDB Free & Open Source	Neo4j	TigerGraph	ArangoDB	SurrealDB
License	Apache 2.0	GPL v3 / Commercial	Proprietary	BSL 1.1	BSL 1.1
Graph model	Native	Native	Native	Native	Native
Document model	Native	Via properties	No	Native	Native
Vector search	Native	Enterprise only	Limited	Yes	Native (HNSW)
Time-series	Native + PromQL	No	No	Manual	Partial
Graph algorithms	70 built-in native · Apache 2.0 · no limits	~65 via GDS plugin GPLv3 · 4-core limit · Enterprise for production	~70 GSQL scripts not native · 300 GB free cap	None Pregel removed in v3.12	3 path primitives no analytics algorithms
Query languages	8 languages SQL · Cypher + GQL · Gremlin · GraphQL · MongoDB · Java · Redis · PromQL	Cypher / GQL	GSQL	AQL	SurrealQL, GraphQL
High Availability	Native (Raft)	Enterprise only	Enterprise only	Enterprise only	Paid tier
Enterprise features free	All features free	Paid tier	Commercial only	Partially	Paid tier

The Fastest OLTP & OLAP Graph Database

LDBC Graphalytics benchmark: the industry standard for graph analytics performance.

Values are execution time in seconds: lower is better. ArcadeDB leads on every algorithm. Explore the interactive benchmarks dashboard or reproduce the results from public code.

PageRank Benchmark

Execution time in seconds (lower is better)

ArcadeDB

0.48s

FalkorDB

1.67s

Kuzu

4.30s

DuckPGQ

6.14s

Neo4j 2026

11.15s

Memgraph

16.90s

ArangoDB

157.01s

0s 40s 80s 120s 157s

Algorithm	ArcadeDB Graph OLAP Engine	Neo4j 2026	Kuzu	DuckPGQ	Memgraph	ArangoDB	FalkorDB
PageRank	0.48s	11.15s	4.30s	6.14s	16.90s	157.01s	1.67s
Connected Components (WCC)	0.30s	0.75s	0.43s	13.93s	crash	78.03s	0.85s
Breadth-First Search (BFS)	0.13s	1.91s	0.86s	2,754s	11.72s	511.55s	0.20s
Local Clustering Coefficient	27.41s	45.78s	N/A	38.59s	N/A	N/A	N/A
Single-Source Shortest Path	3.53s	N/A	N/A	N/A	N/A	301.93s	N/A
Community Detection (CDLP)	3.67s	6.43s	N/A	N/A	N/A	407.41s	5.38s

Explore the Live Benchmarks Dashboard View Full Benchmark Results on GitHub

Getting Started

Choose your preferred installation method and start building in minutes

Run ArcadeDB Server with Docker using a demo database:

docker run --rm -p 2480:2480 -p 2424:2424 \
  -e JAVA_OPTS="-Darcadedb.server.rootPassword=playwithdata \
  -Darcadedb.server.defaultDatabases=Imported[root]{import:https://github.com/ArcadeData/arcadedb-datasets/raw/main/orientdb/OpenBeer.gz}" \
  arcadedata/arcadedb:26.11.1

Open your browser on http://localhost:2480 to access ArcadeDB Studio. Login with username "root" and password "playwithdata".

Store the ArcadeDB Server root password as a secret:

kubectl create secret generic arcadedb-credentials \
  --from-literal=rootPassword='<password>'

Add the official ArcadeDB Helm repository:

helm repo add arcadedb https://helm.arcadedb.com/
helm repo update

Install a cluster with 3 servers:

helm install my-arcadedb arcadedb/arcadedb \
  --set replicaCount=3 \
  --set image.tag=26.11.1 \
  --set arcadedb.credentials.rootPassword.secret.name=arcadedb-credentials \
  --set arcadedb.credentials.rootPassword.secret.key=rootPassword \
  --wait

Download and install ArcadeDB on premise. You need Java 21 or more recent. Run the server from a shell:

$ bin/server.sh


 █████╗ ██████╗  ██████╗ █████╗ ██████╗ ███████╗██████╗ ██████╗
██╔══██╗██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔════╝██╔══██╗██╔══██╗
███████║██████╔╝██║     ███████║██║  ██║█████╗  ██║  ██║██████╔╝
██╔══██║██╔══██╗██║     ██╔══██║██║  ██║██╔══╝  ██║  ██║██╔══██╗
██║  ██║██║  ██║╚██████╗██║  ██║██████╔╝███████╗██████╔╝██████╔╝
╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚═════╝ ╚══════╝╚═════╝ ╚═════╝
PLAY WITH DATA                                    arcadedb.com

The first time the server runs, you'll be prompted to set a password for the root user.

Run ArcadeDB Console:

$ bin/console.sh
ArcadeDB Console v.26.11.1 - Copyrights (c) 2026 Arcade Data

>

In Embedded mode your application and the database share the same space in the JVM for blazing fast performance.

Update your Maven pom.xml file and add the dependency:

<dependency>
  <groupId>com.arcadedb</groupId>
  <artifactId>arcadedb-engine</artifactId>
  <version>26.11.1</version>
</dependency>

Create the database with a basic schema and a graph:

try( Database db = new DatabaseFactory( "Heroes" ).create() ) {
  db.getSchema().createVertexType("Hero");
  db.getSchema().createEdgeType("IsFriendOf");

  db.transaction( () -> {
    Vertex jay = db.newVertex("Hero")
      .set("firstName", "Jay")
      .set("lastName", "Miner")
      .save();
    Vertex elon = db.newVertex("Hero")
      .set("firstName", "Elon")
      .set("lastName", "Musk")
      .save();
    jay.newEdge("IsFriendOf", elon, "since", "1990");
  });
}

Query using OpenCypher (Cypher 25 grammar):

ResultSet result = db.query("cypher",
  "MATCH (h:Hero {firstName: 'Elon', lastName: 'Musk'})-[:IsFriendOf]-(friend) RETURN friend.firstName AS name");
while( result.hasNext() ) {
  String name = result.next().getProperty("name");
  System.out.println( name );
}

Join the Community

We're looking forward to your contribution. Help the project with code, tests, documentation, and more.

GitHub Discussions

Join the conversation, ask questions, and share your knowledge with the community.

Discord Server

Chat with the team and other community members in real-time.

A Sustainable Open Source Foundation

ArcadeDB is led by Arcade Data, the company behind the ArcadeDB division, operating as a foundation model where sponsorships are reinvested into hiring talented contributors rather than maximizing profit. Built by volunteers and dedicated employees working together, this approach ensures sustainable growth focused on long-term project success.

We've seen too many open-source databases pull the rug: Redis, MongoDB, Elasticsearch, Terraform, and others switched to restrictive licenses after communities helped build them. ArcadeDB is Apache 2.0, and we will never change it. No bait-and-switch. No "open core" that hides critical features behind a paywall. No cloud-only editions. The full database, every feature, is and will remain truly open source.

By sponsoring ArcadeDB, you're investing in the growth of the project and helping us expand the team, while building on a foundation you can trust for the long term.

Learn About Sponsorship Read Our License Commitment

Community & Professional Collaboration

Built by passionate volunteers and dedicated Arcade Data employees working together towards a common goal.

Reinvestment, Not Profit

Sponsorships are reinvested to hire more talented contributors, accelerating development and expanding capabilities.

Apache 2.0 Forever

We publicly commit to never changing our license. No bait-and-switch, no restrictive relicensing. Every feature, every model, truly open source, forever.

Pricing and License

Open Source

FREE Forever

ArcadeDB is FREE for any usage (Apache 2 License), no strings attached. Every feature and every model (graph, document, key-value, vector, time-series, full-text search) is included. No "enterprise edition", no cloud-only features.

View on GitHub Download Latest Release

Enterprise Support

Production support subscriptions with SLAs, priority bug fixes, and direct access to core developers. Get the confidence your team needs to run ArcadeDB in mission-critical environments.

View Plans

Custom Development & Consultancy

Need a custom integration, a tailored data model, or architecture guidance? Our team builds custom implementations and provides hands-on consultancy to accelerate your project.

Get in Touch

Fund the Project

Anyone can support ArcadeDB starting from just $5/month. Every contribution is shared with active committers: a sustainable model where sponsorships directly fund the people who build the software.

Become a Sponsor

Frequently Asked Questions

What is ArcadeDB?

ArcadeDB is an open-source, Apache 2.0 licensed multi-model graph database that natively supports graphs, documents, key-value pairs, BM25-ranked full-text search, vectors, and time-series data in a single engine. It eliminates the need for polyglot persistence by handling all data models without performance-degrading translation layers.

Is ArcadeDB free?

Yes. ArcadeDB is completely free under the Apache 2.0 license with no usage limits, no enterprise edition paywalls, no cloud-only features, and no bait-and-switch licensing. Every feature (including HA replication, multi-model support, and all six query languages) is included at no cost.

What query languages does ArcadeDB support?

ArcadeDB natively supports SQL, OpenCypher 25 (the latest Cypher specification), Gremlin, GraphQL, the MongoDB query protocol, and a Java API. The Cypher engine also accepts ISO GQL syntax, so GQL and Cypher 25 can be mixed in one query; see the GQL coverage statement for what is supported feature by feature. All languages access the same underlying data with no performance penalty.

Which version of the OpenCypher specification does ArcadeDB implement?

ArcadeDB implements the latest OpenCypher 25 grammar (Cypher 25), with a native engine that has passed 97.8% of the official OpenCypher TCK. This brings ArcadeDB in line with current Cypher tooling, documentation, and modern syntax features.

How does ArcadeDB compare to Neo4j?

ArcadeDB is fully open source under Apache 2.0 with no community vs. enterprise edition split, while Neo4j restricts many enterprise features behind a commercial license. ArcadeDB supports multiple data models natively (graph, document, key-value, vector, time-series), whereas Neo4j is primarily a graph database. ArcadeDB also supports Cypher, Gremlin, GraphQL, and SQL, not just Cypher.

How does ArcadeDB compare to MongoDB?

MongoDB is primarily a document database. ArcadeDB adds native graph traversal, key-value, full-text search, and vector support alongside document storage in a single engine. ArcadeDB is also fully Apache 2.0, while MongoDB uses SSPL for its server-side code.

Can I migrate from Neo4j or OrientDB to ArcadeDB?

Yes. ArcadeDB ships with built-in importers for both Neo4j and OrientDB, enabling migration in minutes without manual data transformation.

How do I install ArcadeDB?

ArcadeDB can be installed via Docker (docker run arcadedata/arcadedb:26.11.1), downloaded as a binary from GitHub Releases, embedded in a Java application via Maven (groupId: com.arcadedb, artifactId: arcadedb-engine), or deployed on Kubernetes using the official Helm chart.

What license does ArcadeDB use?

ArcadeDB uses the Apache License 2.0, an OSI-approved open source license. Arcade Data Ltd has publicly committed to never changing this license. Unlike MongoDB (SSPL), Redis (RSALv2), Elasticsearch (SSPL), and ArangoDB (BSL), ArcadeDB will remain truly open source.

Can ArcadeDB run embedded?

Yes. ArcadeDB can be embedded directly inside a Java application as a library, or run as a standalone server with a binary protocol, HTTP REST, and Postgres wire protocol.

Is ArcadeDB ACID-compliant?

Yes. ArcadeDB provides full ACID transactions for both single-node and distributed deployments.

What is ArcadeDB used for?

Common use cases include knowledge graphs, GraphRAG and AI memory, fraud detection, recommendation engines, real-time analytics, customer 360, supply-chain analytics, and AI/ML feature stores.

Does ArcadeDB have built-in vector search?

Yes. Vector search is native to the engine rather than a plugin or a companion service. Embeddings are stored in a property, indexed with HNSW using COSINE, EUCLIDEAN, or DOT_PRODUCT similarity, and queried in SQL with the vector.neighbors() function alongside graph traversal in the same statement.

Does ArcadeDB support BM25 full-text search?

Yes. BM25 is the default ranking for every full-text index in ArcadeDB, with tunable k1 and b parameters and per-field boosts, and EXPLAIN shows how each query term is scored. Because the full-text index lives in the same engine as the vector indexes and the graph, a single query can fuse BM25 keyword relevance with dense and sparse vector similarity using Reciprocal Rank Fusion, then traverse relationships from the top results. Indexes created before BM25 support keep the legacy ranking until they are rebuilt. See the full-text and BM25 documentation.

Open-Source Multi-Model Graph Database

What is ArcadeDB?

True Multi-Model Architecture

How ArcadeDB Works

Multiple Query Languages

Fast and Scalable

Indestructible

Integration & Compatibility

How ArcadeDB Compares

Migrating from Neo4j?

The Fastest OLTP & OLAP Graph Database

PageRank Benchmark

Getting Started

Join the Community

GitHub Discussions

Discord Server

A Sustainable Open Source Foundation

Community & Professional Collaboration

Reinvestment, Not Profit

Apache 2.0 Forever

Pricing and License

FREE Forever

Enterprise Support

Custom Development & Consultancy

Fund the Project

Frequently Asked Questions

Open-Source
Multi-Model Graph Database