What is Purple8 Hyper Graph?

The honest answer: it is a new category of thing. We call it a Hyper Graph DB.

It started as a knowledge graph. It grew a vector index because every production AI system eventually needs one. Then it grew a workflow engine because every AI workflow eventually needs to track state, enforce SLAs, involve a human, and prove — with an immutable audit trail — exactly what the AI decided, when, and why. Then it grew a full RAG pipeline because once you have the graph, the vectors, and the LLM — the retrieval-augmented generation layer is just the obvious next step.

The result is not a knowledge graph. It is not a vector database. It is not a workflow engine. It is not a RAG framework. It is all four, sharing the same storage layer, the same query engine, and the same process — and it is the sharing that matters. That is why we call it a Hyper Graph DB: it goes beyond what any individual database category can deliver.

When your knowledge graph is your vector index is your workflow state is your RAG retrieval corpus, you eliminate an entire class of engineering:

• No ETL pipeline syncing a graph database to a vector store.
• No microservice bridging your workflow engine to your AI layer.
• No separate embedding store that drifts out of sync with your source of truth.
• No "glue code" mediating between three billing consoles, three auth systems, three failure domains.

One process. One storage layer. One query language. One pip install.

---

What it actually contains

1. A property graph engine backed by BrickCoreStorage (Purple8 Cortex)

Nodes, edges, labels, properties — standard property graph model with a complete Cypher engine covering MATCH, WHERE, WITH, UNWIND, MERGE, CREATE, DELETE, aggregations, path patterns, and subqueries, steered by a 6-strategy cost-based query planner (PROPERTY_INDEX_SCAN, LABEL_INDEX_SCAN, VECTOR_SEARCH, TRAVERSAL, FULL_SCAN, HYBRID).

GraphEngine is backed by BrickCoreStorage (Purple8 Cortex) and BrickWAL:

• Lock-free write path (~7 µs/node): mutations write to a Rust DashMap buffer and fdatasync via BrickWAL before the mutation is committed.
• Hardware-bounded RSS (CortexAutoConfig): at startup, GraphEngine(..., auto_config=True) probes available RAM and solves (M, ef_construction, segment_size, batch_size) so peak process RSS never exceeds alpha × available_ram (default 0.75). Through the brick seal-and-evict cycle, peak memory is bounded by hardware RAM and never grows monotonically with corpus size $N$ — proven by ingesting 8.84M MS MARCO documents on a 24 GB machine in ~9 GB peak RSS (~5.4 GB steady-state query RAM).

2. HNSW vector search + BM25 full-text, built into the query planner

Not a sidecar. Not a separate index you query separately and join in application code. The HNSW vector index and BM25 full-text engine live inside the same process and storage lifecycle as the graph. The Cypher engine calls into it mid-query:

CALL db.vector.search('Document', $queryVec, 10) YIELD node, score
WHERE node.region = 'APAC' AND score > 0.85
MATCH (node)-[:AUTHORED_BY]->(author:Person)
RETURN node.title, author.name, score
ORDER BY score DESC

One query. One round-trip. Run it with QueryLanguage(engine).execute(cypher, params):

• 0.33 ms vector query P99 @ 100K nodes (in-process)
• 40,551 docs/s (40K/s) batch ingest throughput
• 916 QPS and 0.946 recall@10 on VectorDBBench 1M × 768d
• 23 ms HTTP P95 @ 1024d with JWT/API-key auth, BrickWAL, AES-256-GCM encryption, and RBAC all enabled
• 41,284 nodes/s burst ingest and 1,096 QPS concurrent hybrid search on a 16-vCPU / 32 GB RAM enterprise node (100% accuracy across all algorithm, RAG, SOC, and Quantum gates)
• 1.18M requests across 500 concurrent users with 0% error rate in 30-minute soak testing

3. A Journey Engine that uses the graph as its state store

The part that makes Purple8 genuinely different from "Neo4j + Pinecone."

The Journey Engine tracks any real-world entity — a customer, a loan application, a support ticket, a legal matter — as it moves through a defined sequence of stages across multiple systems. Each stage transition is written as a graph edge (ADVANCED_TO). SLA breaches are written as graph edges (SLA_BREACHED). AI decisions are written as graph edges (AI_ADVISED).

The entire operational history of every entity is the graph. You query it with Cypher. You traverse it. You vector-search against it. There is no separate workflow database to sync with.

je = JourneyEngine(engine)

