ArcadeDB Integrations

LangChain

langchain-arcadedb provides ArcadeDBGraph, which implements LangChain's GraphStore protocol. It connects through ArcadeDB's Bolt protocol (it installs the neo4j Python driver), detects the schema from existing data, runs Cypher, and works as a drop-in graph for GraphCypherQAChain. It can also import LangChain graph documents.

Install

pip install langchain-arcadedb

# ArcadeDB with the Bolt plugin enabled
docker run --rm -p 2480:2480 -p 7687:7687 \
  -e JAVA_OPTS="-Darcadedb.server.rootPassword=playwithdata -Darcadedb.server.plugins=Bolt:com.arcadedb.bolt.BoltProtocolPlugin" \
  arcadedata/arcadedb:26.10.2

# create a database
curl -X POST http://localhost:2480/api/v1/server \
  -d '{"command":"create database mydb"}' \
  -u root:playwithdata -H "Content-Type: application/json"

Snippet

from langchain_arcadedb import ArcadeDBGraph

graph = ArcadeDBGraph(
    url="bolt://localhost:7687",
    username="root",
    password="playwithdata",
    database="mydb",
)

# Schema is auto-detected from existing data
print(graph.get_schema)

# Run Cypher queries
result = graph.query("MATCH (n:Person) RETURN n.name AS name")

For natural-language questions, pass the same graph to GraphCypherQAChain.from_llm(...) from langchain_neo4j together with your LLM, as shown in the repository README.

Haystack

arcadedb-haystack is an ArcadeDB integration for Haystack 2.x. ArcadeDBDocumentStore stores Haystack documents as ArcadeDB vertices with their embeddings in a native HNSW vector index and filters on metadata with SQL. ArcadeDBEmbeddingRetriever is the pipeline component that queries that index. It talks to ArcadeDB over plain HTTP/JSON, so no extra driver is needed. The package is listed in Haystack's integration catalog and its source now lives in deepset's haystack-core-integrations repository.

Install

pip install arcadedb-haystack

docker run -d -p 2480:2480 \
  -e JAVA_OPTS="-Darcadedb.server.rootPassword=arcadedb" \
  arcadedata/arcadedb:26.10.2

export ARCADEDB_USERNAME=root
export ARCADEDB_PASSWORD=arcadedb

Snippet

from haystack import Pipeline
from haystack_integrations.components.retrievers.arcadedb import ArcadeDBEmbeddingRetriever
from haystack_integrations.document_stores.arcadedb import ArcadeDBDocumentStore

store = ArcadeDBDocumentStore(database="myproject", embedding_dimension=768)

pipeline = Pipeline()
pipeline.add_component("retriever", ArcadeDBEmbeddingRetriever(document_store=store, top_k=10))

result = pipeline.run({"retriever": {"query_embedding": [0.1] * 768}})
documents = result["retriever"]["documents"]

LlamaIndex

llama-index-graph-stores-arcadedb implements LlamaIndex's PropertyGraphStore (ArcadeDBPropertyGraphStore) and the older basic graph store (ArcadeDBGraphStore). It connects over ArcadeDB's HTTP API on port 2480, and vector operations are enabled when you pass embedding_dimension. It is maintained by a community contributor rather than by Arcade Data, so file issues on its own repository.

Install

pip install llama-index-graph-stores-arcadedb

Snippet

from llama_index.core import PropertyGraphIndex
from llama_index.graph_stores.arcadedb import ArcadeDBPropertyGraphStore

graph_store = ArcadeDBPropertyGraphStore(
    host="localhost",
    port=2480,
    username="root",
    password="playwithdata",
    database="knowledge_graph",
    embedding_dimension=1536,  # match your embedding model
)

# documents: a list of LlamaIndex Document objects
index = PropertyGraphIndex.from_documents(
    documents,
    property_graph_store=graph_store,
    show_progress=True,
)

response = index.query("What are the main topics discussed?")

Building a PropertyGraphIndex from documents calls the LLM and embedding model configured in LlamaIndex, so those need to be set up (for example with an API key) before this runs.

Flexible GraphRAG

