Client/Server Mode

One database, eight protocols. Connect from any language, any framework, any tool — ArcadeDB speaks the protocols your stack already uses.

Every Protocol, One Engine

Most databases force you into a single protocol. Want to use PostgreSQL tools? You need PostgreSQL. Want Neo4j drivers? You need Neo4j. Want Redis caching? You need Redis. That's three databases to deploy, three to monitor, three to secure, three licenses to manage.

ArcadeDB's server mode is different. A single ArcadeDB instance natively speaks 8 wire protocols, so your Python team connects via PostgreSQL, your Java services use JDBC, your graph visualization tools connect over Bolt, and your ops team monitors via Prometheus — all hitting the same data, the same transactions, the same security layer.

Every protocol supports every data model. Send a Cypher query over the PostgreSQL wire protocol. Execute SQL through the Bolt connector. Run Gremlin traversals via HTTP. ArcadeDB doesn't just emulate these protocols — it integrates them with its full multi-model engine.

Protocol Architecture

ArcadeDB graph · doc · vector · ts key/value · full-text HTTP / JSON :2480 PostgreSQL :5432 Bolt :7687 MongoDB :27017 Redis :6379 Gremlin :8182 JDBC remote Prometheus /prometheus SQL · Cypher · Gremlin · GraphQL · MQL

HTTP / JSON API

# Query with SQL
curl -X POST \
  http://localhost:2480/api/v1/command/mydb \
  -u root:password \
  -H "Content-Type: application/json" \
  -d '{"language":"sql",
     "command":"SELECT FROM Person
                WHERE age > 25"}'

# Or use Cypher over the same endpoint
curl -X POST \
  http://localhost:2480/api/v1/command/mydb \
  -u root:password \
  -d '{"language":"cypher",
     "command":"MATCH (p:Person)-[:KNOWS]->(f)
                RETURN p.name, f.name"}'

# Interactive API docs at:
# http://localhost:2480/api/v1/docs

OpenAPI 3.0 spec + Swagger UI built in. Bearer token auth available.

HTTP / JSON REST API

ArcadeDB's native protocol is a simple HTTP/JSON API on port 2480. No drivers needed — any language with HTTP support connects immediately. Python, JavaScript, Go, Rust, PHP, Ruby — if it can make an HTTP call, it can talk to ArcadeDB.

  • Full OpenAPI 3.0.3 spec: Interactive Swagger UI at /api/v1/docs
  • Multi-language queries: SQL, Cypher, Gremlin, GraphQL, MongoDB query language — all via the same endpoint
  • Server-side transactions: Begin, commit, rollback over HTTP with session tokens
  • WebSocket support: Real-time change event streaming at ws://host:2480/ws
  • Authentication: HTTP Basic Auth or Bearer Token (JWT)

The HTTP API is the most versatile protocol: it supports every query language, every data model, and every administrative operation. Use it when you want maximum flexibility with zero dependencies.

PostgreSQL Wire Protocol

ArcadeDB speaks the PostgreSQL wire protocol on port 5432. This means every PostgreSQL client, driver, and tool in existence works with ArcadeDB out of the box: psql, pgAdmin, DBeaver, Metabase, Grafana, Superset, and any PostgreSQL driver for any programming language.

But here's the twist: you're not limited to SQL. ArcadeDB extends the PostgreSQL protocol with a language prefix syntax. Prefix your query with {cypher} to run Cypher, {gremlin} for Gremlin, or {graphql} for GraphQL — all through a standard PostgreSQL connection.

  • Any PG client works: Python (psycopg2), Java (JDBC), Go (pgx), Node.js (pg), Ruby, Rust, C, C#, R
  • BI tools: Connect Grafana, Metabase, Superset, Tableau directly
  • Multi-language: {cypher}MATCH (n) RETURN n through any PostgreSQL driver
  • Parameter binding: Full prepared statement support for safe, parameterized queries

PostgreSQL Protocol Examples

