# Omnigraph

Source: https://www.omnigraph.dev/

Object-storage native graph database with branching and typed ontology.

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

To set Omnigraph up, an agent can follow the onboarding guide: https://www.omnigraph.dev/onboarding.md

[GitHub](https://github.com/ModernRelay/omnigraph) · [Docs](https://www.omnigraph.dev/docs.md) · [Studio](https://www.omnigraph.dev/studio.md) · [Cloud](https://www.omnigraph.dev/cloud.md)

## In their words

> I mostly use Omnigraph to build a company brain. It fit so well that I ended up contributing Azure Blob Storage support myself.
>
> — Roey Zalta, Data & AI Solutions Engineer, Microsoft

> Omnigraph is the right model for an agent-driven company brain. Agents work on branches across staging and production graphs, and nothing reaches main without review. It’s open source, so when I needed something, I sent a PR instead of waiting.
>
> — Joan Reyero, VP of AI & Data, The Linux Foundation

## Omnigraph is a foundation for

- **Company brain.** Org knowledge in one graph.
- **Agent memory.** Versioned memory per agent or task.
- **Context graph.** Decisions and tribal knowledge.
- **Research graphs.** Hypotheses and results, reviewed.

## Key capabilities

### Typed schema

All your agents share one model of the domain they work in, and every write is checked against it.

What to notice: A decision can't be saved unless it links to the meeting it was made in.

```graphql
node Person {
  handle: String @key
  role: enum(engineer, pm, agent)
}

node Team {
  name: String @key
}

node Meeting {
  slug: String @key
  title: String
  held_on: Date
}

node Decision @instruction("Link every decision to the meeting it was made in.") {
  slug: String @key
  title: String
  body: String @index
  embedding: Vector(1536)? @embed("body") @index
}

edge MemberOf: Person -> Team @card(1..1)
edge Attended: Person -> Meeting
edge DecidedIn: Decision -> Meeting @card(1..)
```

### Branches

Agents work on their own branch, so nothing they write reaches the shared graph until you've reviewed exactly what changed and merged it.

What to notice: While scout works, main doesn't change. Its work only lands once you've seen the diff and merged.

```console
# scout works on its own branch
$ omnigraph branch create agent/scout
$ omnigraph mutate --branch agent/scout --as scout -e '
    query decide() {
      insert Decision { slug: "dead-letter", title: "Dead-letter failed webhooks",
                        body: "Replay them by hand after the last retry." }
      insert DecidedIn { from: "dead-letter", to: "webhook-review" }
    }'
changed agent/scout via decide: 1 nodes, 1 edges
# main doesn't see it yet
$ omnigraph query --branch main -e '
    query check() { match { $d: Decision { slug: "dead-letter" } } return { $d.title } }'
0 rows from branch main via check
# when the work is done: review, then merge
$ omnigraph branch diff agent/scout
insert node Decision dead-letter
insert edge DecidedIn  dead-letter -> webhook-review
$ omnigraph branch merge agent/scout --into main
merged agent/scout into main: fast_forward
```

### Hybrid search

Agents get the right context in one query: follow relationships, filter on structured fields, and rank by meaning and keywords.

What to notice: Vector search alone would also return Tom's retry decision. Walking the graph first keeps only decisions from the platform team's meetings.

```graphql
query team_decisions($team: String, $q: String) {
  match {
    $t: Team { name: $team }
    $p memberOf $t
    $p attended $m
    $d decidedIn $m
  }
  return {
    $d.title, $m.title,
    rrf(nearest($d.embedding, $q), bm25($d.body, $q)) as score
  }
  order { rrf(nearest($d.embedding, $q), bm25($d.body, $q)) }
  limit 5
}
```

```console
$ omnigraph query team_decisions --query search.gq \
    --params '{"team":"platform","q":"how many times do we retry webhooks?"}'
2 rows from branch main via team_decisions
d.title                                 | m.title                    | score
----------------------------------------+----------------------------+-------
Retry webhooks with exponential backoff | Webhook reliability review | 0.0328
Add a retry budget per customer         | Queue outage postmortem    | 0.0323
```

### Declarative config

The whole deployment is a folder in Git: the graphs, their schemas, the queries agents can call, and who may do what. You change it like code, and a plan shows what will happen before anything does.

What to notice: The plan lists every change before anything is written, down to the schema migration, so a change to what agents can do gets reviewed like a code change.

```yaml
version: 1
graphs:
  brain:
    schema: schema.pg
    queries: queries/
policies:
  brain-access:
    file: graph.policy.yaml
    applies_to: [brain]
```

```console
# schema.pg gives decisions a status; queries/open.gq is new
$ omnigraph cluster plan --target ../company-data --as alice
cluster plan: 3 change(s)
  Update graph.brain
  Create query.brain.open_decisions
  Update schema.brain
      {"kind":"add_property","type_name":"Decision","property_name":"status",…}
$ omnigraph cluster apply --target ../company-data --as alice --json \
    | jq -c '{status, converged: .result.converged}'
{"status":"complete","converged":true}
```

### Object storage

The whole graph lives in object storage as open Lance tables: the data, every branch and commit, and the config. Servers only compute, so there's no database disk to size or grow, and the graph gets the durability, scale and cost of object storage. The files are open, so DuckDB or any other Lance reader can query them too.

What to notice: No server keeps anything of its own. Add readers as traffic grows, and a new writer picks up every branch and commit where the last one stopped.

Where the graph lives:

```text
agents and apps
                  |
                  v
+- Omnigraph servers, stateless ---+      your tools
| +--------+ +--------+ +--------+ |      +--------+
| | reader | | reader | | writer | |      | DuckDB |
| +--------+ +--------+ +--------+ |      +--------+
+----------------------------------+
      |          |          |                 |
      v          v          v                 v
+--------------------------------------------------+
| s3://your-bucket/                                |
|   __cluster/             queries, policies       |
|   graphs/company.omni/                           |
|     __manifest/          branches                |
|     __history/           commits, schemas        |
|     nodes/                                       |
|       0000...000a/       Person, a Lance table   |
|         data/*.lance     rows, as columns        |
|         _indices/        vector, FTS, scalar     |
|         _versions/       every version           |
|       0000...0009/       Meeting                 |
|     edges/                                       |
|       0000...000b/       Attended                |
+--------------------------------------------------+
```

## The Knowledge IDE

A blazing fast, GPU-rendered desktop app to visualize your ontology and graph, inspect knowledge, and review changes before they merge.

- **Spot changes.** Open an agent's branch and see what it added, changed and removed, in place.
- **Inspect a record.** See any entity as a page: its properties and everything linked to it.
- **Explore links.** Follow relationships out on a canvas or down a tree.
- **Query safely.** Write queries against the schema. A typo shows up before anything runs.
- **Approve a merge.** Go through a branch change by change, then merge it into main.

[Download Studio](https://www.omnigraph.dev/studio.md) for macOS, Linux and Windows.

## Git for your knowledge graph

Branch, commit, diff, merge and history, for facts instead of files. Here is one fact going through all five.

### Branch

Propose without touching main.

```bash
omnigraph branch create \
  agent/scout
```

```text
created branch agent/scout
from main
```

### Commit

Every write has an author.

```bash
omnigraph mutate \
  --branch agent/scout
```

```text
graph_branch: agent/scout
actor_id: scout
```

### Diff

Review facts, not rows.

```bash
omnigraph branch diff \
  agent/scout
```

```text
update node Person tom
  role: pm -> engineer
```

### Merge

Conflicts listed, never overwritten.

```bash
omnigraph branch merge \
  agent/scout --into main
```

```text
merged agent/scout into main
```

### History

Read the graph as it was.

```bash
omnigraph query \
  --snapshot <commit>
```

```text
--snapshot <last week>
role: pm
```

[Read the branching guide](https://www.omnigraph.dev/docs/branching.md)

## Deploy anywhere

- **[Embedded](https://www.omnigraph.dev/docs/getting-started/install.md).** A folder on your machine. No server, no infra.
- **[BYOC](https://github.com/ModernRelay/omnigraph-cookbooks).** AWS, Azure or GCP, in your own cloud account.
- **On-prem.** Your own servers and any S3-compatible store.
- **[Omnigraph Cloud](https://www.omnigraph.dev/cloud#join).** Run by us: a dedicated cluster with SSO, policy and audit.

[Read the deployment guide](https://www.omnigraph.dev/docs/getting-started/deployment.md)

## Start from a use case

Each use case is a ready-to-run Omnigraph graph: a schema, stored queries, access policies and sample data. Explore its ontology here, then load it and change it to fit your own work.

- **[Company brain](https://www.omnigraph.dev/use-cases/company-brain.md).** A company's people, projects, claims, decisions and commitments, each tied to the exact words it rests on, shared by its people and agents.
- **[Development graph](https://www.omnigraph.dev/use-cases/dev-graph.md).** Issues, epics, specs, decisions, pull requests, releases and incidents as one graph, with the Git host still the record for code.
- **[Agent work queue](https://www.omnigraph.dev/use-cases/beads.md).** A dependency-aware issue queue for coding agents, in the style of beads: file work, link what waits on what, claim what is ready, close it.
- **[Hardware program](https://www.omnigraph.dev/use-cases/hardware-program.md).** Requirements, budgets, interfaces and verification for a hardware program, with "verified" and "over budget" worked out from the evidence on every read.
- **[Industry intelligence](https://www.omnigraph.dev/use-cases/industry-intel.md).** Signals, patterns and insights about an industry, linked to the products and technologies they concern, with hybrid search over the sources.
- **[Pharma intelligence](https://www.omnigraph.dev/use-cases/pharma-intel.md).** Competitive intelligence for a biotech program: the compounds, trials and deals around it, the program's own assumptions, and which signals contradict them.

[Browse all use cases](https://www.omnigraph.dev/use-cases)

## Foundation

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

- [Rust](https://github.com/rust-lang/rust)
- [Lance](https://github.com/lance-format/lance)
- [Arrow](https://github.com/apache/arrow)
- [DataFusion](https://github.com/apache/datafusion)
- [Cedar](https://github.com/cedar-policy/cedar)

## At a glance

| | |
|---|---|
| Engine | Rust |
| Version | 0.15.0 |
| Storage | S3-compatible · Azure Blob (preview) · local disk |
| Format | Lance · open columnar |
| Retrieval | graph · vector · full-text · hybrid (RRF) |
| Branching | zero-copy · git-style · three-way merge · time travel |
| Policy | Cedar · enforced in-engine |
| Config | Terraform-style · cluster + operator surfaces |
| Clients | CLI · TypeScript SDK · Python SDK · MCP |
| License | MIT · open source |
| Deploy | embedded · BYOC (AWS, Azure, GCP) · on-prem |

## FAQ

### What is a context graph?

A graph of what your agents need to know: people, projects, decisions, documents, and how they connect, kept current as agents and people work. Omnigraph is the database underneath one: typed, versioned, and searchable by graph traversal, vector and full-text in a single query.

### Is Omnigraph an open source graph database?

Yes. The engine, CLI and server are MIT-licensed on GitHub. The graph is stored as open Lance files in S3-compatible storage, Azure Blob (in preview) or a local directory, so it runs anywhere: embedded on a laptop with no server, or in your own cloud account.

### Graph database vs vector database: which do AI agents need?

Usually both. A vector database finds text similar to a question; a graph database follows how people, projects and decisions connect. Omnigraph does both in one query: vector, keyword and hybrid ranking over the same typed nodes you traverse, so there are no two stores to keep in sync.

### Can I use Omnigraph for GraphRAG?

Yes. Store documents, chunks and the entities they mention as typed nodes and edges, with embeddings on the nodes. One query ranks chunks by vector, keyword or hybrid similarity and traverses to the related entities and sources, so the context you give the model comes with its connections.

### What database should I use for AI agent memory?

One your agents can write to safely and you can audit. In Omnigraph each agent writes on its own branch, the schema is enforced on every write, Cedar policies run inside the engine, and changes reach main only through a merge you can diff first. Every version stays readable, so you can see what an agent knew and when.

### Is Omnigraph a Neo4j alternative?

For agent workloads, yes. Neo4j is a mature graph database. Omnigraph is MIT-licensed, keeps the graph as open files in storage you own, and is built around what agents need: git-style branches and merges, a typed schema checked on every write, built-in vector and full-text search, and in-engine policy.

### Does Omnigraph work with MCP?

Yes. omnigraph-server serves MCP at /mcp, so Claude, ChatGPT, Cursor or any MCP client can read the schema, run queries and, where your Cedar policy allows it, write. omnigraph mcp connects a local agent to a served graph.

### Where does my data live, and what does it cost?

In storage you own (S3-compatible, Azure Blob or local disk), as open Lance files that stay readable without us. The engine is free and open source: you pay only for your own storage and compute.

## Get started

Install the `omnigraph` CLI on macOS or Linux:

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

or with Homebrew:

```bash
brew tap ModernRelay/tap
brew install ModernRelay/tap/omnigraph
```

- [Documentation](https://www.omnigraph.dev/docs.md): Install and deployment guides.
- [Use cases](https://www.omnigraph.dev/use-cases): Ready-to-run graphs to start from.
- [TypeScript SDK](https://www.npmjs.com/package/@modernrelay/omnigraph): @modernrelay/omnigraph
- [Python SDK](https://pypi.org/project/omnigraph/): pip install omnigraph
- [MCP server](https://www.omnigraph.dev/docs/operations/mcp.md): Built into omnigraph-server at /mcp.
- [Source on GitHub](https://github.com/ModernRelay/omnigraph): MIT-licensed graph engine.
- [Slack community](https://join.slack.com/t/omnigraphworkspace/shared_invite/zt-3wfpglyxj-lHvJGhuySPfqLtN35uJZNw): Ask questions, follow development.
