Omnigraph | Modern Relay

§ Product

Graph as code. Object-storage native. Optimized for context assembly.

Docs GitHub

$ curl -fsSL https://raw.githubusercontent.com/ModernRelay/omnigraph/main/scripts/install.sh | bash

§ Install

[Declarative]

Graph as code

Schema, context, policies, UI and infra are declarative files: versioned like code, enforced by the engine.

Context-as-code

Git-style branch, version, and merge for data. A set of linted, typed queries defines each lens on the graph, and branches keep concurrent batch writes safe.

How it reads

find_experts ranks people by vector similarity, full-text, and graph structure all at once, fusing them into a single ranked result. The whole lens is a file you lint, version, and review.

queries/team.gq

query find_experts($topic: String) {
    match { $p: Person }
    return { $p.name, $p.role }
    order { rrf(nearest($p.embedding, $topic),
                bm25($p.bio, $topic)) }
    limit 5
}

[Branches]

Git-style workflows

Many agents work the same graph at once, each on its own branch, merging into main only through review.

Fig. A single hour on one graph: Hermes adds new data on hermes/ingest while Claude Code dedupes records on claude/dedupe.

Claude Code and Hermes each fork main into their own branch.

cheap fork$ omnigraph branch create

Hermes adds new nodes and edges while Claude Code dedupes existing records. Isolated branches never collide.

schema + policy enforced$ omnigraph mutate

Each branch's diff is approved by a human or another agent before it lands.

human or agent$ omnigraph diff

Both land on main in review order, three-way and attributed to their agent.

three-way · audited$ omnigraph branch merge

✓hermes/ingest and claude/dedupe merged into maineach commit attributed to its agent

No agent touches main directly. The schema rejects malformed writes at the branch, the policy decides who can merge, and the commit graph records every change and its author. Two agents, one graph, no collisions.

[Capabilities]

Key features

Hybrid retrieval

Vector, full-text, and graph traversal in one query, fused with rrf().

Typed schema

Writes are typed and checked, rejected at the branch before they land.

Atomic whole-graph commits

Readers see a consistent snapshot, never a partial write.

Three-way merge

Row-level merges with typed conflicts, not last-write-wins.

Time travel

Every version stays queryable; pin a query to any snapshot.

Approval-gated operations

Destructive changes need explicit approval before apply runs.

Object-storage native

Data, catalog, and state live in one S3-compatible bucket.

Actor audit

Every commit records its actor, resolved server-side.

Anti-probing security

Denied and nonexistent are indistinguishable from outside.

[Agent-native]

Graph optimized for agents

Your agents work with graph data the way engineers work with code: branched, typed, reviewed, merged, audited, and governed.

[Clients]

SDKs and plugins

An open platform, easy to integrate. Available to agents, humans, and apps through different means.

[Infra]

Deploy on infrastructure you own

Not options to weigh, but guides and blueprints to follow: docs to run locally, guides for your own servers, and clone-and-go blueprints for the cloud.

[Cookbooks]

Start from a working graph

Cookbooks are runnable Omnigraph projects: schema, queries, seed data, and agent skills in one repo. Clone one, apply it, and inspect a real graph before you design your own.

Industry intel

Track AI and ML market signals through the SPIKE frame: signals, patterns, insights, and know-how.

Pharma intel

Monitor trials, filings, competitors, and market movement in a graph built for competitive intelligence.

Context graph

Model decisions, traces, actors, and artifacts so an organization becomes queryable by agents.

VC OS

Connect deal flow, theses, founders, portfolio signals, and follow-up work.

Biomed research

Track papers, claims, entities, and evidence across biotech and medical research.

Second brain

A personal operating graph for notes, people, commitments, routines, and recurring work.

[Stack]

Foundation

Built on a strong open-source foundation, aligned with the next-gen lakehouse graph.

The engine: typed, fast, memory-safe systems code.

Open columnar storage with versioning, so the graph remains readable files.

The in-memory standard for columnar data interchange.

Query execution for filtering, sorting, aggregation, and ranked retrieval.

Policy enforcement in the engine, applied before writes land.

EngineRust · edition 2024

Version0.7.0

StorageS3 · RustFS · any S3-compatible bucket

FormatLance · open columnar

Retrievalgraph · vector · full-text · hybrid (RRF)

Branchinggit-style · three-way merge · time travel

PolicyCedar · enforced in-engine

ConfigTerraform-style · cluster + operator surfaces

ClientsCLI · TypeScript SDK · MCP

LicenseMIT · open source

Deploylocal · self-hosted · AWS · Railway

On object storage you own (S3 or RustFS), in the open Lance format. No proprietary store, no lock-in.

Agents branch the graph and propose writes in isolation; changes merge after review, like code. Every change is visible, reviewable and reversible.

Yes. On-prem runs with no outbound calls, on your hardware and network; you hold every key.

Through the TypeScript SDK against a running omnigraph-server, or via the MCP server that bridges Omnigraph into LLM hosts like Claude Desktop and Claude Code.

Yes, MIT-licensed. The engine, CLI and server live in the ModernRelay/omnigraph workspace.

curl -fsSL https://raw.githubusercontent.com/ModernRelay/omnigraph/main/scripts/install.sh | bash

Graph as code. Object-storage native. Optimized for context assembly.