The knowledge engine

Make connected knowledge durable, explainable, and computable.

Medulla unifies graph, SQL, RDF/OWL, vectors, time, evidence, and multimodal data. One Rust-native planner and transaction boundary govern them.

Run it locally Inspect capabilities

Build on it

Use the Python client, UQL, SQL, SPARQL, Cypher, GraphQL, Bolt, and stream interfaces against the same governed state.

Explore interfaces

Understand it

Follow requests from authenticated ingress through planning, reasoning, computation, and commit-before-ack storage.

Read the architecture

Operate it

Run a durable single node or a replicated cluster with explicit identity, policy, persistence, and observability.

Deploy the engine

One authority across every data shape

Interfaces differ. Authority, planning, evidence, and commit semantics do not.

The main build provides the connected data, semantic reasoning, analytical, temporal, and multimodal surfaces shown above. Compatibility is published per operation: the capability matrix explains supported behavior, while the generated method ledger records exact authority, durability, audit, CDC, and transaction properties.

Capability truth is part of the product

Status is generated from the same method contracts the engine serves. Check current status and the capability matrix before selecting an interface or deployment shape.

Where this engine fits

Medulla is the durable authority at the base of the shared runtime.

Explore the live architecture.

This repository owns

Durable data, graph and multimodal computation, semantic reasoning, query planning, schema enforcement, evidence, and engine authorization.

It does not own

Agent orchestration, public gateway policy, browser experience, source credentials, or vendor API execution.

1. Enter through Arbora MCP, REST, A2A, identity, policy, and the hosted WebUI share one public door.
2. Run with agent-utilities Agents, workflows, skills, evaluation, and control-plane decisions run above the database.
3. Commit in Medulla State, schema, evidence, provenance, and outcomes become durable under one transaction boundary.
4. Synchronize through connectors SDK-based connectors exchange governed records with external source systems.

Choose an interface

Goal	Start here
Add or query graph records from Python	Python and native clients
Query connected knowledge	UQL, Cypher, or GraphQL
Work with RDF and ontologies	RDF, SPARQL, OWL, and SHACL
Run relational analytics	SQL and PostgreSQL wire
Search vectors, text, and memory	Memory interfaces and vector search
Ingest documents and media	Governed modality serving
Operate a durable service	Standalone deployment and operations

Run the operator's first graph

The release wheel includes the in-process engine binding, so the shortest path needs no server, port, certificate, or background process:

python -m pip install epistemic-graph
python - <<'PY'
import msgpack
from epistemic_graph.engine import Engine

engine = Engine(persist_dir=":memory:")
engine.create_graph("demo")
engine.add_node("demo", "node:hello", msgpack.packb({"kind": "Greeting"}, use_bin_type=True))
print(engine.has_node("demo", "node:hello"), engine.node_count("demo"))
PY

Expected output: True 1. This explicit :memory: mode is ephemeral. Continue to the local guide for the annotated example, or go directly to Deploy for durable service, TLS, and cluster configuration.

Specification delivery

Open the specification dashboard for documented specifications, separate requirement status, delivery evidence, and open pull request and issue snapshots. It refreshes on pushes to main. Completion requires recorded delivery and acceptance; a merged requirement does not complete its parent specification. Burndown, source-landed velocity, and the delivery timeline use bounded first-parent observations of tracked status files. Commit dates are observation times; release and deployment dates remain unknown without explicit evidence.