Flexible GraphRAG is an open-source AI context platform: document parsing (Docling, LlamaParse or LiteParse), automatic knowledge graph building with optional ontologies, hybrid search across full-text, vector and graph, and AI query and chat. The backend is Python, with LlamaIndex and LangChain as peer frameworks, a FastAPI REST service, an MCP server, and React, Vue and Angular frontends. It ingests from 14 data sources, including Alfresco, Nuxeo, SharePoint and S3, and keeps 10 of them in sync automatically.

ArcadeDB is one of its property graph stores, supported on both the LlamaIndex and the LangChain side, over the HTTP API or in embedded mode through arcadedb-embedded. Search results and chat answers link back to the documents they came from. For the pattern behind it, see GraphRAG with ArcadeDB. It is maintained by Steve Reiner, who also maintains the LlamaIndex package above.

Install

uv pip install flexible-graphrag
# optional: run ArcadeDB in-process (bundled JVM)
uv pip install arcadedb-embedded

Configure ArcadeDB (.env)

PG_GRAPH_DB=arcadedb
ARCADEDB_GRAPH_DB_CONFIG={"host": "localhost", "port": 2480, "username": "root", "password": "password", "database": "flexible_graphrag", "query_language": "sql"}

Cognee

Cognee is an AI memory engine that turns documents and conversations into a knowledge graph plus embeddings. The ArcadeDB adapters are merged into the official cognee-community repository. The hybrid adapter uses ArcadeDB as both Cognee's graph database and its vector database, so one engine replaces two. A graph-only adapter (cognee-community-graph-adapter-arcadedb) is also available.

Install

pip install cognee-community-hybrid-adapter-arcadedb

# Optional: Bolt support for faster graph operations
pip install "cognee-community-hybrid-adapter-arcadedb[bolt]"

Snippet

import asyncio
import os
from cognee import config, add, cognify, search, SearchType

# Import the register module to enable ArcadeDB support
from cognee_community_hybrid_adapter_arcadedb import register


async def main():
    config.set_relational_db_config({"db_provider": "sqlite"})

    # Configure ArcadeDB as both vector and graph database
    config.set_vector_db_config({
        "vector_db_provider": "arcadedb",
        "vector_db_url": os.getenv("ARCADEDB_URL", "localhost"),
        "vector_db_port": int(os.getenv("ARCADEDB_HTTP_PORT", "2480")),
        "vector_db_username": os.getenv("ARCADEDB_USERNAME", "root"),
        "vector_db_password": os.getenv("ARCADEDB_PASSWORD", ""),
    })
    config.set_graph_db_config({
        "graph_database_provider": "arcadedb",
        "graph_database_url": os.getenv("ARCADEDB_URL", "localhost"),
        "graph_database_port": int(os.getenv("ARCADEDB_HTTP_PORT", "2480")),
        "graph_database_username": os.getenv("ARCADEDB_USERNAME", "root"),
        "graph_database_password": os.getenv("ARCADEDB_PASSWORD", ""),
    })

    await add("Natural language processing (NLP) is an interdisciplinary "
              "subfield of computer science and information retrieval.")
    await cognify()

    results = await search(query_type=SearchType.GRAPH_COMPLETION,
                           query_text="Tell me about NLP")
    for result in results:
        print(result)


asyncio.run(main())

cognify() uses an LLM to extract entities and relationships, so configure Cognee's LLM settings before running it. The full example, including the dataset handler environment variables, is in the adapter README.

arcadedb-claude: memory for Claude Code

arcadedb-claude is a community Claude Code plugin (MIT licensed) that gives coding agents persistent memory in an ArcadeDB server you run. It captures each prompt and answer as a turn, links the files, symbols and commits they mention, records decisions with validity windows so superseded ones are hidden rather than deleted, indexes code structure per repository, and answers recall questions with hybrid search (vectors, full-text and graph). It ships CLIs and a library for other agents too.

Install

Run an ArcadeDB server, then in any Claude Code session:

/plugin marketplace add altugsogutoglu/arcadedb-claude
/plugin install arcadedb-claude-skills@arcadedb-claude

Snippet

Set the server password if yours has one, then use the CLI for recall outside Claude Code:

# inside Claude Code
/arcadedb-config set password changeme

# from a shell (npm install -g arcadedb-claude-skills)
arcadedb-skills search "why did we drop the test api default"
arcadedb-skills decisions list --all

Aura: a self-hosted AI agent platform

