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 with Cypher

Nodes, edges, labels, properties — standard property graph model. A custom Cypher implementation with 161 passing test cases covering MATCH, WHERE, WITH, UNWIND, MERGE, CREATE, DELETE, aggregations, path patterns, and subqueries.

Backed by a durable, disk-backed write-ahead log. ACID transactions. No JVM. No separate server. pip install and you have the full engine in-process.

2. HNSW + DiskANN vector search, built into the query planner

Not a sidecar. Not a separate index you query separately and join in application code. The vector index lives in the same storage layer 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. 3.5 ms median at 100k documents.

In-memory HNSW for speed. On-disk DiskANN for datasets that don't fit in RAM (pip install "purple8-hyper-graph[diskann]"). BM25 full-text included for hybrid retrieval.

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

v0.27.0+

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 (v0.27.2):

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	6	fixed, recursive, semantic, sentence_window, parent_child, markdown_header
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 — structured extraction from unstructured docs

Feed a PDF, URL, or raw text. Purple8's DocIntel pipeline extracts entities and relationships using vision-capable LLMs, then writes them directly into the graph. OCR-to-graph in one API call.

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 secured by the same JWT 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). Events are persisted for replay. No Kafka required for most workloads.

9. Envelope encryption with 5 KMS providers

Fields marked sensitive are encrypted at rest with AES-256-GCM. Key wrapping is handled by any of: local key file, HashiCorp Vault, AWS KMS, GCP Cloud KMS, or Azure Key Vault — configurable at startup, no code changes.

10. REST + GraphQL + MCP — all included

A FastAPI server (purple8-hyper-graph serve) exposes the full engine over REST. A Strawberry GraphQL layer is available via pip install "purple8-hyper-graph[graphql]". A first-party MCP server (``) exposes all 31 tools to Claude, Cursor, 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	✅
6 chunking strategies with guided UI	❌	❌	Manual	✅
Workflow / journey tracking	❌	❌	❌	✅
SLA enforcement	❌	❌	❌	✅
AI decision audit trail	❌	❌	❌	✅
Human-in-the-loop	❌	❌	❌	✅
Document Intelligence (PDF/URL → graph)	❌	❌	❌	✅
Real-time CDC / event streaming	Plugin	❌	❌	✅
Envelope encryption (5 KMS providers)	Enterprise add-on	❌	❌	✅
MCP server for AI agents	❌	❌	❌	✅
In-process, no server required	❌	❌	❌	✅
pip install → full engine	❌	SDK only	Framework only	✅

---

Where the ceiling actually is

Purple8 ships PageRank, Louvain community detection, Dijkstra shortest path, and betweenness centrality. It has a full Cypher engine, horizontal sharding (ShardedGraphEngine), federated queries across shards, and Raft replication. It can do fraud detection. It can do recommendation graphs. It can do supply-chain tracing at moderate scale.

Dimension	Purple8	Neo4j	TigerGraph
Node/edge scale	Hundreds of millions	Billions+	Billions+
Deep traversal (depth 10+)	Good	Excellent (native graph format)	Excellent
Graph algorithm library	4 built-in	65+ (GDS)	50+
Bulk iterative analytics (GSQL-style)	No	Partial (GDS)	Yes
In-process, no server	✅	❌	❌
Vector search native	✅	Plugin	❌
RAG pipeline built in	✅	❌	❌
AI workflow + audit trail	✅	❌	❌
pip install	✅	❌	❌

The honest framing: if your workload is purely large-scale graph analytics — 50 billion nodes, depth-15 traversals, 50 graph algorithms, no AI, no vectors, no workflows — Neo4j or TigerGraph will outperform Purple8 at that specific thing.

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 option that does not require you to run, sync, and pay for three separate services.

---

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