An engine built for AI from the first line of code.

Everyone else added vector columns and an LLM function to an engine designed decades before agents existed. We started here.

One connection, one auth token

A SQL join, a vector rank, a graph hop, an agent, an audit row.

No separate vector store, no separate graph database, no orchestrator polling a queue. Same session, same credential, all four systems.

-- One connection. One auth token. Three systems other databases need.

-- 1. SQL join + vector similarity, in the same SELECT
SELECT o.id, o.total, c.name,
       COSINE_SIMILARITY(o.notes_vec, EMBED('likely fraud pattern')) AS risk
  FROM orders o
  JOIN customers c ON c.id = o.customer_id
 WHERE o.status = 'flagged'
 ORDER BY risk DESC
 LIMIT 20;

-- 2. Graph hop, same session — vector similarity as an edge predicate
MATCH (o:Order {status:'flagged'})-[:SIMILAR_TO > 0.85]->(prior:Order)
MATCH (prior)-[:PLACED_BY]->(c:Customer)
RETURN o.id, prior.id, c.name LIMIT 20;

-- 3. A durable agent already declared on this table fires on commit —
--    no external orchestrator, no queue.
CREATE AGENT fraud_triage
  PERSONA 'aidb-assistant'
  TASK 'Investigate the flagged order and recommend hold or release.'
  ON INSERT INTO orders WHERE status = 'flagged'
  WITH (max_iterations = 3, timeout_seconds = 90);

-- 4. Every run lands hash-chained in the audit ledger — tamper-evident,
--    self-hosted, never leaves your box.
SELECT run_id, agent_name, started_at, verified
  FROM _system_agent_runs
 WHERE agent_name = 'fraud_triage'
 ORDER BY started_at DESC
 LIMIT 5;

Run this locally →

Storage & durability

Rust on RocksDB.

ACID transactions
BEGIN / COMMIT / ROLLBACK, with named savepoints available over the REST transaction endpoint (POST /v1/transactions).
RocksDB storage
MVCC, write-ahead logging, and crash recovery underneath every table, index, and vector — memory-safe, concurrent Rust on top.
Backup & restore
synapcores backup / synapcores restore, incremental and destination-addressable (e.g. s3://...) for hash-chained audit tables.

Interfaces

Speak to it however your stack already speaks.

REST gateway

Every surface — query execution, transactions, graph, vectors, memory, recipes — is a JSON endpoint behind one Bearer token. Query execution: POST /v1/query/execute.

MySQL wire protocol

A near drop-in replacement — point an existing MySQL driver, ORM, or BI tool at SynapCores without rewriting your data layer.

MCP endpoint

WebSocket JSON-RPC at /mcp?token=..., plus a stdio bridge (synapcores-mcp-bridge) for MCP clients that only speak stdio — Claude Desktop, Cursor, and other agent IDEs included.

SDKs

Node.js/TypeScript (@synapcores/sdk), Python (pip install synapcores), PHP + a Laravel companion package, Go, and Java/Spring Boot.

Query surface

One grammar for SQL, graph, vectors, and agents.

SQL

The full surface — DDL, DML, joins, CTEs, window functions, triggers and stored procedures — over one BEGIN / COMMIT / ROLLBACK transaction model.

Cypher graph

Property-graph engine with a Cypher subset. Routes through the same query endpoint as SQL — no separate database, no separate auth. Structural patterns and vector-similarity edges compose in one MATCH: MATCH (a)-[:SIMILAR_TO > 0.85]->(b).

Natural language → SQL

ASK '<question>' in SQL, or POST /v1/nl2sql/query over REST. Schema-aware — the planner injects your live table catalog into the prompt — and falls back to a deterministic pattern matcher when no LLM provider is configured. EXPLAIN NATURAL '<question>' shows the generated plan before it runs.

Vector search

EMBED(text) → VECTOR(N); COSINE_SIMILARITY(vec_a, vec_b) and EUCLIDEAN_DISTANCE(vec_a, vec_b) for ranking; <=>, <->, <#> as inline distance operators.

GENERATE

GENERATE(prompt [, options]) calls the configured completion model inline in SQL, with sampling controls (max_tokens, temperature, seed, response_format: "json") via json_object(...).

MEMORY_* and CREATE MEMORY

MEMORY_STORE / MEMORY_RECALL / MEMORY_UPSERT / MEMORY_FORGET are a flat semantic store. CREATE MEMORY is the durable version — one object coordinating episodic events, durable facts, temporal validity, relationships and provenance, written with REMEMBER and read with RECALL / CURRENT / TRACE.

AGENT_RUN

AGENT_RUN(persona, task [, options]) runs a full ReAct loop (reason → call tool → observe → repeat) inside the current transaction and returns the agent's answer as TEXT.

CREATE AGENT

Durable agents are schema objects — a persona, a task, an activation (ON SCHEDULE and/or ON INSERT/UPDATE/DELETE), and a governance envelope — stored in the database and surviving restarts. No external cron box, worker fleet, or queue.

Multimodal

Audio, video, image, and PDF as native column types.

AUDIO, VIDEO, IMAGE, and PDF columns ingest directly, with TRANSCRIBE(), EXTRACT_TEXT() (OCR), EXTRACT_FRAMES(), and EXTRACT_AUDIO() in SQL. Image description runs in-process with a local vision model by default — no cloud key, no sidecar container — with OpenAI, Anthropic, or Ollama LLaVA available as a configurable provider when you want one.

Governance

Provable, not just logged.

Hash-chained audit ledger

Every agent run is chained: entry_hash = sha256(prev_hash ‖ the run's fields). Edit a stored run in place and its verified column flips to false — a single query surfaces tampering. On by default, self-hosted, never leaves your box. Included in Community Edition.

RBAC, SSO, immutable tables

Fine-grained RBAC, SSO/SAML/LDAP, and general-purpose append-only tables (CREATE IMMUTABLE TABLE, VERIFY TABLE) are Enterprise Edition — everything else on this page is Community Edition.

Self-hosted by default. Run it fully air-gapped — no data egress, no phone-home — for regulated and sovereign deployments.

The standard

SQLv2 — an open specification for AI-native SQL.

SQLv2 is the open specification behind everything on this page — vector types, agent DDL, and multimodal columns defined as a standard, not a proprietary extension. Released under Creative Commons Attribution 4.0 and maintained publicly.

Read the spec →