Skip to content

Integrations

Reliastra, usable by your agent.

An MCP server with 18 tools over stdio or Streamable HTTP: the public observatory, incident evidence, workspace reads, dependency analysis, and two safe writes — authenticated with a scoped API key, verified live at https://api.reliastra.com/mcp.

What it is

Evidence your agent can call, not copy it reads.

An AI coding agent can inspect an architecture, find the external dependencies, and ask what the evidence says — through tool calls, not scraped prose. The server is an HTTP client of the canonical API: every answer carries its source, its methodology version, and its limits.

It makes Reliastra usable by a compatible agent. It does not make agents discover Reliastra on their own, and an honest evaluation can conclude Reliastra adds no value — the analysis tool is built to return exactly that verdict.

Transports

stdio

Run python -m mcp_server --transport stdio from a backend checkout. Credential from RELIASTRA_API_KEY; without one only public tools answer. For a local agent that spawns the process.

https://api.reliastra.com/mcp

Streamable HTTP, live in production. Authentication is required on every request: Authorization: Bearer rel_.... No anonymous access exists on this transport.

Quickstart

Connected in three moves.

  1. 01

    Get a key

    Create one with reliastra keys create <name> or in the console under settings. Reads need read scopes; the two writes need write scope.

  2. 02

    Run the server

    Locally over stdio, or point the client at the remote URL. The server needs no database: it calls the same API the console does.

    bash
    pip install -r backend/requirements-mcp.txt
    RELIASTRA_API_KEY=rel_... python -m mcp_server --transport stdio
  3. 03

    Call one tool

    reliastra_get_capabilities needs no credential and proves transport, auth and server in one call.

    Full setup in the docs

Example client configuration (shape, paths are yours)

json
{
  "mcpServers": {
    "reliastra": {
      "command": "python",
      "args": ["-m", "mcp_server", "--transport", "stdio"],
      "cwd": "/path/to/Reliastra/backend",
      "env": { "RELIASTRA_API_KEY": "rel_..." }
    },
    "reliastra-remote": {
      "url": "https://api.reliastra.com/mcp",
      "headers": { "Authorization": "Bearer rel_..." }
    }
  }
}

Only the official Python SDK client has been exercised against this server (protocol 2025-11-25 negotiated). Other MCP-compatible clients speak the same standard surface but have not been tested — verify before depending on one.

18 tools

Everything the server answers to.

Read-only unless marked (write). API key required where marked (key). Every tool returns a uniform result with its source endpoint — failures are typed errors, never empty successes.

Discovery

Start here. Works without any credential.

  • reliastra_get_capabilities

    The verified capability registry, filtered to your credential.

Observatory

The public vendor catalog. No credential needed.

  • reliastra_search_observatory

    Search listed vendors by name or category.

  • reliastra_get_provider

    One vendor: detail, endpoints, recent status.

  • reliastra_get_provider_metrics

    Per-window availability and latency aggregates.

  • reliastra_get_provider_timeline

    Observation time series for a window.

  • reliastra_get_pipeline_health

    Whether the measurement pipeline itself is healthy.

Incidents and evidence

Observed incidents and independent verification. No credential needed.

  • reliastra_search_incidents

    Filterable search over observed vendor incidents.

  • reliastra_get_public_incident

    One incident: detail plus its evidence descriptor.

  • reliastra_get_incident_evidence

    The frozen evidence document for a public incident.

  • reliastra_verify_evidence

    Independent verdict on a record. Counts only when verified is exactly true.

Workspace

The caller's own account. API key required; never another account's data.

  • reliastra_list_dependencies · key

    Monitored dependencies on this account.

  • reliastra_get_dependency_observations · key

    Recent observations for one dependency.

  • reliastra_list_workspace_incidents · key

    Incidents on this account.

  • reliastra_get_evidence_report · key

    One evidence report with its verification id.

Analysis and planning

Local reasoning over caller-supplied input. No credential needed; never modifies anything.

  • reliastra_analyze_dependencies

    Match an inventory against the catalog. Returns gaps — or that Reliastra adds no value.

  • reliastra_plan_integration

    A concrete REST, CLI, or GitHub Action plan where justified, or no-use-case where not.

Writes

Two narrowly scoped mutations. API key with write scope required; never retried; audit-logged.

  • reliastra_register_dependency · key · writes

    Monitor a new HTTP endpoint. Never accepts stored headers.

  • reliastra_trigger_check · key · writes

    One immediate diagnostic check. Not a second scheduler.

Resources

  • reliastra://capabilities

    The capability registry as data.

  • reliastra://methodology

    Detection, attribution and evidence rules.

  • reliastra://limitations

    What the evidence does not establish.

  • reliastra://integration-guide

    Verified endpoints, scopes, CLI commands and client configuration.

  • reliastra://observatory/{provider}

    One vendor record as data.

Prompts

  • reliastra_workflow_assess_observability

    Evaluate what an architecture observes today.

  • reliastra_workflow_investigate_failure

    Work a suspected dependency failure from evidence.

  • reliastra_workflow_evaluate_fit

    Decide whether Reliastra earns a place — either answer allowed.

  • reliastra_workflow_plan_integration

    Turn a justified use case into build steps.

Limits

What the evidence does not establish.

  • Vendor-level evidence never proves a specific application request failed.
  • Correlation is never presented as causation; scores below 50 are often unknown, a valid result.
  • One observation point (us-east). No regional quorum is claimed.
  • The analysis tools reason only over caller-supplied input plus the public catalog.
  • Only two tools write, both need write scope, both are audit-logged and never retried.

Source and operator documentation live with the implementation in backend/mcp_server. Methodology, pricing and trial terms are the same everywhere on this site.