# Connect with psql
psql -h localhost -p 5432 -d mydb -U root

# Standard SQL
SELECT * FROM Person WHERE age > 25;

# Cypher over PostgreSQL!
{cypher}MATCH (p:Person)-[:KNOWS]->(f)
        RETURN p.name, f.name;

# Gremlin over PostgreSQL!
{gremlin}g.V().hasLabel('Person')
        .out('KNOWS').values('name');

# Python with psycopg2
import psycopg2
conn = psycopg2.connect(
  host="localhost", port=5432,
  database="mydb", user="root",
  password="password")
cur = conn.cursor()
cur.execute("{cypher}MATCH (p:Person) "
            "RETURN p.name, p.age")

Neo4j Bolt Protocol

// Java - Official Neo4j Driver
var driver = GraphDatabase.driver(
  "bolt://localhost:7687",
  AuthTokens.basic("root", "password"));

try (var session = driver.session(
    SessionConfig.forDatabase("mydb"))) {
  var result = session.run(
    "MATCH (p:Person)-[:KNOWS]->(f) "
    + "WHERE p.name = $name "
    + "RETURN f.name AS friend",
    Map.of("name", "Alice"));

  result.list().forEach(record ->
    System.out.println(
      record.get("friend").asString()));
}

# Python - Official Neo4j Driver
from neo4j import GraphDatabase
driver = GraphDatabase.driver(
  "bolt://localhost:7687",
  auth=("root", "password"))
with driver.session(
    database="mydb") as s:
  result = s.run(
    "MATCH (p:Person) RETURN p")

Neo4j Bolt Protocol

ArcadeDB implements the Bolt protocol (v3.0, v4.0, v4.4) on port 7687, making it compatible with the official Neo4j drivers for Java, Python, JavaScript, .NET, and Go. If you're migrating from Neo4j, your application code barely changes — just point it at ArcadeDB.

This isn't a thin compatibility layer. ArcadeDB's native OpenCypher engine passes 97.8% of the official TCK (Technology Compatibility Kit), so your Cypher queries run natively — not translated or emulated.

  • Official Neo4j drivers: Java, Python, JavaScript, .NET, Go — all work unchanged
  • Parameter binding: Full parameterized query support for safe, efficient execution
  • Multi-database: Per-connection database selection, just like Neo4j Enterprise
  • Explicit transactions: BEGIN, COMMIT, ROLLBACK over Bolt
  • Graph visualization: Neo4j Browser and tools like Linkurious connect via Bolt

MongoDB & Redis Wire Protocols

ArcadeDB also speaks the MongoDB BSON protocol on port 27017 and the Redis protocol on port 6379. Teams already using MongoDB or Redis drivers can connect to ArcadeDB without changing their client code.

MongoDB Protocol

Use any standard MongoDB driver to store and query documents in ArcadeDB. CRUD operations, queries, and the MongoDB query language work through the native BSON protocol. Your documents are stored in ArcadeDB's multi-model engine, so they can participate in graph relationships and be indexed with vector search.

Redis Protocol

ArcadeDB's Redis protocol operates in two modes:

  • Transient (RAM-only): Non-persistent key-value pairs for sessions, caches, and counters. Commands: GET, SET, INCR, DECR, EXISTS
  • Persistent: Store and retrieve documents, vertices, and edges as JSON via HSET / HGET — persisted to disk with full ACID guarantees
  • Transactions: MULTI / EXEC / DISCARD for atomic multi-command operations

MongoDB & Redis Examples

# MongoDB — pymongo
from pymongo import MongoClient
client = MongoClient("localhost", 27017)
db = client["mydb"]
db.Person.insert_one({
  "name": "Alice",
  "age": 32,
  "role": "engineer"
})
for p in db.Person.find({"age": {"$gt": 25}}):
  print(p["name"])

# Redis — redis-py
import redis
r = redis.Redis(host="localhost",
  port=6379)

