# Purple8 — AI-Native Application Backend (remote · purple8-graph-sandbox.fly.dev)

Complete backend for AI-built apps: data, auth, workflows, SLAs, HITL & RAG in 176 MCP tools.

- Trust score: 60/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- remote · `purple8-graph-sandbox.fly.dev`: 60/100 (this document), [markdown](https://verifymcp.io/servers/ai-purple8-www-purple8-hyper-graph/purple8-graph-sandbox.md), [page](https://verifymcp.io/servers/ai-purple8-www-purple8-hyper-graph/purple8-graph-sandbox)
- remote · `purple8-graph-sandbox.fly.dev`: 66/100, [markdown](https://verifymcp.io/servers/ai-purple8-www-purple8-hyper-graph/purple8-graph-sandbox-2.md), [page](https://verifymcp.io/servers/ai-purple8-www-purple8-hyper-graph/purple8-graph-sandbox-2)

## Channel facts

- Endpoint: `https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter`
- Transports: `sse`
- Auth: `none`
- Version: `0.72.1`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 28 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 40/100
  - Verified sse transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 58/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 7297 tokens (~260/item across 28 items; 28 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 47/100
  - Stability observed for 14 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 93/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 80% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "graph.query" implies "execute" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 29 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Purple8 — AI-Native Application Backend MCP server?

Purple8 — AI-Native Application Backend is a hosted endpoint at https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http ai-purple8-www-purple8-hyper-graph 'https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter'
```

### Cursor

```json
{
  "mcpServers": {
    "ai-purple8-www-purple8-hyper-graph": {
      "url": "https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ai-purple8-www-purple8-hyper-graph": {
      "type": "http",
      "url": "https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter"
    }
  }
}
```

### Codex

```toml
[mcp_servers.ai-purple8-www-purple8-hyper-graph]
url = "https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ai-purple8-www-purple8-hyper-graph": {
      "type": "remote",
      "url": "https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ai-purple8-www-purple8-hyper-graph --url 'https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  ai-purple8-www-purple8-hyper-graph:
    url: "https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter"
```

### Netclaw

```json
{
  "McpServers": {
    "ai-purple8-www-purple8-hyper-graph": {
      "Transport": "http",
      "Url": "https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter"
    }
  }
}
```

### Vellum

```bash
assistant mcp add ai-purple8-www-purple8-hyper-graph -t streamable-http -u 'https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter'
```

### Other

```json
{
  "mcpServers": {
    "ai-purple8-www-purple8-hyper-graph": {
      "type": "http",
      "url": "https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 60, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-20 (score 59, 0)

- [functional] Server version: 0.72.0 → 0.72.2

### 2026-11-19 (score 59, +1)

No change was recorded against any check on this day. Stability & Change Management went from 37 to 40. That category is still filling its 30-day observation window: 11 days of observed history at the previous scan, 12 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-17 (score 58, +31)

- [security improvement] Injection markers: unverified → pass
- [security] Authorization: Authorisation not fully verified: no authorisation is required to call this server, and 28 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
- [functional improvement] Endpoint reachability: not serving MCP → reachable
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Stability: unverified → 0.33
- [functional improvement] MCP protocol: unverified → pass
- [functional] Server version: 1.30.0 → 0.72.0

### 2026-11-15 (score 27, −29)

- [security regression] Endpoint reachability: reachable → not serving MCP
- [security regression] Tool safety: pass → unverified
- [security regression] Stability: 0.23 → unverified
- [security] Authorization: Authorisation not fully verified: no authorisation is required to connect, but we couldn't read the whole tool list to see what that exposes.
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified

### 2026-11-13 (score 56, +25)

- [security improvement] Injection markers: unverified → pass
- [security] Authorization: Authorisation not fully verified: no authorisation is required to call this server, and 28 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
- [functional improvement] Stability: unverified → 0.20
- [functional improvement] Tool coverage: unverified → 100

### 2026-11-12 (score 31, 0)

- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

### 2026-11-11 (score 31, −24)

- [security regression] Stability: 0.10 → unverified
- [security regression] Tool safety: pass → unverified
- [security] Authorization: Authorisation not fully verified: no authorisation is required to connect, but we couldn't read the whole tool list to see what that exposes.
- [functional regression] Tool coverage: 100 → unverified
- [functional] Schema quality: Schema not yet verified: we couldn't read the endpoint's schema, or could read only part of its tool list.
- [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day

## MCP tools (28)

### `rag.query` (~106 tokens)

Flat Vector RAG — retrieves the most relevant graph nodes by pure vector similarity (HNSW + RRF fusion + keyword fallback), then calls the configured LLM to generate a grounded answer.  Fastest of the three RAG modes (p50 ~45 ms, MRR 0.64); best for single-hop factual questions.  Use rag.graph_query or rag.hybrid_query for multi-hop or relationship-heavy questions.

Input parameters:

- `question` (string, required): The question to answer.

### `rag.hybrid_query` (~403 tokens)

Hybrid Graph-Vector RAG — fuses vector similarity AND graph structural signals at every stage: dual-seed fusion (Weighted RRF over vector rank + degree centrality), vector-guided BFS, and semantic path scoring.  Highest accuracy: MRR 0.85, multi-hop 0.91.  ~5x slower (p50 ~240 ms).  Recommended as the default RAG tool for agents that need high quality.

Input parameters:

- `collection_profile` (string): Name of a saved CollectionProfile (from rag.tune_collection save_as).  Fills in mode/fusion_alpha/max_hops/seed_k as defaults — explicit params always win.
- `fusion_alpha` (number): Explicit graph weight (0.0=pure vector, 1.0=pure graph).  Overrides mode.
- `label_filter` (array): Restrict retrieval to nodes with these labels.
- `max_hops` (integer): BFS expansion depth (1-5).  Default 2.
- `max_nodes` (integer): Maximum subgraph nodes in context (5-200).  Default 50.
- `max_tokens` (integer): LLM output token budget.  Default 1024.
- `mode` (string): Fusion mode.  'balanced' for most questions; 'graph_first' for dense-relationship queries; 'vector_first' for semantic similarity.
- `question` (string, required): The question to answer.
- `seed_k` (integer): Seed nodes per signal (1-20).  Default 5.
- `semantic_path_scoring` (boolean): Rank paths by keyword overlap + edge-type bonuses.  Default true.
- `temperature` (number): LLM sampling temperature.  Default 0.0.
- `vector_expansion` (boolean): Filter BFS neighbours by cosine similarity.  Default true.
- `write_inferred` (boolean): Persist LLM-inferred edges back to the graph.  Default false.

### `rag.profile_collection` (~140 tokens)

Analyse the graph topology and return recommended RAG retrieval settings.  Profiles node count, edge density, degree distribution, edge-type distribution, and embedding coverage, then derives concrete values for fusion_alpha, max_hops, seed_k, vector_weight, k, and mode.  Call this before tuning rag.hybrid_query on a new corpus or collection.  Returns topology_class (sparse/moderate/dense), a 'recommended' param block ready to pass to rag.hybrid_query, and a 'rationale' explaining each choice.

Input parameters:

- `label_filter` (array): Restrict analysis to nodes with these labels.  Omit for whole graph.

### `graph.query` (~61 tokens)

Execute a Cypher query against the Purple8 knowledge graph and return matching records.  Use for nodes, edges, paths, or aggregated data.

Input parameters:

- `cypher` (string, required): The Cypher query to execute.
- `parameters` (object): Optional named parameters.

### `graph.vector_search` (~73 tokens)

Find the k nearest nodes to a natural-language query using the HNSW vector index.

Input parameters:

- `k` (integer): Number of results to return.  Default 5.
- `label` (string): Restrict search to nodes with this label.
- `query_text` (string, required): The search query in natural language.

### `graph.hybrid_search` (~75 tokens)

Combine vector similarity with graph traversal for highest-recall retrieval.  Best when graph structure matters.

Input parameters:

- `k` (integer): Number of results to return.  Default 10.
- `label` (string): Restrict search to nodes with this label.
- `query_text` (string, required): The search query in natural language.

### `graph.traverse` (~88 tokens)

Walk the graph from a starting node following edges up to a given depth.

Input parameters:

- `depth` (integer): Maximum traversal depth.  Default 2.
- `direction` (string): Edge direction.  Default 'both'.
- `edge_type` (string): Restrict to edges of this type.  Omit for all types.
- `node_id` (string, required): ID of the starting node.

### `graph.add_node` (~122 tokens)

Insert a new node into the graph (accepts `type`, `label`, or `node_type`).  Requires editor role.

Input parameters:

- `label` (string): Alias for `type` (e.g. 'Document', 'Borrower').
- `labels` (array): Optional additional labels.
- `node_id` (string, required): Unique identifier for the node.
- `node_type` (string): Alias for `type`.
- `properties` (object): Key-value properties.
- `type` (string): Node label / type (e.g. 'Person', 'Company').

### `graph.add_edge` (~226 tokens)

Create a directed edge (relationship) between two existing nodes.  This is the primary agentic handoff mechanism — agents write their output as edges (e.g. DERIVED_FROM, RISK_ASSESSMENT, EXTRACTED_FROM) so downstream agents can discover work by querying graph state rather than passing messages.  edge_id is auto-generated (UUID4) when omitted.  Requires editor role.

Input parameters:

- `edge_id` (string): Unique identifier for the edge.  Auto-generated UUID4 when omitted.
- `edge_type` (string, required): Relationship type label (e.g. 'DERIVED_FROM', 'RISK_ASSESSMENT', 'EXTRACTED_FROM').
- `properties` (object): Key-value edge properties (e.g. {"confidence": 0.9, "assessor": "legal"}).
- `source_id` (string, required): ID of the source (tail) node.
- `target_id` (string, required): ID of the target (head) node.
- `weight` (number): Edge weight for traversal algorithms.  Default 1.0.

### `graph.update_node` (~140 tokens)

Update properties or labels on an existing node.  Properties are merged with existing values (patch semantics — only the keys you supply are changed).  Labels replace the full label set when provided.  Use this to advance agent relay state, e.g. setting {"status": "enriched", "handoff_to": null} to hand off work to the next agent in a relay pipeline.  Requires editor role.

Input parameters:

- `labels` (array): Replacement label set (replaces all existing labels when provided).
- `node_id` (string, required): ID of the node to update.
- `properties` (object): Properties to merge into the node (patch semantics).

### `graph.get_node` (~34 tokens)

Retrieve a node and all its stored properties by ID.

Input parameters:

- `node_id` (string, required): ID of the node to retrieve.

### `data.ingest_text` (~249 tokens)

Extract entities and relationships from raw text and write them into the graph. Calls preview first, then commits the complete extraction on success. auto_commit=false returns a review-only preview. Pending jobs return job_id for resumption. Original bytes are not stored automatically; supply file_ref or use data.commit with file_bytes_b64 if needed. After an interrupted write, ask the user to confirm a retry; use data.commit with the retained reviewed payload instead of re-extracting. Requires editor role.

Input parameters:

- `auto_commit` (boolean): false returns the complete preview without graph writes. Review then use data.commit.
- `file_ref` (string): Optional existing Graph file_id in this tenant, used as the original/document anchor at commit.
- `job_id` (string): Resume an earlier extraction instead of submitting again; repeat the original input arguments.
- `profile_hint` (string): Extraction profile; omit for auto-detection.
- `source_name` (string, required): Label for the source document (provenance).
- `text` (string, required): The raw text to extract knowledge from.
- `wait_seconds` (integer): Maximum wait for an admitted extraction. Pending jobs are NOT committed; resume with job_id.

### `data.commit` (~718 tokens)

Commit a reviewed extraction or your own extractor's output without invoking DocIntel. Uses the complete POST /ingest/commit contract: entities, relationships, Markdown, spans, tables/pages, context, file_ref or inline file_bytes_b64 and ingestion options. Existing entities are linked, not edited, unless update_entities=true. For extractor-generated IDs use identity_policy='review_conflicts': name matches alone are not identity proof. On entity_identity_conflict nothing was written; correct/exclude the incoming entity and update relationship endpoints, or explicitly confirm identity_resolution='link_existing', then retry. link_existing never edits existing facts. After interruption or a lost response, ask the user to confirm retrying the retained reviewed payload. Reuse entity IDs, assertion keys and file_ref; do not automatically re-extract. Retain metadata.sha256 (original bytes) and optional metadata.file_version. On source_version_conflict nothing was written: obtain and review current-source extraction and ask for confirmation, rather than replaying or relabeling the old review. SIMILAR_TO edges (enabled by default) are similarity, not factual assertions. Inspect embedding, document_chunks, structured_content and original_file outcomes; a successful write alone does not guarantee retrieval readiness. Requires editor role.

Input parameters:

- `build_similarity_edges` (boolean): Build SIMILAR_TO edges to cross-batch neighbours via vector search. On by default — turns every commit into a native hybrid ingest.
- `chunking_hint`
- `context`
- `doc_type`
- `entities` (array, required)
- `file_bytes_b64`
- `file_id`: Content-hash / File node ID for a file-backed commit. When provided, the orchestrator creates File → HAS_CHUNK → Chunk edges.
- `file_ref`
- `identity_policy` (string): review_conflicts rejects conflicting names/types/identifiers and cross-document name-only matches before writes. Supply matching stable identifiers, same-source provenance, or explicit link_existing…
- `links` (array)
- `markdown` (string)
- `markdown_sections` (array)
- `metadata` (object): Preserve extraction metadata. For a stored File, sha256 binds the review to original bytes (not Markdown); optional file_version pins its positive integer version. A changed/missing bound source retu…
- `pages` (array)
- `raw_text`: Full document text used to extract per-chunk text from section_boundaries. Pass the complete text for accurate MENTIONED_IN linkage.
- `relationships` (array, required)
- `section_boundaries` (array)
- `session_id`
- `similarity_k` (integer): Number of nearest neighbours to consider per node.
- `similarity_threshold` (number): Minimum cosine similarity for SIMILAR_TO edge creation.
- `source_name`
- `suggested_embedding_model`
- `tables` (array)
- `update_entities` (boolean): Merge this document's values into entities that already exist. Off by default: existing entities are linked, not modified. Requires edit access to every existing entity (403 otherwise; nothing is wri…
- `upsert` (boolean): Idempotent re-projection mode (default on): never create __vN twins, and derive deterministic edge ids so re-commits converge instead of duplicating.

### `journey.start` (~76 tokens)

Create a new Journey Engine instance for an entity and move it to the first stage.  All transitions are recorded as immutable graph edges.  Requires editor role.

Input parameters:

- `entity_id` (string, required): ID of the entity node the journey is for.
- `journey_type` (string, required): Journey type to instantiate (e.g. 'sales-cycle').

### `journey.advance` (~78 tokens)

Advance a journey instance to the next stage.  Actor and notes are written to the audit trail as an ADVANCED_TO edge.  Requires editor role.

Input parameters:

- `instance_id` (string, required): ID of the journey instance.
- `notes` (string): Optional notes for the audit trail.
- `to_stage` (string, required): Stage name to advance to.

### `journey.status` (~45 tokens)

Return the full state and audit trail for a journey instance — every stage transition, AI recommendation, and HITL decision.

Input parameters:

- `instance_id` (string, required): ID of the journey instance.

### `journey.define` (~231 tokens)

Define a new journey type (workflow template) with ordered stages, owner systems, and per-stage SLA policies.  Once defined, instances can be started with journey.start.  Call this first when building any new workflow — the agent can define the entire process in one call.  Use overwrite=true to update an existing definition. Requires journey:admin permission (admin or super_admin by default). Use operation=configure_ai with ai_enabled to persistently enable/disable this tenant's advisor. Generation uses tenant LLM settings; delivery is currently best-effort.

Input parameters:

- `ai_enabled` (boolean): Required for configure_ai. Explicit opt-in to automatic LLM calls for this tenant.
- `description` (string): Human-readable description of what this journey tracks.
- `journey_type` (string): Unique snake_case name for this workflow (e.g. 'loan_application', 'supplier_approval').
- `operation` (string)
- `overwrite` (boolean): Replace an existing definition with the same journey_type.  Default false.
- `stages` (array): Ordered list of stages.  First stage is the initial state.

### `journey.list` (~168 tokens)

List journey instances with optional filters.  Use this to discover what is in flight, find instances for a specific entity, or check all instances of a given type.  Also returns all defined journey types when called with no arguments.  Essential for any agent monitoring or orchestrating workflows. Set runtime_status=true to inspect this tenant's advisor enablement, provider readiness and delivery guarantees.

Input parameters:

- `entity_id` (string): Filter by the entity the journey is tracking.
- `journey_type` (string): Filter by journey type (e.g. 'loan_application').
- `list_types` (boolean): Return defined journey type names instead of instances.  Default false.
- `runtime_status` (boolean): Return tenant Journey AI configuration/readiness instead of instances.
- `status` (string): Filter by instance status.

### `journey.list_hitl` (~146 tokens)

List pending Human-In-The-Loop (HITL) tasks — decisions that require a human (or agent acting as human proxy) to approve, reject, or escalate before the journey can continue.  Returns task ID, title, assigned role, description, and the stage the journey is waiting on.  An agent can use this to surface pending decisions to the user or take autonomous action if authorised.

Input parameters:

- `assigned_role` (string): Filter by role (e.g. 'compliance_officer').
- `instance_id` (string): Restrict to HITL tasks for a specific journey instance.
- `status` (string): Filter by task status.  Default: pending.

### `journey.resolve_hitl` (~227 tokens)

Resolve a Human-In-The-Loop (HITL) task — approve, reject, or escalate it.  On approval the journey automatically advances to the next stage if advance_to_stage is set.  The decision is written to the immutable graph audit trail with the actor and timestamp.  An AI agent acting as a human proxy must set actor to the user or role it is acting on behalf of.  Requires editor role.

Input parameters:

- `action` (string, required): Resolution action.
- `actor` (string, required): User or system making the decision (written to audit trail).
- `advance_to_stage` (string): Stage to advance the journey to on completion.  Omit to leave stage unchanged.
- `decision` (string): Decision label for complete actions (e.g. 'approved', 'denied').  Default 'approved'.
- `new_assigned_role` (string): New role to escalate to (required when action=escalate).
- `notes` (string): Notes written to the audit trail.
- `task_id` (string, required): ID of the HITL task to resolve.

### `data.ingest_file` (~317 tokens)

Send a document file (PDF, DOCX, PPTX, XLSX, HTML, IFC, CSV, …) to Purple8 DocIntel for parsing, entity extraction, and graph ingestion.  The document is fetched by DocIntel from a public URL, not a local path. The complete extraction is committed only when finished successfully. auto_commit=false returns a review-only preview; pending jobs return job_id for resumption. URL extraction does not retain original bytes in Graph; supply file_ref or commit an original separately. Use this when the knowledge source is a document rather than raw text.  Requires editor role and DocIntel to be running. After an interrupted write, ask the user to confirm a retry; use data.commit with the retained reviewed payload instead of re-extracting.

Input parameters:

- `auto_commit` (boolean): false returns the complete preview without graph writes. Review then use data.commit.
- `file_ref` (string): Optional existing Graph file_id in this tenant, used as the original/document anchor at commit.
- `job_id` (string): Resume an earlier extraction instead of submitting again; repeat the original input arguments.
- `profile_hint` (string): Extraction profile; omit for auto-detection.
- `source_name` (string, required): Label for provenance tracking (e.g. 'loan_policy_v3.pdf').
- `url` (string, required): Publicly accessible URL of the document to fetch and process.
- `wait_seconds` (integer): Maximum wait for an admitted extraction. Pending jobs are NOT committed; resume with job_id.

### `graph.assert_statement` (~64 tokens)

Idempotently assert one native RDF quad with exact lexical terms, explicit blank-node scope and optional graph name. Uses existing node/edge create and read permissions, record policies and API-key label restrictions. No bulk import or caller-supplied metadata.

Input parameters:

- `statement` (required)

### `graph.semantic_query` (~149 tokens)

Read-only indexed RDF/LPG pattern query with policy-filtered evidence. Use tagged rdf, lpg and lpg_edge patterns. Returns unified bindings and evidence or, with output_format=nquads, a JSON envelope containing selected asserted N-Quads and selection metadata. Raw work stats are withheld (stats=null). No inferred RDF, writes, import, or whole-corpus export. Existing read permissions apply; N-Quads additionally requires data:export.

Input parameters:

- `bindings`
- `limit` (integer)
- `limits`
- `max_output_bytes` (integer)
- `node_bindings`
- `output_format` (string)
- `patterns` (array, required)

### `graph.counts` (~63 tokens)

Return the total number of nodes in the graph, optionally filtered by label.  A cheap situational-awareness call an agent can make before deciding how to query or ingest.

Input parameters:

- `label` (string): Count only nodes with this label.  Omit for all nodes.

### `graph.labels` (~65 tokens)

List every node type (label) in the graph with how many nodes carry it, largest first.  Cheap — O(types), not O(nodes).  Call this first to learn what the graph contains (e.g. Person, Account, Invoice) before querying or filtering by label.

### `schema.validate` (~66 tokens)

Validate the tenant's live graph data against the defined schema.  Reports missing required properties, type/enum violations, edge source/target-type violations, and orphan labels (labels present in the graph but undefined in the schema).  Returns valid=true with empty violation lists when the graph conforms.

### `schema.define_node_type` (~311 tokens)

Define a new node type — the primitive that lets an agent build the data model itself.  The type_name becomes the canonical label for nodes of this type.  Set app_id to make the type a per-app IAM boundary (only matching API keys may touch its nodes).  Declare properties with per-field type / required / enum constraints, and immutable_properties that cannot change after creation.  Fails 409 if the type already exists (use schema.update_node_type to change).

Input parameters:

- `allowed_edge_types` (array): Outgoing edge types this node type may participate in.  Omit for unrestricted.
- `app_id` (string): Owning application ID — makes this type an app-level IAM boundary.  Omit for tenant-wide types.
- `data_classification` (string): public | internal | restricted | highly_restricted.  Default internal.
- `description` (string): Human-readable description of the type.
- `immutable_properties` (array): Properties that cannot be modified after node creation.
- `properties` (object): Map of property name → definition.  Each definition may set: type (string|str|integer|int|float|number|boolean|bool|datetime|list|array|dict|object), required (bool), description, enum (list of allow…
- `required_labels` (array): Additional labels every node of this type must carry.
- `type_name` (string, required): Canonical node label (1–100 chars).

### `schema.define_edge_type` (~256 tokens)

Define a new edge (relationship) type.  Constrain which node types may be the source/target, declare edge properties, and set cardinality (one_to_one | one_to_many | many_to_one | many_to_many).  Fails 409 if the type already exists.

Input parameters:

- `app_id` (string)
- `cardinality` (string): one_to_one | one_to_many | many_to_one | many_to_many.  Default many_to_many.
- `data_classification` (string): public | internal | restricted | highly_restricted.  Default internal.
- `description` (string)
- `properties` (object): Map of property name → definition.  Each definition may set: type (string|str|integer|int|float|number|boolean|bool|datetime|list|array|dict|object), required (bool), description, enum (list of allow…
- `source_node_types` (array): Allowed source node types.  Omit for any.
- `target_node_types` (array): Allowed target node types.  Omit for any.
- `type_name` (string, required): Canonical edge type name (1–100 chars).

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ai-purple8-www-purple8-hyper-graph/purple8-graph-sandbox#diagnostics

## Score history

- 2026-11-21: 60
- 2026-11-20: 59
- 2026-11-19: 59
- 2026-11-18: 58
- 2026-11-17: 58
- 2026-11-16: 27
- 2026-11-15: 27
- 2026-11-14: 56
- 2026-11-13: 56
- 2026-11-12: 31
- 2026-11-11: 31
- 2026-11-10: 55
- 2026-11-09: 54
- 2026-11-08: 54
- 2026-11-07: 53
- 2026-11-06: 33

## Common questions

### What is the Purple8 — AI-Native Application Backend MCP server?

Purple8 — AI-Native Application Backend is an MCP server listed in the public MCP registry as ai.purple8.www/purple8-hyper-graph. Complete backend for AI-built apps: data, auth, workflows, SLAs, HITL & RAG in 176 MCP tools. This page covers its hosted endpoint (https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter).

### Is the Purple8 — AI-Native Application Backend MCP server safe to use?

Purple8 — AI-Native Application Backend scores 60 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Purple8 — AI-Native Application Backend MCP server expose?

Purple8 — AI-Native Application Backend exposes 28 tools: rag.query, rag.hybrid_query, rag.profile_collection, graph.query, graph.vector_search, and 23 more. Their descriptions and schemas cost roughly 4,697 tokens of context every time the server is loaded.

### Does the Purple8 — AI-Native Application Backend MCP server require authentication?

No. We connected to Purple8 — AI-Native Application Backend without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Purple8 — AI-Native Application Backend MCP server still maintained?

Purple8 — AI-Native Application Backend is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What did VerifyMCP test on the Purple8 — AI-Native Application Backend MCP server?

VerifyMCP ran 12 checks on Purple8 — AI-Native Application Backend, covering TLS certificate, HTTPS, HSTS header, DNSSEC and 8 more. One item could not be completed, a gap on our side rather than a finding about Purple8 — AI-Native Application Backend: Authorization. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://purple8-graph-sandbox.fly.dev/mcp/sse?profile=starter
- Authorisation metadata: https://purple8-graph-sandbox.fly.dev/.well-known/oauth-protected-resource/mcp/sse
- Website: https://www.purple8.ai/products/hyper-graph/
- Changelog RSS feed: https://verifymcp.io/servers/ai-purple8-www-purple8-hyper-graph/purple8-graph-sandbox.xml
- Changelog JSON feed: https://verifymcp.io/servers/ai-purple8-www-purple8-hyper-graph/purple8-graph-sandbox/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/ai-purple8-www-purple8-hyper-graph/purple8-graph-sandbox.json
- HTML version of this page: https://verifymcp.io/servers/ai-purple8-www-purple8-hyper-graph/purple8-graph-sandbox
