MCP Spotlight: ArcadeDB — The Built-In MCP Server for the Only Multi-Model DBMS That Speaks SQL, Cypher, Gremlin, GraphQL, MongoQL & Redis

Server: Built into ArcadeDB by ArcadeData Tools: Built-in · License: Apache 2.0 (Open Source Forever) · Models: 7 — graph, document, key/value, search, time series, vector, geospatial Query languages: 6 — SQL, Cypher, Gremlin, GraphQL, MongoDB QL, Redis commands Wire protocols: 5 — HTTP/JSON, Postgres Wire, MongoDB driver, Redis driver, gRPC MCP Tracker: glama.ai/mcp/servers/ArcadeData/arcadedb Docs: docs.arcadedb.com/arcadedb/reference/mcp/mcp

Most database MCP servers wrap one database that speaks one query language. ArcadeDB is built different: seven data models, six query languages, five wire protocols, and a built-in MCP server that exposes all of them to your AI agent through one tool surface. Written from scratch in LLJ (Low Level Java) by the founder of OrientDB, designed to crunch millions of records per second on a Raspberry Pi.

This is the first MCP server I've seen where the database and the agent interface are designed by the same team — not a thin wrapper bolted on top, but a first-class integration built into the core engine. For agents that need to reason across graph, vector, time-series, and document data in the same query, there's nothing else like it.

The Multi-Model Promise

ArcadeDB is one engine that supports:

Data Model	What It's For	Compatible With
Graph Database	Relationship-heavy data — social networks, fraud rings, knowledge graphs	Neo4j Cypher, Apache Tinkerpop Gremlin, OrientDB SQL
Document Database	Schema-flexible JSON-like records	MongoDB driver + MongoDB queries, OrientDB SQL
Key/Value	Caching, session state, simple lookups	Redis driver + Redis commands
Search Engine	Full-text indexing and queries	Lucene-style query language
Time Series	IoT, metrics, event data	InfluxDB Line Protocol, Prometheus remote_write/read, PromQL
Vector Embedding	Similarity search, RAG, semantic lookup	HNSW index, vector distance functions
Geospatial	Location data, proximity queries	geo.* SQL functions

In one database. One transaction layer. One query interface. No "synchronize Elasticsearch with Postgres with Redis" orchestration. No eventual-consistency footguns. Your agent can write a vector embedding, traverse a graph from it, time-window the results, and return documents — all in one SQL query.

Six Query Languages, One Engine

The same database answers queries in:

• SQL (OrientDB-derived, full DDL/DML/DQL with extensions for graph and vector)
• Cypher (Open Cypher, Neo4j-compatible)
• Apache Gremlin (Tinkerpop v3.7.x, the standard graph traversal language)
• GraphQL (full schema generation, queries, mutations)
• MongoDB Query Language (find/aggregate/insert/update/delete)
• Redis commands (GET/SET/HSET/LPUSH/etc. — a subset)

The agent picks the language it knows best. A graph query in Cypher is the same query in Gremlin is the same query in SQL. The engine plans it identically.

For AI agents, this is significant: the model doesn't need to learn ArcadeDB-specific syntax. It writes standard Cypher for graph queries, standard MongoDB find() for document queries, standard PromQL for time-series. The MCP server accepts any of them.

The MCP Integration: Built-In, Not Bolted On

The MCP server is part of the ArcadeDB core — not a separate binary, not a community plugin, not a wrapper. Enable it via configuration, point your agent at the stdio transport, and you have access to the database through tool calls.

From the ArcadeDB docs:

ArcadeDB includes a built-in Model Context Protocol (MCP) server that allows AI assistants and LLM-based tools to interact with the database. The MCP server exposes database operations as tools that AI clients can discover and invoke using the standard MCP protocol.

The integration points:

• stdio transport — works with Claude Desktop, Cursor, Cline, Windsurf, and any MCP client that accepts stdio
• Tool discovery — database operations are exposed as tools; the agent learns them via the standard MCP tools/list
• Multi-language query support — pass cypher, sql, gremlin, mongodb, or graphql as the language parameter
• Schema introspection — agent can list databases, types, and indexes before querying

Your agent can run a Cypher graph query and get the same result as a MongoDB document query. The MCP tool surface normalizes the access pattern regardless of underlying query language.

Performance: Alien Technology + LLJ

The technical differentiator: ArcadeDB is written in LLJ (Low Level Java) — still Java 21+ but only using low-level APIs to leverage advanced mechanical sympathy techniques and reduce Garbage Collector pressure. The result, per the project:

