MCP Gateway¶

Arxyne dispatches all solvers through a single MCP Gateway (FastMCP, streamable HTTP) running on one port. The gateway routes each call to the right solver Docker container internally and streams progress back over MCP. Solvers are not MCP servers — they're pure Docker images launched per-call.

See the multi-solver stack guide for setup.

Overview¶


Process	`arxyne_platform/gateway.py` — one process, one port, one log
Default port	`8100` (`ARXYNE_GATEWAY_PORT`)
Endpoint	`http://127.0.0.1:8100/mcp/` (`ARXYNE_GATEWAY_URL`)
Start	`arxyne --start-solver gateway` · or `python -m arxyne_platform.gateway --port 8100`

# Defaults work out of the box; override only for remote GPU dispatch
export ARXYNE_GATEWAY_PORT=8100
export ARXYNE_GATEWAY_URL=http://127.0.0.1:8100/mcp/

# Verify
arxyne --solvers

Trailing /mcp/ is required

The gateway mounts its endpoint at /mcp/. A bare URL without the path will 404.

Registered Solvers¶

The solver registry is a dict in arxyne_platform/solver.py. Each entry maps a solver name to its Docker image; the gateway launches the container per-call. There are no per-solver ports or per-solver MCP servers.

Solver	Domain	Image	Notes
OpenFOAM	aero (CPU RANS CFD)	`arxynehq/solver-openfoam`	nprocs-parallel
XLB	aero (GPU LBM, JAX/Warp)	`arxynehq/solver-xlb`	needs `--gpus all`
Chrono	dynamics (multi-body)	`arxynehq/solver-chrono`	—
DoMINO	aero (neural-operator surrogate)	`nvcr.io/nim/nvidia/domino-automotive-aero`	NIM, NGC auth required, automotive-only

Gateway Tools¶

All tools take a solver argument so one gateway serves every solver. Metadata tools (get_bindings, get_kpi_spec, get_contracts, list_assessments) read the contracts the solver image bundles; simulate_* launches the container.

Tool	Description	Returns
`simulate_aero(product_name, solver, nprocs, iterations, case_dir, voxel_size_m, timesteps)`	Run an aero solver (`openfoam` \| `xlb` \| `domino`) via Docker; streams progress over MCP	S.9: `{cd, cl, cm_pitch, cells, converged, wall_time_s, ...}`
`simulate_dynamics(product_name, manoeuvre, params)`	Run Chrono multi-body dynamics via Docker	S.9: `{lateral_g, yaw_rate_dps, roll_angle_deg, speed_kmh}`
`get_bindings(solver)`	USD attr ↔ solver key mapping	Bindings dict
`get_kpi_spec(solver)`	KPI definitions + gates	KPI spec dict
`get_contracts(solver, assessment)`	Input/output/failure contracts for an assessment	`{input, output, failure}`
`list_assessments(solver)`	Assessments the solver advertises	`["aero/steady_state", ...]`

The result JSON is delimited with an @@ARXYNE_RESULT@@ sentinel so the gateway can isolate it from solver banner noise (Warp/CUDA device dumps, etc.).

Solver Inputs¶

Each solver declares what it needs in its bundled kpi_spec.yaml:

OpenFOAM — frontalArea, stl_name, half_model, turbulence_model
XLB — frontalArea, voxel resolution, freestream velocity
Chrono — vehicleMass, wheelbase, trackWidth, cgHeight

Geometry is bundled in the solver image (/solver/stl-files/), not shipped from the platform — the platform writes only case.yaml (BYOM, 2026-05-16).

Chrono manoeuvres:

Manoeuvre	Speed	Steer Angle	Duration
`step_steer`	80 km/h	2.0°	8 s
`lane_change`	80 km/h	4.0°	10 s
`steady_state_cornering`	60 km/h	3.0°	15 s
`cruise`	150 km/h	0.0°	10 s

Platform API (Not MCP)¶

The USD digital twin is accessed directly via the Python API or CLI — not through the gateway:

Python API: from arxyne_platform.api import Arxyne
CLI: arxyne --product X --aero ..., arxyne --list, arxyne --doctor, etc.

Contract Trilogy¶

Every solver follows the same contract pattern, served from its own image and fetched over the gateway at runtime:

M.7 (input): case.yaml + bundled geometry — what the solver needs
S.9 (output): JSON result dict — what the solver returns on success
S.7b (failure): typed error record with {status, class, gate_result, message, captures}

Failure classes: configuration, runtime, convergence, data.

Security¶

The gateway runs over HTTP. For local dev, no auth is needed. Production / multi-tenant deployments require RBAC + OAuth in front of the transport edge (planned). For remote GPU dispatch, point ARXYNE_GATEWAY_URL at the host running the gateway.