# Transient (RAM-only cache)
r.set("session:abc", "user123")
r.incr("page:views")

# Persistent (stored in ArcadeDB)
r.hset("Person:alice", mapping={
  "name": "Alice",
  "age": "32"})

Apache TinkerPop Gremlin

// Java — Gremlin Driver
Cluster cluster = Cluster.build()
  .addContactPoint("localhost")
  .port(8182)
  .credentials("root", "password")
  .create();
Client client = cluster.connect();

ResultSet rs = client.submit(
  "g.V().hasLabel('Person')"
  + ".has('name','Alice')"
  + ".out('KNOWS')"
  + ".values('name')");

# Python — gremlinpython
from gremlin_python.driver import client
c = client.Client(
  "ws://localhost:8182/gremlin",
  "g")
result = c.submit(
  "g.V().hasLabel('Person')"
  + ".outE('KNOWS').count()")

Gremlin Server (Apache TinkerPop)

ArcadeDB runs a full Gremlin Server on port 8182 via WebSocket, compatible with the Apache TinkerPop ecosystem. This is the standard for imperative graph traversals, used by developers who prefer a step-by-step, pipeline approach to graph queries.

  • TinkerPop 3.x compatible: Standard Gremlin drivers for Java, Python, JavaScript, .NET, Go
  • WebSocket transport: Efficient binary protocol for high-throughput traversals
  • Multi-database: Automatic database registration — g alias maps to the default database
  • Secure engine: Java-based Gremlin engine (no Groovy RCE vulnerabilities)

Gremlin is also available via the PostgreSQL protocol ({gremlin}g.V()...) and the HTTP API ("language":"gremlin"), giving you three ways to execute the same traversals depending on your infrastructure.

Monitoring Stack

ArcadeDB Server /prometheus endpoint scrape every 15s Prometheus / VictoriaMetrics query Grafana Dashboard METRICS latency throughput heap GC ALERTS Slack PagerDuty Email Webhook Production-grade observability built in

Prometheus Metrics & Monitoring

ArcadeDB exposes a Prometheus-compatible metrics endpoint at /prometheus on the HTTP port. Scrape it with any Prometheus-compatible monitoring system — Grafana, Datadog, Victoria Metrics, Thanos — for real-time observability into your database.

  • Server metrics: Query throughput, latency percentiles, active connections, cache hit rates
  • Database metrics: Per-database record counts, storage size, transaction rates
  • JVM metrics: Heap usage, GC pressure, thread counts
  • Replication metrics: Lag, quorum status, leader election events

Enable it with a single server setting: 

-Darcadedb.serverMetrics=true -Darcadedb.server.plugins="Prometheus:com.arcadedb.metrics.prometheus.PrometheusMetricsPlugin"

High Availability Cluster

LEADER Reads + Writes HTTP · PG · Bolt · Gremlin Redis · MongoDB Raft replication Raft replication REPLICA 1 Reads (auto-forward writes) All protocols available REPLICA 2 Reads (auto-forward writes) All protocols available App Cluster A App Cluster B BI / Monitoring Automatic failover · Quorum-based writes

High Availability with Raft Consensus

ArcadeDB's HA architecture uses the Raft consensus algorithm for leader election and data replication. Deploy a cluster of nodes and get automatic failover, real-time replication, and quorum-based write consistency — all built into the open-source Apache 2.0 release.

  • Leader/Replica model: Any node handles reads; writes are transparently forwarded to the leader
  • Automatic failover: If the leader goes down, a replica is elected within seconds
  • Quorum writes: Configurable: none, 1, 2, 3, majority, or all
  • Kubernetes-native: Built-in K8s service discovery with arcadedb.ha.k8s=true
  • All protocols on all nodes: Clients can connect to any replica via any protocol — writes are forwarded automatically

Unlike Neo4j, where clustering requires the Enterprise edition (AGPL), ArcadeDB HA is part of the core open-source distribution. No license gates, no per-node fees.