je.define_journey("loan_application", stages=[
    StageSpec("submitted"),
    StageSpec("kyc_verified",    sla=SLAPolicy(breach_after_seconds=7200)),
    StageSpec("credit_assessed", sla=SLAPolicy(breach_after_seconds=14400)),
    StageSpec("approved"),
])

instance = je.start("loan_application", entity_id="customer_123")
je.advance(instance.instance_id, to_stage="kyc_verified", actor="SystemB")

Every advance() call writes a graph edge, fires the AI advisor, checks SLAs, and publishes a CDC event — all in the same transaction.

4. RAG Studio — a configurable RAG pipeline over the graph

Most RAG frameworks sit outside your data store and require you to assemble retrieval, chunking, embedding, generation, and evaluation from scratch. Purple8's RAG Studio is built into the graph engine.

What the registry contains:

Registry	Count	Examples
LLM models	39 across 9 providers	GPT-5.4, Claude Sonnet 4, Gemini 3 Flash, Mistral Large 3, Command A, Llama 4 Maverick
Embedding models	21 across 7 providers	text-embedding-3-small, embed-v4.0, voyage-4-large, gemini-embedding-001
Chunking strategies	8	fixed, recursive, semantic, sentence_window, parent_child, markdown_header, late, syntactic
Reranker models	3	Cohere Rerank v4 Pro, Cohere v4 Fast, Cross-Encoder (self-hosted)

Every parameter — retrieval k, similarity threshold, hybrid weight, MMR diversity, chunk size, overlap, temperature, system prompt — is configurable per-tenant via a guided UI or the REST API (GET/PUT /rag/config).

Evaluation is built in: POST /rag/evaluate runs your test cases through the pipeline and scores them with faithfulness, answer relevancy, context recall, and hallucination metrics.

→ RAG Studio guide for the full walkthrough.

5. Document Intelligence — 70+ formats across 75+ languages

Feed PDFs, Office files, CAD/BIM drawings (IFC, DXF, STEP), SAP IDocs, scanned OCR images, or URLs. Purple8 DocIntel (v0.12.5) parses 70+ document formats across 75+ languages, extracts entities and relationships, and writes them directly into the graph.

6. JourneyAIAdvisor — the graph advises itself

On every stage transition, JourneyAIAdvisor is called with the full journey definition, the current instance state, the complete transition history from the graph, and any few_shot_patterns extracted from past journeys. It returns a structured recommendation written back to the graph. The AI never sees raw data it shouldn't — the advisor only sees what the graph exposes.

7. Human-in-the-loop, built in

Stages marked requires_human=True create a HITLTask node. Humans claim, approve, reject, or escalate via REST endpoints or MCP tools (journey.list_hitl, journey.resolve_hitl) secured by the same JWT/API-key 4-tier RBAC layer. The decision is written to the graph. The audit trail is complete without any extra tooling.

8. Change Data Capture with WebSocket streaming

Every graph mutation — node write, edge write, journey advance, SLA breach — publishes a ChangeEvent to an EventBus. Downstream systems subscribe in real-time via WebSocket (/ws/changes) or egress webhooks (egress.*). Events are persisted for replay. No Kafka required for most workloads.

9. Envelope encryption with 5 KMS providers & built-in SOC

Data is encrypted at rest with AES-256-GCM envelope encryption. Key wrapping is handled by any of: Local keystore, HashiCorp Vault, AWS KMS, GCP Cloud KMS, or Azure Key Vault — configurable at startup, no code changes. An autonomous Security Operations (soc/) subsystem provides real-time threat detection, agent behavioural profiling, and automated containment.

10. REST + GraphQL + MCP (125 tools across 16 namespaces)

A FastAPI server (python -m purple8_graph.secure_server on port 8100, or Docker on port 8000) exposes the full engine over REST, LCNC operational console (/lcnc/), and Strawberry GraphQL. The built-in MCP server (purple8_graph.mcp_server, SSE endpoint /mcp/sse) exposes 125 tools across 16 namespaces (graph.*, rag.*, data.*, journey.*, schema.*, memory.*, registry.*, models.*, quantum.*, egress.*, feedback.*, scheduler.*, admin.*, evolution.*, sentinel.*, guardrails.*) to Claude, Cursor, VS Code Copilot, or any MCP-compatible agent.

---

How it compares

