ArcadeDB Embedded Python | In-Process Multi-Model Database

The Embedded Database Revolution Reaches Python

DuckDB proved that an in-process analytical database can outperform entire distributed clusters for real-world workloads. SQLite processes more queries per day than all other databases combined. The fastest network call is the one you never make.

Until recently, Python developers had no equivalent for graph and multi-model workloads. NetworkX is not persistent. SQLite is relational only. Kuzu Python brought embedded graphs to Python, then was acquired by Apple in October 2025 and the open-source repository was archived.

arcadedb-embedded fills that gap. One pip install ships ArcadeDB's full engine into your Python process: graphs, documents, key-value, vectors, time-series, and full-text search. The wheel bundles a Java 25 runtime (no separate Java install) and weighs about 73 MB.

And it is not going anywhere. ArcadeDB is Apache 2.0 forever: no acquisition will archive your database.

Why Embedded Is Faster

Zero serialization: No marshalling Python objects to JSON and back
Zero network: No TCP round-trips, no connection pooling, no timeouts
JPype bridge: Direct in-process calls into the ArcadeDB engine
Bundled JRE: Java 25 ships with the wheel, no system Java required
One dependency: pip install arcadedb-embedded and you are done
O(1) traversal: Graph hops via direct pointers, not index lookups

Client/Server vs. Embedded

Eliminate the Network, Keep the Power

In client/server mode, every database operation requires serializing your request, sending it over TCP/IP, deserializing on the server, executing, serializing the result, sending it back, and deserializing again. For a simple vertex lookup, that is 6 steps of overhead before you see your data.

In embedded mode, it is a JPype call straight into the ArcadeDB engine running inside the same process. No network, no serialization, no connection pool, no timeout configuration. Just direct, in-process access to a full-featured multi-model database from Python.

This is not a simplified "lite" mode. Every feature of ArcadeDB is available from the Python binding:

Graph traversal with SQL and OpenCypher
Vector search with JVector (HNSW + Product Quantization)
Full-text search via Lucene integration
Time-series with time_bucket(), rate(), moving_avg()
Document and key-value storage
ACID transactions with WAL recovery
Data import (CSV, XML, JSONL) and export (JSONL, GraphML, GraphSON)

Up and Running in 60 Seconds

Run a single pip install. Open a database. Start querying. No server to install, no Docker container to manage, no ports to configure, no connection strings to debug, and no separate Java runtime to set up.

The arcadedb-embedded wheel ships with a bundled Java 25 runtime, so the only prerequisite is a supported Python interpreter. Wheels are published for Python 3.10 through 3.14 on Linux (x86_64 and ARM64), macOS (Apple Silicon), and Windows (x86_64).

The database files live in a directory you specify. No background daemon. No configuration files. No ports. When your script starts, the database opens. When the with block exits, the database closes. If the process crashes, WAL recovery handles the rest.

Install

# One command. Bundles ArcadeDB
# engine + Java 25 runtime.
pip install arcadedb-embedded

That's it. One dependency. ~73 MB wheel. No system Java required, no JNI to compile, no native build step.

Create Database & Graph

import arcadedb_embedded as arcadedb

# Create or open a database
with arcadedb.create_database(
    "./mydb") as db:

  with db.transaction():
    # Define schema
    db.command("sql",
      "CREATE VERTEX TYPE Person")
    db.command("sql",
      "CREATE EDGE TYPE Knows")

    # Create vertices
    db.command("sql",
      "INSERT INTO Person SET "
      "name = 'Alice', age = 32")
    db.command("sql",
      "INSERT INTO Person SET "
      "name = 'Bob', age = 28")

    # Create edge
    db.command("sql",
      "CREATE EDGE Knows "
      "FROM (SELECT FROM Person "
      "WHERE name='Alice') "
      "TO (SELECT FROM Person "
      "WHERE name='Bob') "
      "SET since = 2020")

The Python API

The Python binding is designed around two principles: safety and simplicity. Both create_database() and db.transaction() return context managers, so a with block handles cleanup, commit, and rollback for you.

The binding is SQL and OpenCypher first: write data with db.command(), read data with db.query(), and use GraphBatch for high-throughput bulk graph ingestion. No ORM, no annotations, no code generation: just direct access to your data.

arcadedb.create_database(path): Open or create a database, returns a context-managed handle
db.transaction(): with-block ACID transactions with automatic commit/rollback
db.command(lang, sql): Run writes (INSERT, UPDATE, DELETE, CREATE)
db.query(lang, sql): Run reads, iterate result records as Python objects
GraphBatch: Optimized bulk loader for millions of vertices and edges
db.import_documents(): Wrapper for SQL IMPORT DATABASE over CSV, XML, or JSONL

