Redix AnyToAny Server

A developer sandbox for the Redix AnyToAny healthcare data conversion engine, exposed to AI clients (Claude Desktop, Claude Code, Cursor, and any MCP-compatible agent) over the Model Context Protocol.

Point your AI client at this server and ask it, in plain language, to validate an X12 claim, turn an 837 into a FHIR R4 Bundle, render a CMS-1500 PDF, or map an HL7 v2 message - and watch the Redix engine do it, with validation gates that block bad conversions instead of silently passing them.

What this is (and is not)

This server is an interactive evaluation and debugging surface for the Redix conversion engine. It is the fastest way to see what the engine does to your data before you write a line of integration code.

It is not a production pipeline. Healthcare conversion at volume runs through the deterministic Redix REST API (the same engine this server wraps), under a Redix license. When you have seen enough here, that is where you go next:

• REST API and tools: https://demo.redix.com
• Production licensing: [email protected]

Tools (11)

Tool	Description	Validation gate
validate_x12	Validate HIPAA X12 against 5010 implementation-guide rules	is the gate
convert_x12_to_fhir	X12 -> FHIR R4 Bundle	Gate 1 (input)
convert_x12_to_rmap	X12 -> RMap v5 intermediate	Gate 1 (input)
convert_rmap_to_x12	RMap v5 -> X12	Gate 5 (output)
convert_x12_to_database	X12 -> relational DB tables	Gate 1 (input)
generate_x12_from_database	DB -> X12	Gate 5 (output)
convert_hl7_to_fhir	HL7 v2 -> FHIR R4	-
convert_cda_to_fhir	CDA / C-CDA -> FHIR R4	-
convert_fhir_to_rmap	FHIR -> RMap v5 (inspect the intermediate mapping)	-
generate_claim_pdf	X12 837 -> PDF (CMS-1500 / UB-04 / ADA J400)	Gate 1 (input)
list_supported_formats	Capability discovery (no key needed)	-

Reverse FHIR-to-X12 (278) is intentionally not exposed in this sandbox. External, provider-generated PAS bundles do not yet ingest cleanly end to end, so it is unfit for unattended use where a failure would look like an engine defect. It remains available through the REST API under a short private technical review - email [email protected].

Quick start - hosted (no install)

Point your MCP client at the hosted demo server. It runs with a sample-only demo key, so you can try every tool against Redix sample files immediately.

Streamable HTTP (recommended)

{
  "mcpServers": {
    "redix-anytoany": {
      "url": "https://demo.redix.com/mcp",
      "env": { "REDIX_API_KEY": "demo-key-12345" }
    }
  }
}

SSE

{
  "mcpServers": {
    "redix-anytoany": {
      "url": "https://demo.redix.com/sse",
      "env": { "REDIX_API_KEY": "demo-key-12345" }
    }
  }
}

Evaluating with your own data

The published demo-key-12345 is sample-only: it converts Redix sample files so you can see each tool work, but it will not process your own files. This protects healthcare data and keeps the demo a controlled technical evaluation.

When you send your own data, a tool returns a clear EVAL_KEY_REQUIRED response telling you exactly where to request a free, tool-scoped evaluation key - for example, the X12 validator points you to https://demo.redix.com/tools/validate. Submit the short "request an evaluation key" form on that page (or email [email protected]); Redix issues a scoped key by email, usually for a 7-day evaluation. Then set REDIX_API_KEY to that key and rerun.

Use test or de-identified data for evaluation. Do not upload production PHI to the demo server.

Setup - local (self-hosted)

pip install -r requirements.txt

Environment variables

Variable	Default	Description
REDIX_API_BASE	http://localhost:8080	Redix API base URL
REDIX_API_KEY	demo-key-12345	API authentication key
REQUEST_TIMEOUT	120	HTTP timeout in seconds
LOG_LEVEL	INFO	Python logging level

Running locally

# STDIO mode (Claude Desktop / Claude Code)
python3.11 server.py

# Streamable HTTP mode (multi-client)
fastmcp run server.py --transport streamable-http --port 8001

# SSE mode (multi-client)
fastmcp run server.py --transport sse --port 8000

# MCP Inspector (browser UI)
fastmcp dev server.py

Claude Code integration

Copy .mcp.json to your project root, or add to Claude Code settings:

{
  "mcpServers": {
    "redix-anytoany": {
      "command": "python3.11",
      "args": ["server.py"],
      "cwd": "/opt/MCP/redix-mcp-server",
      "env": {
        "REDIX_API_BASE": "http://localhost:8080",
        "REDIX_API_KEY": "demo-key-12345"
      }
    }
  }
}

Claude Desktop integration

Add to ~/.claude/claude_desktop_config.json:

{
  "mcpServers": {
    "redix-anytoany": {
      "command": "python3.11",
      "args": ["/opt/MCP/redix-mcp-server/server.py"],
      "env": {
        "REDIX_API_BASE": "http://localhost:8080",
        "REDIX_API_KEY": "demo-key-12345"
      }
    }
  }
}

How it works

Each tool is a thin wrapper over the Redix AnyToAny REST API. Conversions are bracketed by validation gates:

• Gate 1 (input) validates X12 against 5010 rules before converting. A malformed claim is refused, not silently mangled.
• Gate 5 (output) re-validates X12 that a tool generates, so you never get back EDI that would bounce at a payer.

Transaction types are auto-detected from content when you do not specify them.

Testing

python3.11 tests/test_tools.py

Requires the Redix API running at REDIX_API_BASE. Note: against the hosted demo (sample-only key, 3-second rate limit) many cases return EVAL_KEY_REQUIRED or rate-limit errors by design; run the suite against a local API with an evaluation key for full coverage.