Real-time streaming · MCP built in · openCypher · Rust

Make your data agent-ready.
In real time.

Q: How does the built-in MCP server work?

The engine exposes a Streamable HTTP MCP endpoint at /mcp (and /api/mcp) on port 8080, plus an optional standalone jetgraph-mcp binary for stdio or separate HTTP hosting. Agents get 14 tools — including get_schema, get_neighbors, get_edge_state, get_histogram, find_similar, guarded read-only cypher_read, and signal/segment tools — plus the investigate prompt.

JetGraph turns your streaming data into a live graph of entities, relationships, and behavior over time — one that AI agents can understand, query, and act on through a built-in MCP server.

Get Started Connect an agent

Agent query via MCP http://localhost:8080/mcp

“What changed for this entity in the last 24 hours?”

get_schema()reads description & business_meaning

get_histogram(24h vs 7d)compares hourly burst to baseline

get_neighbors()resolves connected entities

get_edge_state(pair)tx_count, approx_sum, last_seen

Compact structured answer — no raw event table dump, no brittle multi-table SQL.

What the graph keeps per relationship 1 record per (src, dst) pair

tx_count & approx_sumlifetime count and tracked total

last_seenlatest event unix timestamp

8-bin histogramvalue distribution over time

21-tick activity bitmapsliding window counts & bool_flag

Product

What is JetGraph?

JetGraph is a real-time, in-memory graph engine that turns streaming subject-area data into a live graph AI agents can understand and analyze.

It is not a generic replacement for every graph-database workload, not a full Neo4j drop-in, and not an agent framework or LLM. JetGraph is the live data layer agents connect to over MCP — and the same graph serves sub-millisecond gRPC, HTTP/Cypher, and Bolt reads to decision services.

Four pillars

Real-time streaming

Events stream in continuously over gRPC IngestStream and HTTP graph.ingest, so the graph is current the moment an agent asks.

Agent-readable by design

Schema types carry description and business_meaning, and edges store compact per-pair summaries instead of raw rows — keeping answers small and cheap in tokens.

MCP built in

14 tools mounted at /mcp (and /api/mcp) with a read-only Cypher guard, capped page sizes, and an investigate workflow prompt.

Predictable footprint

Keeps the meaning, not the event log. Memory follows how many entities and distinct relationships you hold, not how many events you stream.

Product overview MCP for AI agents Why JetGraph Documentation

How It Works

Stream. Model. Ask.

Turn continuous event streams into a live, self-describing graph that AI agents and low-latency services can read side by side.

Step 01

📡

Stream

Push domain events as they happen over bidirectional gRPC streaming, single-request ingest, or HTTP procedures. No waiting for overnight warehouse syncs.

IngestStream (gRPC stream)

IngestTransaction / UpsertEdge

CALL graph.ingest(...)

Step 02

🧠

Model

Every connected pair updates one compact in-memory record in place while rolling node histograms track time windows. Schema metadata carries plain-language business meaning.

description & business_meaning

tx_count, approx_sum, last_seen

8-bin histograms & 21-tick bitmaps

Step 03

🤖

Ask & Act

Connect AI agents directly to /mcp to inspect schema, compare windows, run read-only Cypher, or author live segments — while services query via gRPC, HTTP, or Bolt.

Streamable HTTP /mcp (14 tools)

create_signal & create_segment

gRPC, POST /cypher, Bolt :7687

Agent-Ready Data Layer

Why AI agents work better
on a live graph

Agents struggle when business context is scattered across normalized SQL tables or frozen in static text chunks. JetGraph gives them structure, semantics, time windows, and guardrails in one place. See Why JetGraph and features.

📖

Self-Describing Schema

Node and edge types store description and business_meaning right in the engine. Agents call get_schema first and map user questions to real domain concepts without guessing column names.

get_schema · business_meaning

🗜️

Compact, Token-Light Answers

Because each relationship pair is summarized into counts, approximate sums, recency, and bins, an agent reads one concise record instead of paging through thousands of raw event rows.

1 record per (src, dst) pair

⏱️

Time-Aware by Default

Built-in hourly and daily node histograms plus 21-tick edge activity bitmaps let agents compare recent bursts against longer baselines in a single tool call.

get_histogram · get_edge_state