Aura is a community, MIT-licensed AI agent platform written in Go. A single binary hosts the agent runtime, tools, a CLI, a Telegram gateway and a web cockpit, and the model route is your choice: OpenRouter, a ChatGPT plan, a bundled llama.cpp server or Ollama. Its memory is graph-native: facts, their sources and validity windows live in ArcadeDB, and temporal paths return the evidence behind an answer. Aura is multi-user, with one isolated ArcadeDB database per identity, and the Docker Compose stack runs ArcadeDB next to Postgres and the other services.

Install

The installer generates .env, downloads the Compose assets and starts the stack, including ArcadeDB:

npx create-aura-appliance                 # local
npx create-aura-appliance --mode remote   # Linux target over SSH

Then open https://<host>/setup/?token=<AURA_ACCESS_TOKEN>, create the first user and pick the model route. The project's install guide covers the hardware it needs and the other install options.

ArcadeDB MCP server

ArcadeDB ships a Model Context Protocol server inside the database. Once enabled, any MCP client can list databases, read the schema, run read-only queries in SQL, Cypher, Gremlin, GraphQL or MongoDB syntax, search vector, full-text and hybrid indexes, and upsert entities and relationships for agent memory. Every operation is gated by per-operation permission flags that default to read-only. The full setup, the tool list and client configuration are on ArcadeDB for AI agents.

Enable

curl -X POST -u root:playwithdata \
  -H "Content-Type: application/json" \
  -d '{"enabled": true, "allowReads": true}' \
  http://localhost:2480/api/v1/mcp/config

Snippet: Claude Code

claude mcp add --transport http arcadedb http://localhost:2480/api/v1/mcp \
  --header "Authorization: Basic cm9vdDpwbGF5d2l0aGRhdGE="

MCP Toolbox for Databases (Google)

MCP Toolbox for Databases (formerly GenAI Toolbox) is Google's open-source MCP server for databases. ArcadeDB support was merged upstream and released in Toolbox v1.7.0: an arcadedb source plus two tools, arcadedb-execute-cypher and arcadedb-execute-sql, both with a readOnly flag. Use it when your agents already go through the Toolbox for other databases; it connects over Bolt, so enable the Bolt plugin as in the LangChain section.

Install and run

export PASSWORD=playwithdata
npx @toolbox-sdk/server --config tools.yaml

Snippet: tools.yaml

kind: source
name: my-arcadedb-source
type: arcadedb
uri: bolt://localhost:7687
user: root
password: ${PASSWORD}
database: "mydb"
---
kind: tool
name: query_arcadedb
type: arcadedb-execute-cypher
source: my-arcadedb-source
readOnly: true
description: Execute read-only Cypher against ArcadeDB.

Grafana

The ArcadeDB data source plugin queries ArcadeDB directly from Grafana dashboards. It has a visual builder for ArcadeDB time series (auto-discovered types, fields and tags with SUM, AVG, MIN, MAX and COUNT), SQL with time macros such as $__timeFilter(col), Cypher and Gremlin with optional rendering in Grafana's Node Graph panel, template variables, and alerting through its Go backend. It needs Grafana 12.3 or later.

Install

docker run --rm -d --name grafana -p 3000:3000 \
  -e GF_PLUGINS_ALLOW_LOADING_UNSIGNED_PLUGINS=arcadedb-arcadedb-datasource \
  -e GF_INSTALL_PLUGINS="https://github.com/ArcadeData/arcadedb-grafana-datasource/releases/download/v1.0.0-beta.2/arcadedb-arcadedb-datasource-1.0.0-beta.2.zip;arcadedb-arcadedb-datasource" \
  grafana/grafana:latest