Docker & Kubernetes Deployment

ArcadeDB ships as a single Docker image with all protocols enabled. Start a server in seconds, or deploy a full HA cluster on Kubernetes with built-in service discovery. 

# Start ArcadeDB with all protocols
docker run -d --name arcadedb \
  -p 2480:2480 # HTTP / JSON API \
  -p 2424:2424 # Replication \
  -p 5432:5432 # PostgreSQL \
  -p 7687:7687 # Neo4j Bolt \
  -p 8182:8182 # Gremlin \
  -p 27017:27017 # MongoDB \
  -p 6379:6379 # Redis \
  -e JAVA_OPTS="-Darcadedb.server.rootPassword=mypassword" \
  arcadedata/arcadedb:latest

Quick Start

  • 1. Run the Docker command
  • 2. Open localhost:2480 for the web console
  • 3. Connect via psql -h localhost -p 5432
  • 4. Or use bolt://localhost:7687 with Neo4j drivers
  • 5. Or curl localhost:2480/api/v1/... for REST

All protocols share the same users, permissions, and databases. Create a user once — it works across HTTP, PostgreSQL, Bolt, Redis, MongoDB, and Gremlin.

Protocol Reference

Every protocol, every port, every capability at a glance.

Protocol Port Languages Transactions Best For
HTTP / JSON 2480 SQL, Cypher, Gremlin, GraphQL, MQL ✓ Microservices, REST APIs, any language
PostgreSQL 5432 SQL, Cypher*, Gremlin*, GraphQL* ✓ BI tools, Grafana, existing PG stacks
Bolt (Neo4j) 7687 Cypher ✓ Neo4j migration, graph visualization
MongoDB 27017 MQL ✓ Document workloads, existing Mongo stacks
Redis 6379 Redis commands ✓ Caching, sessions, counters
Gremlin 8182 Gremlin ✓ TinkerPop ecosystem, graph pipelines
JDBC remote SQL ✓ Java/JVM apps, Spring, Hibernate
Prometheus /prometheus Metrics — Monitoring, alerting, dashboards

* Via language prefix: {cypher}, {gremlin}, {graphql}

Embedded vs. Client/Server

Capability Embedded Client/Server
Latency ~0.001ms ~0.5-5ms
Multi-language clients JVM only Any language
Concurrent clients Single process Thousands
Wire protocols Java API 8 protocols
HA replication via Embedded Server ✓ Native Raft
BI / monitoring tools ✗ ✓
Deployment In your JAR Docker / K8s / bare metal

Both modes share the same engine, the same data format, and the same query languages. You can even combine them with the Embedded Server pattern.

When to Choose Client/Server

Client/Server mode is the right choice when your architecture requires multi-language access, remote connectivity, or team-wide shared database access. Use it when:

  • Polyglot teams: Python, Java, Go, JavaScript, .NET teams all need database access
  • Microservice architecture: Many services connect to a shared data layer
  • BI and analytics: Grafana, Metabase, or Superset need SQL access via PostgreSQL
  • Neo4j migration: Existing applications connect via Bolt with minimal code changes
  • Operational monitoring: Prometheus metrics, dashboards, and alerting required
  • Multi-tenant: Multiple databases served from a single cluster with unified security

For maximum throughput on a single JVM application, consider Embedded Mode. For the best of both worlds — in-process speed plus remote access — use the Embedded Server pattern.

Apache 2.0 — Every Protocol Included

All 8 protocols, HA replication, and Kubernetes support are included in the open-source Apache 2.0 release. No "Enterprise Edition" with gated features, no per-node licensing, no protocol add-ons. ArcadeDB is Apache 2.0 forever.

Ready to Connect?

Start ArcadeDB with Docker in 30 seconds. Connect via HTTP, PostgreSQL, Bolt, MongoDB, Redis, or Gremlin — your choice, your tools, one database.

Get Started Read Documentation