Every Query Language, In-Process

The Python binding supports SQL, OpenCypher (latest Cypher 25 grammar), and the MongoDB query language: all executing in-process without network overhead.

Different problems suit different query languages. Use Cypher for graph pattern matching, SQL for aggregations and joins, and the MongoDB syntax when you are migrating from a Mongo-shaped data model. Switch between them freely within the same script.

For Cypher specifically, ArcadeDB's native engine implements the latest OpenCypher 25 specification and passes 97.8% of the official Technology Compatibility Kit (TCK). If you are migrating from Neo4j or looking for a Kuzu replacement, your existing Cypher queries work as-is.

Query Languages from Python

# SQL
result = db.query("sql",
  "SELECT FROM Person "
  "WHERE age > 25")

for row in result:
  print(row.get("name"))

# OpenCypher
result = db.query("cypher",
  "MATCH (p:Person)-[:Knows]->(f) "
  "WHERE p.name = 'Alice' "
  "RETURN f.name, f.age")

# MongoDB syntax
result = db.query("mongo",
  '{ find: "Person", '
  '  filter: { age: { $gt: 25 } } }')

for row in result:
  name = row.get("name")
  age  = row.get("age")

Vector Index from Python

# Create the document type
# and a vector index
db.command("sql",
  "CREATE DOCUMENT TYPE Document")

db.command("sql",
  "CREATE VECTOR INDEX "
  "ON Document(embedding) "
  "LSM TYPE COSINE")

# Insert documents with embeddings
with db.transaction():
  db.command("sql",
    "INSERT INTO Document SET "
    "content = ?, embedding = ?",
    text, embedding_vector)

# Hybrid: vector + graph in
# a single in-process query
result = db.query("sql",
  "SELECT content, "
  "embedding.cosineDistance(?) "
  "AS score, "
  "out('MENTIONS').name "
  "AS entities "
  "FROM Document "
  "WHERE embedding."
  "cosineDistance(?) < 0.4 "
  "ORDER BY score LIMIT 10",
  query_vec, query_vec)

JVector In-Process: AI Without Infrastructure

Building AI applications with RAG, semantic search, or recommendation engines in Python? ArcadeDB's embedded mode runs JVector: the same vector search engine that powers DataStax Astra DB, accessible directly from your Python script.

No separate Pinecone subscription. No Weaviate container. No HTTP calls to a vector service. Your embeddings are indexed and searchable in the same process that generates them, alongside the graph and document data they relate to.

HNSW + DiskANN hybrid: Best-in-class search quality at any scale
SIMD acceleration: CPU vector instructions for similarity computation
Product Quantization: Handle billion-scale embeddings on a single machine
Graph + Vector in one query: Combine vector similarity with graph traversal in-process, sub-millisecond
Pairs cleanly with LangChain / LlamaIndex: Use ArcadeDB as the persistent store behind a Python RAG pipeline

This is the ideal architecture for embedded AI in Python: your LLM client generates embeddings, your application stores and queries them via arcadedb-embedded, and graph context enriches the results. All in a single process with no external dependencies.

When Embedded Python Mode Shines

AI / RAG Pipelines

Use ArcadeDB as the persistent store for LangChain, LlamaIndex, or custom RAG pipelines. Vectors plus a knowledge graph in one in-process database, with sub-millisecond retrieval for Graph RAG, semantic search, and recommendations.

Data Science & Notebooks

Persistent state for Jupyter notebooks. Load a dataset once, run iterative analyses, keep the database between kernel restarts. Mix graph traversals with pandas, numpy, and scikit-learn in the same process.

Edge & IoT

Run a full multi-model database on Python edge devices, gateways, and Raspberry Pi deployments. Process sensor data with time-series, model device relationships as graphs, and sync to the cloud when connected.

Desktop & CLI Tools

Ship a rich data layer with your Python CLI or desktop app. No installer, no service, no database administration. Great for developer tools, data analysis utilities, and bundled Click / Typer applications.

FastAPI / Flask Microservices

Each microservice gets its own embedded database for local state. No shared database bottleneck. Event sourcing, CQRS, and saga patterns become natural with embedded graph + document + time-series.

Testing & CI/CD

No Docker, no Testcontainers, no database fixtures to provision. Spin up a temporary database per pytest test, run your assertions, tear it down. Tests are fast, isolated, and reproducible.

Embedded Mode for Python