• Millions of records per second on common hardware
• Minimal resource usage (Raspberry Pi to multi-server cloud)
• LSM-Tree indexes + extendible hash indexes for fast lookups
• Parallel query execution leveraging multiple CPU cores
• Materialized views for pre-computed results

For AI agents that need to query large datasets without latency tanking, this is the difference between "the agent query is fast enough to be useful" and "the agent query is slow enough that the user gives up."

70+ Built-In Graph Algorithms

ArcadeDB ships with 70+ built-in graph algorithms out of the box:

• Pathfinding — shortest path, all paths, A*, Dijkstra
• Centrality — PageRank, betweenness, closeness, eigenvector
• Community detection — Louvain, label propagation, connected components
• Link prediction — common neighbors, Adamic-Adar, preferential attachment
• Graph embeddings — node2vec, DeepWalk, GraphSAGE
• Similarity — Jaccard, cosine, overlap

For agents doing graph reasoning — recommendation engines, fraud detection, knowledge graph traversal — these algorithms are MCP-callable without needing to install a separate graph analytics library.

The 5-Minute Quickstart

# Run ArcadeDB with Docker (includes MCP server)
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:latest

# Open Studio at http://localhost:2480
# Connect your MCP client to the stdio transport

The Docker image ships with the OpenBeer dataset preloaded — you can immediately query a graph of beers, breweries, and ratings to verify the MCP integration works. Then point the agent at your own data.

Facio Integration

{
  "mcpServers": {
    "arcadedb": {
      "command": "arcadedb",
      "args": ["mcp"],
      "env": {
        "ARCADEDB_ROOT_PASSWORD": "${credentials.ARCADEDB_ROOT_PASSWORD}"
      }
    }
  }
}

Facio's audit trail captures every ArcadeDB query the agent runs — the query language, the statement, the parameters, the result count, the timing. For multi-model queries that combine vector + graph + time-series, this creates a traceable record of which models were touched and how the results were composed.

For HITL workflows, the destructive operations are obvious:

• Drop database / type / index — hard confirm
• Truncate type — hard confirm
• Delete by query without WHERE — refuse at the tool layer (defensive default)
• Create / update — soft confirm or autonomous depending on context
• Read-only queries (SELECT, MATCH, find) — fully autonomous

The combination of LLJ performance + multi-model queries + built-in MCP + Apache 2.0 + "Open Source Forever" governance makes ArcadeDB the database layer to reach for when the agent needs more than a single-model store.

Use Cases

Graph RAG: Store your knowledge graph in ArcadeDB, embed nodes as vectors, query by similarity, traverse the graph from the matched nodes. All in one SQL query with vector + graph operators. The agent composes retrieval across both models in a single tool call.

Fraud detection: Combine graph traversal (find connected accounts), vector similarity (find similar fraud patterns), and time-series (recent velocity). The agent runs one query across all three models; ArcadeDB returns a single ranked list of suspicious accounts.

Recommendation engine: Graph (user → purchased → product), vector (product embeddings), document (product metadata), time-series (purchase velocity). The agent reasons across all four to produce personalized recommendations.

Real-time analytics: IoT sensors write time-series data with PromQL-style ingest, the agent runs vector similarity to detect anomalies, traverses the asset graph to identify affected systems, and returns a ranked alert list.

Polyglot persistence, one DB: A team migrating from MongoDB → ArcadeDB keeps using find() and aggregate() queries. A team adding graph relationships writes Cypher. A team adding vector search writes vector distance queries. Same database, same ACID transactions, same MCP tool surface.

Agent memory layer: Store conversation history as documents, embed them as vectors for semantic recall, traverse user relationships for personalization, time-window by recency. ArcadeDB becomes the long-term memory store for the agent.

Bottom Line

ArcadeDB is the only multi-model DBMS that ships with a first-party MCP server built into the engine — not a wrapper, not a plugin, but a designed-from-scratch integration. Seven data models, six query languages, five wire protocols, 70+ graph algorithms, Apache 2.0, "Open Source Forever" governance.

For AI agents that need to reason across graph + vector + time-series + document data in a single transaction, ArcadeDB is the only database that makes this trivial. The agent writes standard Cypher, standard MongoDB queries, or standard SQL — ArcadeDB handles the multi-model planning under the hood.

docker run arcadedata/arcadedb:latest and your agent has a multi-model database with a built-in MCP interface.

---

MCP Spotlight is a series covering servers that give AI agents real capabilities. Every server is evaluated for architecture, performance, and integration fit with Facio's HITL-first agent runtime.