WarpGBM MCP Service

WarpGBM MCP Service lets AI agents train GPU-accelerated gradient boosting models, cache fast predictions, and download portable artifacts. It provides a stateless cloud backend plus local hosting options, making it easy to experiment with GPU-backed models and scale to production.

How to use

You connect an MCP client to the WarpGBM MCP service to train models on NVIDIA GPUs, obtain a reusable artifact_id, and then make ultra-fast predictions through cached endpoints. Start by selecting the HTTP MCP endpoint for the service, or run a local or deployed instance and point your MCP client at its URL. Use the artifact_id you receive after training to perform rapid, cached predictions; you can also download a portable model artifact and run the model wherever you prefer.

How to install

Prerequisites: you need Python and a runtime environment to run the MCP service locally, plus access to a GPU if you plan to train on GPU. You should also have a terminal with network access to pull dependencies and start the server.

# Local development prerequisites
# 1) Clone the project repository (the MCP service wrapper repository)
git clone https://github.com/jefferythewind/mcp-warpgbm.git
cd mcp-warpgbm

# 2) Create and activate a virtual environment
python3 -m venv .venv
source .venv/bin/activate

# 3) Install dependencies
pip install -r requirements.txt

# 4) Run the local development server (GPU optional for development)
uvicorn local_dev:app --host 0.0.0.0 --port 8000 --reload

# 5) Verify the service is running
curl http://localhost:8000/healthz

Additional setup and notes

If you want a production-style deployment, you can deploy the service via Modal or other GPU-capable hosting platforms. The Modal deployment uses Modal tooling to publish the service and expose a live URL. You can also run the container locally with GPU support if you need a self-contained environment.

Endpoints and MCP integration overview

Core endpoints let you list models, train, get artifacts, and perform fast predictions via artifact-based caching. You also have a health check and endpoints for feedback. For MCP integration, there is a Server-Sent Events endpoint and a capability manifest they expose for agent orchestration.

Example pattern: training and fast inference

1. Train a model on the service and receive an artifact_id. 2) Use the artifact_id to perform fast, cached predictions (<100 ms) for future inferences. 3) If needed, download the portable artifact (joblib) and run the model locally or in another environment.

Iris dataset practical walkthrough

Train WarpGBM on a small Iris-like dataset to obtain an artifact_id, then perform fast predictions using that artifact_id. The training response includes artifact_id and model_artifact_joblib, enabling quick deployment in downstream applications.

Available tools

train

Train a model on the WarpGBM backend and receive an artifact_id and a portable model artifact for later use.

predict_from_artifact

Make fast predictions using a cached artifact_id with sub-100 ms latency for supported X inputs.

predict_proba_from_artifact

Obtain probability predictions for classification tasks using a cached artifact_id.

upload_data

Upload training data in supported formats for model training.

healthz

Health check endpoint to verify service status and GPU availability.

mcp_sse

MCP Server-Sent Events endpoint for agent communication.

x402

Pricing and payment manifest for MCP usage.