Then add the data source under Connections > Data Sources with your ArcadeDB HTTP URL (for example http://localhost:2480), database name and credentials.

Snippet

SELECT ts, temperature FROM weather
WHERE $__timeFilter(ts)
ORDER BY ts

Prometheus

The standard distribution includes a metrics module that exposes server, engine and JVM metrics in Prometheus format at /prometheus on the HTTP port. Register the Prometheus plugin, point your scraper at it, and chart the results in Grafana. Scraping requires authentication by default.

Enable

docker run --rm -p 2480:2480 \
  -e JAVA_OPTS="-Darcadedb.server.rootPassword=arcadedb -Darcadedb.server.plugins=Prometheus:com.arcadedb.metrics.prometheus.PrometheusMetricsPlugin" \
  arcadedata/arcadedb:26.10.2

curl -u root:arcadedb http://localhost:2480/prometheus

Snippet: prometheus.yml

scrape_configs:
  - job_name: 'arcadedb'
    scrape_interval: 15s
    metrics_path: /prometheus
    static_configs:
      - targets: ['localhost:2480']
    basic_auth:
      username: root
      password: arcadedb

OpenTelemetry

Alongside the Prometheus scrape, ArcadeDB can push the same metrics to an OpenTelemetry Collector over OTLP/HTTP (port 4318, path /v1/metrics). It is off by default and turned on with two settings. Distributed tracing is a separate, optional plugin described in the observability docs.

Enable

docker run --rm -p 2480:2480 \
  -e JAVA_OPTS="-Darcadedb.server.rootPassword=arcadedb -Darcadedb.serverMetrics.otlp.enabled=true -Darcadedb.serverMetrics.otlp.endpoint=http://otel-collector:4318" \
  arcadedata/arcadedb:26.10.2

BI tools over the PostgreSQL protocol

ArcadeDB speaks the PostgreSQL wire protocol on port 5432, so Apache Superset, Metabase, Tableau, Power BI and other tools with a PostgreSQL connector connect without a custom driver. Java tools use the standard PostgreSQL JDBC driver. To send Cypher or Gremlin from a SQL-only tool, prefix the query with the language tag, as below. The docs have a page per tool.

Snippet

-- JDBC URL: jdbc:postgresql://localhost:5432/mydb
{cypher} MATCH (m:Movie)<-[a:ACTED_IN]-(p:Person) RETURN m.title, count(p)

Nuxeo, OpenArch and Jackrabbit Oak on ArcadeDB

Three sibling projects, side projects of Flexible GraphRAG, move a content repository's document and folder nodes out of MongoDB (or SQL) and into a property graph. Every file, folder and version becomes a vertex linked to its parent by a CHILD_OF edge, with metadata, versions and ACLs on the vertices. The repository product and its APIs stay unchanged on top, and every write still goes through it, so there is no second store to synchronize. File content stays in the usual blob store.

With the content tree in ArcadeDB, you can browse it in ArcadeDB Studio, query it directly in SQL or Cypher, and link documents to business entities and ontologies in the same database: the starting point for a knowledge graph over enterprise content. Each project also supports Neo4j. All three are prototypes and use ArcadeDB's Java remote (HTTP) API.

• nuxeo-graph-storage: a DBS backend for Nuxeo LTS 2025. It passes Nuxeo's own core repository test suite, unchanged, and NXQL is translated to ArcadeDB SQL. Nuxeo's Web UI works on it.
• openarch-graph-storage: the same for Hyland OpenArch, which derives from Nuxeo, running OpenArch's core repository tests unchanged.
• oak-graph-store: an Apache Jackrabbit Oak DocumentStore, the layer under the JCR API that Apache Sling and Adobe Experience Manager build on. It passes the Oak tests that apply to a document store.

Configure (Nuxeo)

nuxeo.arcadedb.host=localhost
nuxeo.arcadedb.port=2480
nuxeo.arcadedb.database=nuxeo
nuxeo.arcadedb.username=root
nuxeo.arcadedb.password=

Each repository includes Docker Compose files that start the repository product with ArcadeDB and ArcadeDB Studio.

Better Auth

better-auth-arcadedb is a community, MIT-licensed database adapter that lets Better Auth, the TypeScript authentication framework, keep its users, sessions, accounts and plugin models in ArcadeDB. It is built on the official @arcadedb/driver for Node.js, so there is no separate HTTP client to configure. It supports transactions, atomic single-use and counter operations, custom model and field names, and generates the SQL schema with indexes from your Better Auth options. Version 1.0.0 is verified against ArcadeDB 26.10.2 on Node.js 22 and 24.

Install

npm install [email protected] [email protected] @arcadedb/[email protected]

Snippet

import { basicAuth, createClient } from "@arcadedb/driver";
import { betterAuth } from "better-auth";
import { arcadeDBAdapter } from "better-auth-arcadedb";

const server = createClient({
  baseUrl: process.env.ARCADEDB_URL!,
  auth: basicAuth(process.env.ARCADEDB_USERNAME!, process.env.ARCADEDB_PASSWORD!),
});

export const auth = betterAuth({
  secret: process.env.BETTER_AUTH_SECRET!,
  baseURL: process.env.BETTER_AUTH_URL!,
  database: arcadeDBAdapter(server.db(process.env.ARCADEDB_DATABASE!), { usePlural: false }),
  emailAndPassword: { enabled: true },
});

Create the database and apply the generated schema before serving requests: the adapter does not create or alter schema at runtime. The repository has a runnable Docker example with the schema step.

Ruby: the arcadedb gem

arcadedb is a community, MIT-licensed Ruby interface to ArcadeDB over the HTTP/JSON API. Each database type maps to a model class built on Dry::Struct (not ActiveRecord): vertices, edges, documents and native time-series types. Vertices can walk the graph with nodes, edges and traverse, a generator builds MATCH statements from Ruby, and query objects nest, so hybrid queries need no string surgery. It also ships a vector and full-text schema for RAG pipelines, transactions, and an append-only revision trail. Version 0.5.4 is tested against ArcadeDB 26.10 and needs Ruby 2.7 or later.

Install

bundle add arcadedb

Connection settings live in an arcade.yml file, with one database per environment; the repository has a template and a bin/console to copy.

Snippet

class Person < Arcade::Vertex
  attribute :name, Types::Nominal::String
end
class IsMarriedTo < Arcade::Edge; end

Arcade::Init.connect :development

hubert  = Person.insert name: 'Hubert'
pauline = Person.insert name: 'Pauline'
hubert.assign via: IsMarriedTo, vertex: pauline, divorced: false

hubert.nodes(:out, via: IsMarriedTo).first   # => Pauline
Arcade::Match.new(type: Person, as: :p).out(IsMarriedTo).node.execute

Person.create_type creates the type and runs any DDL placed after __END__ in the model file. Properties you do not declare stay schemaless and arrive in the values attribute. The README also covers time-series writes and bucketed reads, and the spec suite is the reference for the API.

DatAasee: a metadata lake for libraries

DatAasee is an MIT-licensed metadata lake from the University and State Library of Münster. It harvests bibliographic and research metadata from distributed sources (OAI-PMH, S3 and plain HTTP GET, in DataCite, Dublin Core, LIDO, MARC or MODS XML), normalizes every record into a DataCite-based Metadata vertex, and then interconnects the records with edges into one union catalog. ArcadeDB is the only component that holds state; a Redpanda Connect (Benthos) backend serves a JSON:API over HTTP, and an optional Lowdefy frontend sits on top. Version 0.9 ships ArcadeDB 26.4.2 in its container image and is at pilot stage, not yet production-ready.

Install

wget https://raw.githubusercontent.com/ulbmuenster/dataasee/0.9/compose.yaml
mkdir -p -m 777 backup
DL_PASS=password1 DB_PASS=password2 docker compose up

DL_PASS is the password of DatAasee's admin user, needed for the POST endpoints; DB_PASS is the ArcadeDB root password. The API listens on port 8343 and the web frontend on 8000. The Compose file also runs with Podman.

Snippet

# harvest the DOAJ catalog over OAI-PMH
wget -qO- "http://localhost:8343/api/v1/ingest" --user admin --ask-password --post-data \
  '{"source":"https://doaj.org/oai", "method":"oai-pmh", "format":"oai_dc", "rights":"CC0", "steward":"[email protected]"}'

# full-text search the catalog
wget -qO- "http://localhost:8343/api/v1/metadata?search=climate"

# read-only query straight against the ArcadeDB graph
wget -qO- "http://localhost:8343/api/v1/database?language=sql&query=SELECT+title+FROM+Metadata+LIMIT+10"

The /database endpoint accepts any of ArcadeDB's query languages (sql, opencypher, mongo, graphql or redis), so downstream services can walk the interlinked records as a knowledge graph of publications and datasets. For a public deployment, set DL_SAFE=true or block that endpoint at the reverse proxy. The documentation covers the native schema, the interconnect edges and backups, and the project's companion paper explains the design.