Capability	Neo4j	Pinecone / Weaviate	LangChain + vector DB	Purple8 Hyper Graph
Property graph + Cypher	✅	❌	❌	✅
Vector search	Plugin	✅	✅ (external)	✅ native
Hybrid vector + graph in one query	❌ client-side join	❌	❌	✅
Built-in RAG pipeline	❌	❌	✅ (assembly required)	✅ (configured, not assembled)
39 LLM models, 9 providers	❌	❌	Varies	✅
8 chunking strategies with guided UI	❌	❌	Manual	✅
Workflow / journey tracking	❌	❌	❌	✅
SLA enforcement	❌	❌	❌	✅
AI decision audit trail	❌	❌	❌	✅
Human-in-the-loop	❌	❌	❌	✅
Document Intelligence (70+ formats, 75+ languages → graph)	❌	❌	❌	✅
Real-time CDC / event streaming	Plugin	❌	❌	✅
Envelope encryption (5 KMS providers)	Enterprise add-on	❌	❌	✅
MCP server for AI agents (125 tools, 16 namespaces)	❌	❌	❌	✅
Hardware-bounded RSS (BrickCoreStorage + CortexAutoConfig)	❌	❌	❌	✅
In-process, no server required	❌	❌	❌	✅
pip install → full engine	❌	SDK only	Framework only	✅

---

Where the ceiling actually is

Purple8 ships 15+ core graph algorithms (PageRank, temporal/dynamic PageRank, Louvain community detection, Dijkstra shortest path, betweenness centrality, 6-method link prediction, triangle counting, Tarjan biconnected components, bridge detection, Hopcroft-Karp bipartite matching, Kruskal MST, spatial Moran's I) plus specialized domain verticals for AEC/BIM (12 modules), SOC threat detection (9 modules), Quantum QUBO/Ising optimisation, and Multi-objective Evolutionary Optimisation. It has a full Cypher engine, horizontal sharding (ShardedGraphEngine), federated Supergraph queries, and Raft consensus replication.

Dimension	Purple8 Hyper Graph (v0.72.0)	Neo4j	TigerGraph
Node/edge scale	Tens to hundreds of millions (8.84M docs in ~9 GB peak RSS on 24 GB laptop)	Billions+	Billions+
Deep traversal (depth 10+)	Good	Excellent (native graph format)	Excellent
Graph algorithm library	15+ core + AEC/Quantum/Evolution	65+ (GDS)	50+
Bulk iterative analytics (GSQL-style)	No	Partial (GDS)	Yes
In-process, no server	✅	❌	❌
Vector search native	✅ (0.33 ms P99 @ 100K)	Plugin	❌
RAG pipeline built in	✅	❌	❌
AI workflow + audit trail	✅	❌	❌
pip install	✅	❌	❌

The honest framing: if your workload is purely petabyte-scale batch graph analytics — 50 billion nodes, depth-15 traversals, no AI, no vectors, no workflows — Neo4j or TigerGraph are purpose-built for that specific task.

But if you are building an AI system that also needs a graph — or a graph system that also needs AI — Purple8 is the only platform that does not require you to deploy, sync, secure, and pay for 8–12 separate services.

---

Licensing & Ecosystem Partnerships

Purple8 Hyper Graph uses a transparent 2-tier self-hosted licensing model:

1. Developer (Self-Hosted Free — $0): Up to 50K nodes and 1 MCP agent, with the full GraphEngine (BrickCoreStorage, BrickWAL, CortexAutoConfig, HNSW, Cypher, Journey Engine, RAG Studio) for local development, prototyping, and evaluation (ghcr.io/purple8-technologies/purple8-graph:developer).
2. Enterprise / Custom (Self-Hosted): The single commercial self-hosted tier — unlimited nodes & MCP agents, SSO/OIDC/SAML, 4-tier RBAC, immutable audit trail, managed KMS (Vault · AWS · GCP · Azure), Raft HA & failover, horizontal sharding, Supergraph federation, SOC vertical, Red Hat UBI9 / OpenShift certified container (Dockerfile.rhel), and SLA-backed support.

Purple8, Inc. is a member of the NVIDIA Inception program and a Red Hat Technology Partner.

---

Next steps

• Quickstart (pip) — running in 5 minutes
• Docker Quickstart — one docker run
• Hybrid Search guide — the core query pattern
• RAG Studio guide — configure your RAG pipeline in a guided UI
• Journey Engine guide — tracking real-world workflows in the graph
• Graph as Memory — how AI decisions accumulate into knowledge
• MCP Integration — expose everything to Claude or Cursor