🕸️

Relationship-Native Exploration

Traverse hops, inspect latest activity, estimate distinct fan-out, and find weighted lookalikes via shared neighbors without writing multi-join SQL queries.

get_neighbors · find_similar

🛡️

Built-In Agent Guardrails

cypher_read rejects write keywords (CREATE, MERGE, DELETE, SET, REMOVE, DROP) and caps output at 100 rows. Pagination and similarity limits prevent runaway scans.

Read-only Cypher · LIMIT ≤ 100

⚡

Always Fresh, Never Stale

Streaming writes update the in-memory graph immediately. Agents can also promote findings into live evaluator rules via create_signal and create_segment.

IngestStream · live segments

Predictable Footprint

Keeps the meaning, not the event log

Stream a billion events; JetGraph stores the relationships. Each pair of connected entities is one compact record, updated in place — so memory follows how many entities and relationships you have, not how many events you send.

Guessable RAM sizing from your schema

Every edge type picks a fixed per-pair payload at registration: Full (~52 B with 8-bin histogram, 21-tick bitmap, count, sum, recency), Slim (~32 B without per-pair bins), or Static (~16 B value + timestamp only), plus fixed-size per-node histograms.

Estimated edge RAM ≈ distinct (src, dst) pairs × bytes_per_pair (52 B / 32 B / 16 B)

The same aggregation is why agent answers stay small: instead of retrieving thousands of raw event rows, an agent inspects one compact summary record per relationship. Verify exact runtime memory anytime with CALL db.memoryUsage().

Memory & compression docs

What this does — and does not — mean

Not a system of record: individual events are folded into the pair summary and cannot be listed or replayed later. approx_sum is approximate.
Bounded time windows: temporal detail is kept within the configured hourly/daily histogram slots and 21-tick activity horizon.
Grows with distinct pairs: adding new entities or new distinct relationships still allocates memory (set state_ttl_secs to expire idle pairs).
Node properties remain stored: node identifiers and registered properties stay in memory — this is a footprint and data-minimization design, not a compliance certification.

Model Context Protocol

14 MCP tools built right into the engine

Point Cursor, Claude, or custom agent runtimes at http://localhost:8080/mcp (or run the standalone jetgraph-mcp binary). No glue service required.

Understand

Read the live schema, business meanings, and existing evaluator definitions.

get_schema list_signals list_segments

Explore

Traverse paginated neighborhoods, check latest targets, and find lookalikes.

get_neighbors get_neighbor_count get_last_neighbor find_similar

Behavior over time

Inspect pair state, rolling hourly/daily histograms, and 32-slot feature vectors.

get_edge_state get_histogram get_feature_vector

Ask anything

Run multi-hop patterns, property filters, and Top-K rankings behind a read-only guard.

cypher_read

Act

Turn findings into live evaluator signals and segments, and inspect members.

create_signal create_segment list_segment_members

mcp.json — Streamable HTTP

{
  "mcpServers": {
    "jetgraph": {
      "url": "http://localhost:8080/mcp"
    }
  }
}

Explore MCP for agents MCP reference docs

Contrast

Why not just give the agent SQL or a vector store?

SQL warehouses and vector stores solve different problems. JetGraph supplies the live, time-windowed relationship layer they lack. Compare with Neo4j, PostgreSQL, Redis, and feature stores.

🗄️

Raw SQL & Warehouses

Agents write fragile multi-table joins across raw event tables, hit timeouts or scan huge partitions, and get thousands of unaggregated rows back that blow up context windows.

🧲

Vector Stores & Text RAG

Great for unstructured documents, blind to live entity structure. Embeddings cannot count how many interactions happened in the last 24 hours or trace shared devices and accounts.

🕸️

JetGraph Live Graph

Maintains compact relationship summaries and rolling windows as events arrive, with business_meaning baked into the schema and 14 bounded MCP tools ready for agents.

Use Cases

One live graph, many agentic use cases

Model any subject area once as entities, relationships, and time windows — then let AI agents and real-time services act on the same graph. Explore all nine use cases including Knowledge Graph on the use cases hub.

Fraud Management

Fraud Rings & Investigation

Stream transactions, devices, and IPs into a live fraud graph. Let analysts and agents trace shared-entity rings, inspect pair novelty, and manage fraud cases over MCP.

