Skip to content
Ahura OS
Get $10 free
Try Ahura OS with Get $10 trial credit. Register and start building.
All services
Remember

Ahura Graph

Relationships an agent can walk.

A lightweight graph for the connections between things: entities, tasks, sources, decisions. Agents link nodes and traverse them to answer questions that tables handle badly.

What it does

  • Nodes and typed edges

    Model people, documents, tasks and how they relate.

  • Bounded traversal

    Walk outward from a node with depth and result limits that keep cost predictable.

  • Properties on both

    Attach data to nodes and edges, not just labels.

  • Shares the partition

    Same isolation, billing and lifecycle as the rest of the agent state.

An agent calls it like this

{ "tool": "graph.traverse", "start": "task:482", "direction": "out", "labels": ["depends_on"], "max_depth": 3 }

Interactive simulation

Try Ahura Graph

Press Run to send the call. The dashboard shows what it would use in a partition. Simulated: nothing is actually executed.

ahura mcp · ptn_demo_7f3a

# Add a node.

→ POST /mcp

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "graph.node.put",
    "arguments": {
      "id": "task:482",
      "label": "task",
      "props": {
        "title": "Ship report"
      }
    }
  }
}

# Link it to another.

→ POST /mcp

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "graph.edge.put",
    "arguments": {
      "from": "task:482",
      "to": "task:310",
      "label": "depends_on"
    }
  }
}

# Walk the dependencies.

→ POST /mcp

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "graph.traverse",
    "arguments": {
      "start": "task:482",
      "direction": "out",
      "labels": [
        "depends_on"
      ],
      "max_depth": 3
    }
  }
}

Ready. Press Run.

ptn_demo_7f3a

Partition · N. Virginia · created just now

Simulated
Activeus-eastRetention hold
Run time
0.0s
0 calls
Size
2.3MB
0.00 ACU used

Services in this partition

  • Graph

    0 calls · 0.00 ACU

Spend by service

Ledger

  • No usage yet.

Why it matters

Where Ahura Graph beats a graph database you run.

Relationships are where agents reason best, and where tables serve them worst. A dedicated graph database fixes that but adds a system to run.

Tables, or a graph database

  • Model relationships as join tables and write multi-hop queries by hand, or stand up a graph engine.
  • Learn and maintain a separate query language.
  • Keep the graph in step with the rest of your agent’s state.
  • Pay for an always-on cluster to answer occasional questions.

Ahura Graph

  • Nodes and edges are tool calls. Neighbours, walks and shortest paths are one call each.
  • No query language to learn, and bounded walks that cannot run away.
  • Lives in the same partition as memory, files and records.
  • Pay per call, with nothing running when nobody is asking.

  • Multi-hop

    Follow connections several steps in a single call.

  • Paths

    Shortest route by hops or by weight.

  • Bounded

    Depth and size limits keep every query predictable.

  • Together

    Same isolation, billing and lifecycle as your other state.

Ahura Graph is a lightweight property graph. For large-scale graph analytics, compose bounded calls in a workflow.

In depth

What Ahura Graph can do.

  • Labelled nodes with properties

    Model people, documents, tasks or anything else. Properties are free-form JSON.

  • Directed, typed edges

    Connect nodes with labelled relationships that carry their own properties and a weight.

  • Both directions are fast

    Follow a relationship forwards or backwards with equal speed.

  • Neighbours in one call

    Ask for everything connected to a node, filtered by direction and edge type, with the node details included if you want them.

  • Bounded traversal

    Walk outward up to 6 levels with filters on nodes and edges. Hard limits stop a runaway walk and the response tells you if it was cut short.

  • Shortest paths

    Find the shortest route between two nodes, by hops or by edge weight.

  • Find nodes by property

    Declare an index on a property and look nodes up by equality or range.

  • Safe deletes

    Delete a node with all its edges, or refuse to delete one that is still connected.

  • Bulk loading

    Create up to 100 nodes and 100 edges in a call, with per-item results.

Every call, listed

14 tools your agent can call. Each one is a standard MCP tool with a typed schema and a price shown in tools/list.

Nodes

graph.node.put
Create or update a node, with optional version check.
graph.node.get
Read a node and, optionally, its connection counts.
graph.node.list
List nodes by label with paging.
graph.node.find
Find nodes by an indexed property.
graph.node.delete
Delete a node, optionally with its edges.

Edges

graph.edge.put
Connect two existing nodes.
graph.edge.get
Read one edge.
graph.edge.delete
Remove an edge.

Querying

graph.neighbors
Edges, and optionally nodes, next to a node.
graph.traverse
Breadth-first walk with depth, size and filter limits.
graph.path
Shortest path, unweighted or weighted.

Management

graph.index.create / drop
Add or remove a property index on live data.
graph.bulk
Load many nodes and edges at once.
graph.stats
Node and edge counts.

Ahura Graph is a lightweight property graph. It does not speak Cypher, Gremlin or SPARQL, and larger graph analytics are best composed as workflows of bounded calls.

Use cases with Graph

All use cases

and 1 more

Works with

Next: Ahura Search

Ahura Memory

Fast working memory for agents.

Ahura Store

Persistent files and objects.

Ahura NoSQL

Document collections without the setup.

Ahura Search

High performance vector/embedding search

Partitions

Where this service's data lives and how it freezes.