01 / Overview
The relationships are part of the data.
A document supports a claim. A service depends on another service. A task belongs to an objective and produces a result. When those connections matter to an application, they belong in its database.
GraphSub is a graph database written in Rust. It stores entities and their relationships, lets applications query the paths between them, and connects vector similarity search with the surrounding graph. Persistent storage and recovery mechanisms let the data outlive the process working on it.
The system reaches from compact graph records and storage internals to query interfaces, algorithms, and primitives for agent state. You can use it to build a knowledge graph, model application dependencies, or give ongoing work a shared representation.
02 / Capabilities
What it brings to the work.
Model a connected domain
Represent the things in your application as typed nodes, with edges for the relationships between them. Store properties and source context alongside that structure. The data model can distinguish observations, reports, inferences, and contested information, so an application can record how a claim is being treated.
Query paths and patterns
Use Cypher to describe patterns in the graph, or work through the REST and GraphQL interfaces. Follow a dependency, inspect a neighborhood, or ask which records share a connection. Query planning and graph traversal sit inside the database engine.
Connect similarity with structure
Associate embeddings with graph nodes and use vector search to find related material. A result has a place in the graph: the application can continue from a similar passage to its source, subject, or related work. The engine includes an HNSW index for approximate nearest-neighbor search.
Load, retain, and recover
Batch operations load nodes and edges efficiently. The persistence path includes write-ahead logging, checkpoints, integrity checks, and recovery of stored shards. These mechanisms support applications that need to reopen their graph and continue using retained data.
Examine the shape of the graph
Use graph algorithms to find paths, identify connected components and communities, or measure how central a node is. These operations help explore a network of concepts, a dependency map, or the structure of an organization.
Respond to graph changes
Subscriptions let applications receive graph-change events over a live connection. Follow selected nodes or relationship types and update a view or trigger the next application step when relevant data changes.
Represent ongoing agent work
Memory, goals, and coordination primitives give agent applications structures to build on. Connect an objective to its tasks, observations, and outputs. Keep the state available for the next interaction, with explicit relationships that a person or another agent can inspect.
03 / How it works
Build with connected data.
- 01
Define the domain
Choose the entities, properties, and relationship types your application needs. Give source material and working objects an identity.
- 02
Load and connect
Create nodes and edges, attach properties or embeddings, and retain the links that explain where the information came from.
- 03
Query and examine
Find relevant nodes, traverse their relationships, and use graph algorithms to inspect the larger structure.
- 04
Update and carry forward
Write the next state, observe relevant changes, and reopen persisted data when work continues in a later process.
Example application model
Follow a finding through the work that uses it.
A research application can connect a source document to an extracted claim, the task that reviewed it, and the report that used it. If the source changes, the application can follow those relationships to find which conclusions need another look. Vector search helps locate relevant material; graph queries reveal how it fits together.
- 01Source document
- 02Supported claim
- 03Review task
- 04Resulting report
04 / The connected system
A working database. A growing common foundation.
GraphSub is a product in its own right and the graph foundation we are progressively bringing beneath more of Distributed Systems. We brought individual services to market as they became useful. Today, parts of the portfolio still use their own storage and processing systems.
The direction is a common graph connecting research findings, document passages, video moments, and the tasks that use them. Search and extraction make material accessible; GraphSub provides a place to represent the relationships that an application wants to keep.
Lingo already provides a concrete integration: selected world artifacts can be stored in GraphSub and reopened with their source and runtime identities. That gives a calculation a retained context that later work can inspect and use.