get_edge_state GetFraudContext shared_device_ring

Risk Scoring

Real-Time Risk Scoring

Query historical graph state before committing an event, score with your rules or model, write back via IngestTransaction, and let agents explain why an entity spiked.

QueryNodeHistogram GetEdgeState CreateFraudCase

Marketing

Agentic Segmentation & Offers

Turn customer spend, product holdings, and campaign touches into a live marketing graph. Agents discover lookalikes with find_similar and create dynamic segments.

Retail & E-Commerce

Shopper Journeys & Affinity

Model views, cart adds, purchases, and co-bought products as a live compact graph. Merchandising and retention agents query category shifts and reactivation signals directly.

BOUGHT_WITH get_histogram category_drift

Customer 360

Live Context for Care & Ops Agents

Connect accounts, services, devices, tickets, invoices, and network events one or two hops away so care agents answer “why is this customer calling?” in one pass.

get_schema get_neighbors cypher_read

Network Security

Lateral Movement & Triage

Map hosts, IPs, identities, and services in real time. Spot first-time connections, fan-out spikes, and compromised-node exposure for SOAR playbooks and triage agents.

get_neighbor_count pair_novelty lateral_hops

Identity & Access

Login & Session Anomalies

Track which identities used which devices, IPs, and locations. Surface new-device novelty, login bursts, and shared-credential clusters before minting a session.

found: false activity_counts shared_device

Recommendations

Live Affinity & Lookalikes

Compute weighted shared-neighbor similarity on live interaction edges with FindSimilarNodes and find_similar, combined with pair novelty and recency.

Also on the Decision Path

One live graph for agents
and real-time scoring

The same in-memory graph that feeds AI agents over MCP also serves sub-millisecond reads to authorize-time services. Follow the three-phase decision loop: query committed history, enrich and score, then ingest and link cases.

Query historical state first

Read pair novelty and 21-tick activity via GetEdgeState, rolling windows via QueryNodeHistogram, fan-out via GetNeighborCount, and open case links via GetFraudContext.

Enrich and decide

Combine graph features in your application or pass a registered scoring_profile on IngestTransaction. Your rules or model own the final decision.

Ingest and manage cases

Write the event via UpsertEdge or IngestTransaction (even when declined), and link confirmed participants with CreateFraudCase or retract misfires with ResolveFraudCase.

Risk scoring pattern Fraud management

Connected Entity & Case Context

🌐 IP · 1.2.3.4

👤 Entity · Case

🏢 Org · Linked

↕ USES_IP

↕ IN_CASE

↕ BELONGS_TO

🌐 IP · shared

📦 Account

📱 Device

Linked to case (GetFraudContext)

Connected participants & neighbors

Built for Real Time

Why the engine stays fast under load

JetGraph is engineered for sub-millisecond reads and high-throughput streaming ingest on a single node. Published benchmarks on the current API surface are being re-measured — see Built for real time.

⚡

100% in memory

The working graph lives in RAM on one node. Queries never hit disk, and recovery loads zstd-compressed snapshots without replaying an event log.

📦

One record per pair

GetEdgeState and QueryNodeHistogram read pre-aggregated counters, bins, and bitmaps directly — no scanning raw historical events at query time.

🦀

Rust & zero GC

Implemented in Rust on Tokio with DashMap sharding and chunked RCU adjacency rows — predictable tail behavior without garbage-collection pauses.

📡

Micro-batched streaming

Bidirectional gRPC IngestStream micro-batches incoming transactions and merges updates by edge type and source node in a single pass.

Get Started Architecture Performance notes

Architecture

One in-memory engine.
MCP, gRPC, HTTP, and Bolt.

JetGraph stores the active graph in memory on one machine — exposing MCP for AI agents alongside gRPC, REST/Cypher, and Bolt for applications. No serialization on the critical path. No disk I/O during queries.

🤖

Built-in Streamable HTTP MCP

Mounted directly inside jetgraph-engine at /mcp (and /api/mcp) on port 8080, plus an optional standalone jetgraph-mcp binary for stdio or separate HTTP hosting.

🗄️

Compact edge store

