Glossary
Terms used throughout the Purple8 Graph documentation, sorted alphabetically. P8G-specific branded names are marked [P8G].
A
Adapter
A protocol driver that SuperGraphExecutor uses to query a remote Purple8 peer. The default adapter is "p8g" (Purple8 REST API). Adapters are declared per-peer in PeerInfo.adapter and can be extended to support other graph engines.
AEC Algorithms [P8G]
Twelve domain-specific algorithm modules for the Architecture, Engineering & Construction vertical — Space Syntax / VGA, Structural Topology, BIM Graph (IFC), Generative Design, MEP Flow Analysis, Graph Grammars, Spectral Structural Optimisation, Topology Optimisation, MORL + GCN Agent, MPNN Physics Kernel, Hypergraph, and IFC Graph Rewriting. Loaded via from purple8_graph.aec import *.
ANN (Approximate Nearest Neighbour)
A vector search strategy that finds the k closest embedding vectors in sub-linear time by trading a small recall loss for a large speed gain. Purple8 uses HNSW for ANN. Contrast with exact (exhaustive) k-NN.
ApprovalConfig [P8G]
A dataclass (purple8_graph.supergraph.ApprovalConfig) that controls the SuperGraph approval workflow — require_approval, optional webhook_url, and timeout_secs. Passed to ApprovalManager at construction.
ApprovalManager [P8G]
The orchestrator for the SuperGraph peer-approval lifecycle. Issues tokens via request_approval(), records human decisions via receive_decision(), and fires webhook callbacks on approval or denial. Lives in purple8_graph.supergraph.
ApprovalRequest [P8G]
An immutable record of a pending or decided approval — fields: token, instance_id, requested_by, status, decided_by, decided_at. Created by ApprovalManager.request_approval().
AnomalySignal [P8G]
A dataclass (purple8_graph.soc.AnomalySignal) emitted by Layer 1 (rule engine) or Layer 2 (statistical baseline) when a metric breaches a threshold or z-score limit. Fields: signal_id, layer (DetectionLayer), rule_name, tenant_id, journey_id, observed_value, threshold, z_score, context, detected_at.
AuditRecord [P8G]
An immutable record of a containment action written by ContainmentManager.contain() or a human-release decision. Fields: record_id, event_id, action, level, threat_class, tenant_id, journey_id, actor, released_by, released_at, notes. The .is_released property is True once released_by is populated.
B
Binary Quantization
A vector compression technique that reduces each float32 dimension to a single bit. Reduces memory by ~32× with some recall loss. Enabled per vector slot via quantization: "binary" in the node schema.
BlastRadiusEstimator [P8G]
A component (purple8_graph.soc.BlastRadiusEstimator) that estimates the number of resources (tenants, journeys, peers) potentially affected by a ThreatEvent. Constructed with known_tenant_count, known_journey_count, and known_peer_count. Passed to SOCAgentConfig.blast_radius.
BM25
Best Match 25 — a probabilistic ranking function for full-text search that scores documents by term frequency and inverse document frequency with length normalisation. Purple8's FullTextEngine (and its Rust counterpart FullTextIndexCore) uses BM25 as the default retrieval function for GET /search/text.
C
ChunkingAgent [P8G]
An ingest-time classifier (purple8_graph.ChunkingAgent) that reads a document's text (and optional DocIntel metadata) and returns the optimal (chunking_strategy, embedding_model) pair. Activated via chunking_agent_enabled: true in PUT /rag/config. Introduced in v0.32.0.
ChunkingStrategyRegistry [P8G]
A dict-backed registry mapping doc_type strings to {"chunking_strategy": ..., "embedding_model": ...} records. Load the built-in defaults with default_chunking_registry(), customise, and persist with save_chunking_registry().
Circuit Breaker (Drain) [P8G]
A full state-machine circuit breaker (CLOSED → OPEN → HALF_OPEN) that wraps the Turbo Mode drain thread. If the drain thread accumulates too many consecutive failures, the breaker opens and stops accepting new writes until the engine recovers. Introduced in v0.30.0.
Clustering
Purple8's horizontal-scaling tier — multiple engine nodes coordinated by a distributed write coordinator. Each node handles a shard of the graph. See the Sharding & Clustering guide.
ContainmentAction [P8G]
An enum (purple8_graph.soc.ContainmentAction) of the 10 automated response actions: FLAG_JOURNEY, RATE_LIMIT_TENANT, SUSPEND_JOURNEY, REVOKE_API_KEY, ISOLATE_TENANT, QUARANTINE_DATA, NOTIFY_SECURITY_TEAM, ESCALATE_TO_CISO, BLOCK_CROSS_TENANT, EMERGENCY_SNAPSHOT.
ContainmentLevel [P8G]
An enum (purple8_graph.soc.ContainmentLevel) with four graduated severity tiers: SOFT (flag only), MEDIUM (rate-limit + alert), HARD (suspend; human release required), CRITICAL (isolate + snapshot; human release required). level.requires_human_release is True for HARD and CRITICAL.
ContainmentManager [P8G]
The component (purple8_graph.soc.ContainmentManager) that maps a ThreatEvent to a list of ContainmentAction values, applies them, and writes AuditRecord entries. Fires webhook and SIEM callbacks asynchronously without blocking the containment path. .release(event_id, released_by, notes) is the human-release gate.
Cypher / openCypher
A declarative graph query language. Purple8 implements ~80% of the openCypher specification — MATCH, CREATE, MERGE, SET, DELETE, UNWIND, variable-length paths, and more. See the Cypher Reference.
D
DiscoveryTier [P8G]
An enum (purple8_graph.supergraph.DiscoveryTier) describing how a peer was found:
STATIC(Tier 1) — manually declared; always enabledSERVICE_DISCOVERY(Tier 2) — auto-discovered via a registry; requires Tier 1GOSSIP(Tier 3) — peer-to-peer gossip protocol; requires Tiers 1 + 2FEDERATED_DNS(Tier 4) — DNS-based discovery; requires Tiers 1 + 2
DetectionLayer [P8G]
An enum (purple8_graph.soc.DetectionLayer) marking which detection layer produced an AnomalySignal: RULE (Layer 1 — threshold-based) or STATISTICAL (Layer 2 — EWMA z-score).
DocIntelChunkingHint [P8G]
A dataclass that carries doc_type, chunking_hint, suggested_embedding_model, and optional section_boundaries from the Purple8 DocIntel microservice into ChunkingAgent.classify(). When present, it bypasses heuristic re-classification entirely.
Document Store
One of the four storage engines unified in Purple8. Every node carries a schemaless properties dict that can hold arbitrary nested JSON — no separate document database required.
Drain Circuit Breaker
See Circuit Breaker (Drain).
E
Edge
A directed relationship between two nodes. Edges have a type label (e.g. WORKS_FOR), optional properties, and are stored in the RocksDB-backed adjacency index. Also called a relationship in Cypher terminology.
Envelope Encryption [P8G]
A two-layer encryption scheme: data is encrypted with a local AES-GCM data key; the data key itself is encrypted by a master key held in an external KMS (Local keyring, HashiCorp Vault, AWS KMS, GCP KMS, or Azure Key Vault). Enabled via PUT /admin/encryption.
F
Federation
See SuperGraph Federation.
FullTextEngine [P8G]
The built-in BM25 inverted-index subsystem that auto-indexes node properties on write. Exposes GET /search/text and participates in hybrid search alongside the vector index. Accelerated by the FullTextIndexCore Rust module in v0.28.0.
Fusion Strategy [P8G]
How multiple retrieval signal scores are combined in hybrid search. Purple8 supports two strategies selectable via fusion_strategy in PUT /rag/config:
"weighted_sum"— linear combination of normalised scores (default)"rrf"— Reciprocal Rank Fusion (rank-position–based, no weight tuning required)
G
Graph Traversal
Navigating a graph by following edges from node to node. Purple8 uses parent-pointer BFS with batch edge fetching for O(log N + k) adjacency reads.
H
HNSW (Hierarchical Navigable Small World)
The ANN index algorithm used by Purple8's vector subsystem. Maintains a multi-layer proximity graph; supports pre-filter ANN (apply attribute filters before vector search), optional int8 and binary quantization. The Rust VectorIndexCore module provides a pure-Rust HNSW implementation for Turbo Mode.
Hybrid Search
A retrieval mode that combines vector similarity (semantic), BM25 full-text, and/or graph-BFS signals into a single ranked result set. The combination strategy is controlled by fusion_strategy.
I
Instance ID
A unique string identifier for a Purple8 peer in the SuperGraph mesh — e.g. "legal-graph-us". Declared in PeerInfo.instance_id and used as the primary key throughout PeerRegistry, ApprovalManager, and SuperGraphStitcher.
Int8 Quantization
A vector compression technique that stores each float32 dimension as an 8-bit integer. Reduces memory by ~4× with minimal recall loss compared to binary quantization. Enabled per vector slot via quantization: "int8".
J
Journey [P8G]
A long-running business process modelled as a graph — nodes represent stages, edges represent transitions, and SLA deadlines are tracked per stage. Managed by the Journey Engine. See the Journey Engine guide.
JourneyAIAdvisor [P8G]
An LLM-backed component that can suggest next steps, generate summaries, or flag at-risk journeys based on current graph state. Configurable with any supported LLM provider.
Journey Engine [P8G]
The Purple8 subsystem for modelling, executing, and monitoring long-running business processes as graphs. Accelerated by the JourneyEngineCore Rust module (v0.28.0) for parallel SLA scanning. See the Journey Engine guide.
Journey ID
A str correlation token (e.g. "j-2026-001") threaded through every SuperGraph federated query so that cross-instance results, logs, and traces can be linked end-to-end.
JourneyAnomalyDetector [P8G]
The Layer 2 statistical baseline component (purple8_graph.soc.JourneyAnomalyDetector). Maintains a per-(tenant_id, metric_name) EWMA of mean and variance. Fires AnomalySignal entries when the z-score of an observed value exceeds DetectorConfig.z_score_threshold (default 3.5) after the warm-up period (warmup_samples, default 30).
JourneyAnomalyRuleEngine [P8G]
The Layer 1 rule-based detection component (purple8_graph.soc.JourneyAnomalyRuleEngine). Evaluates 11 stateless threshold rules against a raw metrics dict on every process() call. Returns a list of AnomalySignal entries. Thresholds are configured via RuleConfig.
K
KMS (Key Management Service)
An external system that holds master encryption keys. Purple8 supports five KMS backends: Local keyring (dev), HashiCorp Vault, AWS KMS, GCP KMS, Azure Key Vault. See the Encryption & KMS guide.
L
Label
A string tag applied to a node (e.g. "Person", "Contract") or edge (e.g. "WORKS_FOR"). Labels are indexed and used as the primary filter in Cypher MATCH patterns and RAG routing rules.
Late Chunking [P8G]
An embedding strategy where the entire document is encoded with a long-context model (e.g. voyage-4-large, 32 K context window), and chunk vectors are derived by pooling token embeddings — preserving cross-sentence semantic signal that fixed-window chunking loses. Activated via chunking_strategy: "late".
M
MCP (Model Context Protocol)
An open standard for exposing tools and resources to LLM agents. Purple8 ships a built-in MCP server that exposes the graph, vector search, RAG, and Journey Engine as MCP tools — agents can query and modify the graph without writing REST calls. See the MCP Integration guide.
Memory & Learning [P8G]
Purple8's long-term agent memory layer — stores interaction history, learned preferences, and derived facts as graph nodes and edges so that AI agents can recall past context across sessions.
Multi-tenancy
Logical isolation of multiple tenants inside a single Purple8 instance via namespace-partitioned keyspaces. Each tenant's nodes, edges, and vectors are stored separately. See the Multi-tenancy guide.
N
Node
The fundamental unit of storage in Purple8. Every node has a unique id, one or more labels, a schemaless properties dict, and optionally one or more named embedding vectors.
P
PeerInfo [P8G]
A dataclass (purple8_graph.supergraph.PeerInfo) that describes a SuperGraph peer — instance_id, address, adapter, optional domains list, and optional metadata dict.
PeerRegistry [P8G]
The SuperGraph directory of declared peers. Holds PeerInfo records, tracks PeerStatus (PENDING / APPROVED / DENIED / UNREACHABLE), and manages DiscoveryTier prerequisites. Lives in purple8_graph.supergraph.
PeerResult [P8G]
The result of a single peer query executed by SuperGraphExecutor — instance_id, address, adapter, success (bool), data (list), error (str | None), latency_ms (float).
PeerStatus [P8G]
An enum tracking a peer's lifecycle in PeerRegistry:
PENDING— declared but not yet approvedAPPROVED— human sign-off received; eligible to be queriedDENIED— approval denied; will not be queriedUNREACHABLE— was approved but did not respond during the last execution
Property Graph
A graph model where nodes and edges can each carry arbitrary key–value properties. Purple8 extends the property graph with native vector slots and document-store semantics — every node is simultaneously a graph vertex, a document, and a vector.
R
RAG (Retrieval-Augmented Generation)
A technique where an LLM's response is grounded by retrieved context — in Purple8's case, context retrieved via hybrid graph + vector + BM25 search. The full pipeline is exposed via POST /rag/query.
RAG Studio [P8G]
Purple8's built-in RAG configuration and experimentation UI — browse 39 LLM models and 21 embedding models, tune chunking strategy, switch fusion mode, and test queries interactively. Accessible via GET /rag/studio.
RouterAgent [P8G]
A per-label RAG query dispatcher (MultiIndexRouter) that reads rag_routing.json and routes each query to the optimal retrieval strategy (vector, BM25, graph-BFS, or hybrid) based on node label and query confidence. Enabled via routing_enabled: true in PUT /rag/config. Introduced in v0.31.0. Also re-embeds queries with the label-matched embedding model before vector search.
RRF (Reciprocal Rank Fusion) [P8G]
A rank-based score fusion method. Instead of combining raw scores (which have incompatible scales across BM25, cosine, and graph-hop), RRF uses each result's position in each ranked list: $score = \sum_{r \in \text{rankers}} \frac{1}{k + \text{rank}_r}$. Select via fusion_strategy: "rrf". Introduced in v0.31.0.
Rust Core [P8G]
Six PyO3/Rayon Rust modules compiled via maturin that eliminate the Python GIL for CPU-bound hot paths. Operates in two modes — Standard Mode (always-on, transparent) and Turbo Mode (opt-in, in-memory). Introduced in v0.28.0.
S
Semantic Chunking
A chunking strategy that splits documents at sentence or paragraph boundaries using a sentence encoder to detect topic shifts. Produces variable-size chunks with higher semantic coherence than fixed-size splitting. Activated via chunking_strategy: "semantic".
SOCAgent [P8G]
The top-level entry point for the SOC module (purple8_graph.soc.SOCAgent). Orchestrates the full pipeline: Layer 1 rule engine → Layer 2 statistical baseline → ThreatClassifier → ContainmentManager. Exposes process(), release(), incident_report(), audit_log, active_containments(), and is_contained(). Introduced in v0.33.0.
Standard Mode [P8G]
The always-on Rust acceleration tier. Three Rust modules (FullTextIndexCore, JourneyEngineCore, DocumentStore) transparently accelerate the subsystems where Python loops are the GIL bottleneck. Requires no configuration — active from v0.28.0 onward.
SuperGraph [P8G]
See SuperGraph Federation.
SuperGraph Federation [P8G]
The enterprise-tier feature (v0.32.0) that lets multiple Purple8 instances federate into a single queryable mesh. Key properties: explicit peer declaration, mandatory human approval before any peer is queried, parallel execution across approved peers, and honest partial-result reporting via SuperGraphResult.disclaimer. See the SuperGraph Federation guide.
SuperGraphExecutor [P8G]
The component that fans out a Cypher query to all approved peers in PeerRegistry concurrently (thread-pool, configurable max_workers). Returns a List[PeerResult]. Lives in purple8_graph.supergraph.
SuperGraphExecutorConfig [P8G]
A dataclass controlling SuperGraphExecutor behaviour — timeout_secs (default 30), max_workers (default 20), and adapter_query_paths (per-adapter URL path map).
SuperGraphResult [P8G]
The stitched output of a federated query — journey_id, status ("complete" / "partial" / "empty"), records (merged data list), total_records, sources (list of instance_ids that returned data), failed_peers (list of instance_ids that failed), and disclaimer (non-empty string when any peer failed — never silent).
SuperGraphStitcher [P8G]
Merges a List[PeerResult] into a single SuperGraphResult. Optionally deduplicates records across peers. Sets status and populates disclaimer when any peer failed. Lives in purple8_graph.supergraph.
Syntactic Chunking
A chunking strategy that splits documents at fixed structural boundaries (sentences, paragraphs, or token windows) without semantic awareness. Fast and predictable. Activated via chunking_strategy: "syntactic".
T
Turbo Mode [P8G]
An opt-in, all-in-memory, GIL-free graph engine for burst workloads (migrations, batch ETL, one-time analytics). Three Rust modules — GraphEngineCore, VectorIndexCore, StorageEngine — replace the persistent storage layer. Data is flushed to Standard Mode via flush_to_persistent(). Not intended for long-running production services. Introduced in v0.28.0.
ThreatClass [P8G]
An enum (purple8_graph.soc.ThreatClass) with 11 values representing canonical threat categories: credential_stuffing, data_exfiltration, privilege_escalation, lateral_movement, insider_threat, rag_poisoning, graph_dos, tenant_boundary_violation, embedding_inversion, destructive_write, unknown. Used by ThreatClassifier and ContainmentManager.
ThreatClassifier [P8G]
A component (purple8_graph.soc.ThreatClassifier) that maps a list of AnomalySignal entries to a (ThreatClass, ContainmentLevel) pair using a prefix-match table keyed on signal.rule_name. Returns (UNKNOWN, SOFT) when no signal matches.
ThreatEvent [P8G]
An immutable dataclass (purple8_graph.soc.ThreatEvent) created by SOCAgent.process() when signals fire. Fields: event_id (UUID), threat_class, containment_level, blast_radius, signals, tenant_id, journey_id, peer_instance_ids, description, detected_at. Passed to ContainmentManager.contain() to trigger automated response.
U
Unified Data Store [P8G]
Purple8's core value proposition — one embedded engine that functions simultaneously as a graph database, vector database, document store, and full-text search engine. Eliminates the need for Postgres, Pinecone, Elasticsearch, and Neo4j as separate systems. See the Unified Data Store guide.
UnreachablePeer [P8G]
A custom exception raised by PeerRegistry.get_peer() when a peer's status has been set to UNREACHABLE — i.e. it was approved but did not respond during a previous execution cycle.
V
Vector Slot
A named embedding field on a node. Nodes can carry multiple independent vector slots (e.g. "title_embedding" and "body_embedding") with different dimensions, quantization settings, and HNSW index parameters.
VGA (Visibility Graph Analysis)
A Space Syntax method that computes which points in a floor plan are mutually visible — used in Purple8's AEC algorithms module for spatial analysis of architectural layouts.