MCP Server FAQ

The Redix MCP Server provides healthcare data conversion tools via the Model Context Protocol (MCP). MCP clients such as Claude Desktop, Claude Code, and Cursor can validate HIPAA X12, convert to FHIR R4, generate claim PDFs, and more — all within a single conversation. Compatibility is confirmed per client and version.

The MCP Server is a protocol adapter that wraps the same Redix REST API used by programmatic clients and exposes its endpoints as MCP tools. On applicable X12 paths it adds validation gates (see the validation gates question below).

• validate_x12: HIPAA X12 validation (syntax, inter-segment, and balancing)
• convert_x12_to_fhir: X12 to FHIR R4 bundles
• convert_x12_to_rmap: X12 to the RMap tabular format
• convert_rmap_to_x12: RMap to X12
• convert_x12_to_database: X12 to PostgreSQL
• generate_x12_from_database: PostgreSQL to X12
• convert_hl7_to_fhir: HL7 v2.x to FHIR R4
• convert_cda_to_fhir: CDA/C-CDA to FHIR R4
• convert_fhir_to_rmap: FHIR R4 to RMap
• generate_claim_pdf: CMS-1500, UB-04, ADA J400
• list_supported_formats: list supported formats

Before you start: install the server's dependencies (Python 3.11 or later; run pip install -r requirements.txt in the server directory) and note the absolute paths of your Python executable and of server.py.

In Claude Desktop, open Settings > Developer > Edit Config to open claude_desktop_config.json. The file is at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS and %APPDATA%\Claude\claude_desktop_config.json on Windows; on other platforms, use Edit Config to locate it. Add the server:

{
  "mcpServers": {
    "redix": {
      "command": "/absolute/path/to/python3.11",
      "args": ["/absolute/path/to/redix-mcp-server/server.py"],
      "env": {
        "REDIX_API_BASE": "https://demo.redix.com",
        "REDIX_API_KEY": "YOUR_EVALUATION_KEY"
      }
    }
  }
}

REDIX_API_BASE is the Redix API the server calls; if it is not set, the server uses http://localhost:8080. Use https://demo.redix.com only with synthetic data. Replace the placeholder with the evaluation key Redix issued you, scoped for the tools you are evaluating, and keep it private. With the public demo key, this client can list the tools, but guarded conversion and validation tools return an EVAL_KEY_REQUIRED response instead of a result.

Restart Claude Desktop. If the Redix tools do not appear, check the paths in the file and the client's MCP logs; your client may also ask you to approve the server before its tools run.

Use the same mcpServers entry shown for Claude Desktop, in the file each client reads:

• Claude Code: .mcp.json in your project root
• Cursor: .cursor/mcp.json in your project, or ~/.cursor/mcp.json for all projects

The REDIX_API_BASE and REDIX_API_KEY environment variables configure the connection. Point REDIX_API_BASE to your own Redix API server for on-premise use, or to https://demo.redix.com for the public sandbox with synthetic data only, and use an evaluation key scoped for the tools you are evaluating. Seeing the tools listed in your client is a different check from a conversion succeeding; restart or reload the client and check its MCP logs if the server does not start.

The MCP Inspector is a browser-based testing tool for MCP servers. A hosted Inspector page for the Redix MCP Server is at demo.redix.com:6275, with no local installation.

It is a testing aid for exploring the tools before integrating them into your AI workflow. Opening the page does not mean every tool will run: the Inspector may need connection details before it connects, and conversion and validation results depend on the key the connected server uses. Use synthetic data only.

• STDIO (local): the MCP server runs as a subprocess of your AI client (Claude Desktop, Claude Code, Cursor). Suited to on-premises deployments. STDIO covers only the link between your AI client and the MCP server; the server still calls the Redix API at the address you configure, and your AI client and model have their own data paths.
• SSE (remote): the legacy HTTP+SSE transport, at /sse over HTTPS, with no local installation. It is distinct from the newer Streamable HTTP transport, and client support varies by client and version. The public demo endpoint is https://demo.redix.com/sse, for synthetic data only.

On applicable X12 paths, the MCP Server brackets conversions with validation gates:

• Gate 1 (Input Validation) — validates X12 input before an X12 conversion; malformed X12 is refused rather than converted
• Gate 5 (Output Validation) — re-validates X12 that a tool generates (RMap to X12, database to X12) before returning it

The HL7, CDA, and FHIR to RMap tools do not go through these X12 gates. The gates are X12 checks, not FHIR profile validation or clinical review, and an APPROVED status from the MCP Server is not payer approval or conformance certification. Gate 2 (regulatory currency), Gate 3 (clinical plausibility), and Gate 4 (temporal consistency) are not implemented.

Yes. The MCP Server is a Python application that needs Python 3.11 or later and the packages in its requirements.txt; support on a given system also depends on those packages and on the platform of the Redix engine behind your API. For on-premise deployment:

• Install the server and its dependencies locally
• Point REDIX_API_BASE to your local Redix API instance
• Use STDIO transport between your AI client and the MCP server

STDIO alone does not keep data inside your infrastructure. That also requires the Redix API endpoint, your AI client and model processing, and logging to be configured and assessed for it. Use synthetic data only with the public demo.

No. The MCP server and REST API are fixed wrappers. On the configurable engine paths, the AnyToAny Engine underneath uses IFD (Input Format Definition) files for validation rules and OFD (a proprietary language similar to Python/VB) for conversion logic. Not every tool runs on that engine: CDA to FHIR, for example, uses separate open-source-based foundation components. Pre-defined maps cover the standard transactions; consultation services add payer- or workflow-specific requirements. What a tool converts is bounded by the map configured for it and by the evaluation scope.

The server includes an end-to-end test runner, tests/test_tools.py. Run it from the MCP server directory:

cd /path/to/redix-mcp-server
python3.11 tests/test_tools.py

It is not an isolated unit-test suite. It calls the real Redix API at REDIX_API_BASE (default http://localhost:8080), including database conversions, and some checks accept an error or blocked result. Run it against your own approved, isolated Redix API instance with an evaluation key scoped for the tools under test. Against the public demo, with its sample-only key and rate limits, many cases return EVAL_KEY_REQUIRED or rate-limit errors by design.