Edges are stored one record per unique src–dst pair with optional TTL eviction — Full (~52 B), Slim (~32 B), or Static (~16 B).

💾

Memory-efficient encoding

Strings are dictionary-encoded, booleans are bit-packed, and rolling node histograms use compact rings so more entities fit in RAM.

📸

zstd snapshot persistence

Snapshots and delta checkpoints persist state to disk on a configurable interval. Optional warm standby provides failover — not a distributed query cluster.

API Layer

MCP Server — /mcp :8080 14 agent tools · read-only Cypher guard · investigate prompt

gRPC / HTTP2 — port 50051 Schema · Graph · Feature · IngestStream

REST + Cypher — port 8080 POST /cypher · /health · /metrics · /mcp

Bolt Protocol — port 7687 Compatible drivers · openCypher subset

↓ async Tokio runtime

Engine Layer

Graph Engine (Rust) DashMap sharding · Cypher planner · WatchEdgeUpserts CDC

Feature Engine Histograms · 32-slot vectors · FindSimilarNodes · Fraud cases

↓ lock-free reads / chunked RCU writes

Storage Layer

Compact Neighbor Store One record per src–dst pair · Full / Slim / Static · TTL

Node Histograms · Activity Bitmaps Hourly/daily rings · 21-tick pair bitmaps · adaptive inverse index

↓ background snapshot task

Persistence Layer

Snapshot & Delta Checkpoints (zstd) Configurable interval · fast restart · optional warm standby

Demo Stack

Engine, sidecars, and Admin UI in one compose

The Docker demo includes segment evaluation, sequence pattern mining, an Admin UI, and the MCP server so both humans and AI agents can explore live graph signals immediately.

Admin UI

Signals, Schema & Graph Explorer

Visual workspace for schema design with business meanings, Cypher Editor, Graph Explorer, and Analytics — Signals, Segmentation, and Pattern Monitor.

Cypher Editor Signals Graph Explorer

segment-evaluator

Real-Time Segmentation

Evaluate entity membership against configurable Cypher signals as events stream in. Agents can read and author live signals and segments via MCP tools.

list_segments create_signal create_segment

pattern-miner

Sequence Pattern Mining

Subscribe to WatchEdgeUpserts CDC and build transition edges (such as NEXT_MERCHANT) from live streams without custom batch jobs.

WatchEdgeUpserts transition rules live config

Integration

Connect agents via MCP.
Wire services via gRPC or Cypher.

Agents connect to /mcp with zero client boilerplate. For application write and scoring paths, the jetgraph-client Rust crate gives you a typed async API over gRPC.

Connect your agent or client

Point MCP clients at http://localhost:8080/mcp, or add jetgraph-client in Rust, HTTP /cypher, or Bolt on 7687.

Describe your subject-area schema

Register node types, compact edge types, histograms, and description / business_meaning notes so agents understand the domain.

Stream events, query live

Push updates with ingest_stream or upsert_edge; query edge state, histograms, similarity, or MCP tools in real time.

🤖

MCP Server

14 tools at /mcp for AI agents

🦀

Rust Client

Typed gRPC crate & IngestStream

🔤

Cypher HTTP API

openCypher subset — any language

🔌

Bolt Drivers

Compatible drivers on port 7687

Example — jetgraph-client (Rust)

decision_loop.rs

use jetgraph_client::{Client, NodeRef};

let mut client = Client::connect("http://localhost:50051").await?;
let actor = NodeRef::external("account", "acct-01");
let target = NodeRef::external("channel", "web-04");

// Phase 1: read compact pair state + rolling histogram
let state = client.get_edge_state(
    "INTERACTS_WITH", actor.clone(), target.clone(), None, Some(&[300, 3600])
).await?;
let hist = client.features()
    .query_node_histogram(actor.clone(), "INTERACTS_WITH", 24, 0).await?;

// Phase 2: apply your application logic over live graph signals
let is_new_pair = state.as_ref().map_or(true, |s| !s.found);
let burst_24h = hist.total_events;

// Phase 3: upsert compact edge (updates count, sum, last_seen, bins, bitmap)
client.upsert_edge(
    "INTERACTS_WITH", actor, target, Some(125.0), None, None
).await?;

Demo

Up and running in 3 minutes

Try JetGraph locally with Docker — no build required. The demo compose starts the engine, segment-evaluator, pattern-miner, and Admin UI. Connect AI agents over MCP, or applications over HTTP Cypher and Bolt.

Start the stack

Save the file below as docker-compose.yml, then run docker compose up -d. Both images are pulled automatically from Docker Hub.

docker-compose.yml

services:
  graphengine:
    image: alhascan/jetgraph-demo:latest
    restart: unless-stopped
    ports:
      - "8080:8080"
      - "7687:7687"
    volumes:
      - graphengine-data:/data
    environment:
      RUST_LOG: info
      ENABLE_ADMIN_RESET: "true"
    healthcheck:
      test: ["CMD", "sh", "-c", "curl -sf http://localhost:8080/health || curl -sf http://localhost:8080/api/health || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 120s

  segment-evaluator:
    image: alhascan/jetgraph-demo:latest
    entrypoint: ["/usr/local/bin/segment-evaluator"]
    restart: unless-stopped
    environment:
      RUST_LOG: info
      GRAPH_ENGINE_ENDPOINT: http://graphengine:50051
      SEGMENT_EVALUATOR_CONFIG_DB: /data/seg-config
    volumes:
      - seg-config-data:/data/seg-config
    depends_on:
      graphengine:
        condition: service_healthy

  pattern-miner:
    image: alhascan/jetgraph-demo:latest
    entrypoint: ["/usr/local/bin/pattern-miner"]
    restart: unless-stopped
    environment:
      RUST_LOG: info
      GRAPH_ENGINE_ENDPOINT: http://graphengine:50051
      PATTERN_MINER_CONFIG_DB: /data/pm-config
      PATTERN_MINER_ADDR: 0.0.0.0:8082
    volumes:
      - pm-config-data:/data/pm-config
    depends_on:
      graphengine:
        condition: service_healthy

  graphengine-ui:
    image: alhascan/jetgraph-ui-demo:latest
    restart: unless-stopped
    ports:
      # Change 80 to any free host port (e.g. "8081:3000") if port 80 is already in use
      - "80:3000"
    environment:
      BOLT_URL: bolt://graphengine:7687
      NEO4J_USER: ""
      NEO4J_PASSWORD: ""
      GRAPH_HTTP_URL: http://graphengine:8080
      SEGMENT_API_URL: http://segment-evaluator:8081
      PATTERN_MINER_URL: http://pattern-miner:8082
    depends_on:
      graphengine:
        condition: service_healthy

volumes:
  graphengine-data:
  seg-config-data:
  pm-config-data:

Verify the engine is ready

Once the containers are up, check the health endpoint. You should see a JSON response with "ready":true. If you changed the UI host port in the compose file, open http://localhost:<your-port> instead of http://localhost.

bash

# Health check
curl http://localhost:8080/health
# → {"status":"ok","ready":true}

# Then open the admin UI in your browser
open http://localhost

Load sample data with one click

Open the Admin UI at http://localhost, go to Schema in the left nav, and click Apply Schema & Load Sample Data. This provisions a demo schema and seeds a representative dataset so every query and MCP tool returns live results. Prefer your own schema? Skip to Step 05.

Admin UI flow

# 1. Open the UI
open http://localhost

# 2. In the left sidebar, click  Schema
# 3. Click  ⚡ Apply Schema & Load Sample Data
# 4. Explore in Graph Explorer, Cypher Editor, Analytics, or via MCP

Connect via Bolt (compatible drivers)

JetGraph listens on port 7687 with Bolt. Neo4j-compatible drivers work for the supported openCypher subset — no credentials required in demo mode. Full Neo4j Cypher is not guaranteed.

Python — neo4j driver

from neo4j import GraphDatabase

driver = GraphDatabase.driver("bolt://localhost:7687", auth=("", ""))

with driver.session() as session:
    result = session.run("MATCH (c:CARD) RETURN c.external_id AS id LIMIT 10")
    for record in result:
        print(record["id"])

driver.close()
# → card-001

Or — register your own schema & run Cypher queries

If you skipped Step 03, declare your schema manually before writing data. Run these calls via the Cypher HTTP API — or paste them directly into the Cypher Editor in the UI.

bash — POST /cypher

# 1. Register node types
curl -sS -X POST http://localhost:8080/cypher \
  -H 'Content-Type: application/json' \
  -d '{"query":"CALL db.registerNodeType(\"CARD\", \"string\") YIELD node_type_id RETURN node_type_id","parameters":{}}'

curl -sS -X POST http://localhost:8080/cypher \
  -H 'Content-Type: application/json' \
  -d '{"query":"CALL db.registerNodeType(\"MERCHANT\", \"string\") YIELD node_type_id RETURN node_type_id","parameters":{}}'

# 2. Register a relationship type
curl -sS -X POST http://localhost:8080/cypher \
  -H 'Content-Type: application/json' \
  -d '{"query":"CALL db.registerEdgeType({name:\"TRANSACTS_AT\",from_node_type:\"CARD\",to_node_type:\"MERCHANT\"}) YIELD edge_type_id RETURN edge_type_id","parameters":{}}'

# 3. Finalize schema — required before any write can succeed
curl -sS -X POST http://localhost:8080/cypher \
  -H 'Content-Type: application/json' \
  -d '{"query":"CALL db.finalizeSchema() YIELD schema_version RETURN schema_version","parameters":{}}'

# 4. Create nodes and query back
curl -sS -X POST http://localhost:8080/cypher \
  -H 'Content-Type: application/json' \
  -d '{"query":"CREATE (c:CARD {external_id: $id}) RETURN c.external_id AS created","parameters":{"id":"card-001"}}'

Connect your AI agent via MCP

Add the Streamable HTTP endpoint http://localhost:8080/mcp to Cursor, Claude, or your agent client, then ask natural-language questions — the agent calls get_schema first and inspects live relationships automatically.

.cursor/mcp.json (or Claude MCP config)

{
  "mcpServers": {
    "jetgraph": {
      "url": "http://localhost:8080/mcp"
    }
  }
}

Explore visually in the Admin UI

Cypher Editor, Schema, Graph Explorer, plus Analytics — Signals, Segmentation, and Pattern Monitor.

http://localhost

FAQ

Questions humans and AI agents ask

Short, factual answers. The full list lives on the FAQ page.

What does "make your data agent-ready" mean with JetGraph?

Instead of asking AI agents to stitch raw event tables with brittle SQL, JetGraph turns streaming data into a self-describing, in-memory graph. Schema types carry description and business_meaning metadata, relationships store compact time-windowed summaries, and a built-in MCP server gives agents 14 safe tools to understand, explore, and act on live context.

How does the built-in MCP server work?

The engine exposes a Streamable HTTP MCP endpoint at /mcp (and /api/mcp) on port 8080, plus an optional standalone jetgraph-mcp binary for stdio or separate HTTP hosting. Agents get 14 tools — including get_schema, get_neighbors, get_edge_state, get_histogram, find_similar, guarded read-only cypher_read, and signal/segment tools — plus the investigate prompt. See MCP docs.

Does JetGraph store every event?

No. JetGraph keeps the meaning, not the event log. Each connected pair of entities is stored as a single compact record (tx_count, approx_sum, last_seen, 8-bin value histogram, 21-tick activity bitmap) updated in place, alongside fixed-size per-node histograms. Memory grows with distinct entities and relationships (~52 B full, ~32 B slim, ~16 B static per pair), not with raw event volume. Individual events cannot be listed or replayed.

Is JetGraph a graph database?

JetGraph is a real-time, in-memory graph engine. It models entities and relationships, serves MCP tools, an openCypher subset, Bolt, and gRPC, and persists via zstd snapshots. It is not a general-purpose persistent graph database, not a full Neo4j replacement, and not an agent framework or LLM — it is the live data layer agents and decision services talk to.

How do I install JetGraph?

The supported demo path is Docker Compose via the Quick Start. Connect AI agents to http://localhost:8080/mcp, or applications over HTTP POST /cypher, Bolt on 7687, or gRPC on 50051. Official docs are at jetgraph.io/docs and the Rust client is at JetGraphClient.

Ready to make your data agent-ready?

Spin up JetGraph locally with Docker, stream events into a compact live graph, and connect your AI agent over MCP in minutes.

Start Building Explore MCP Tools View on GitHub

$

docker compose up -d

Make your data agent-ready. In real time.