Getting started

TuiML is machine learning that agents can actually call. Install it, connect your AI agent, and run real ML workflows in plain language.

Installation

One-line install (recommended)

Installs uv and TuiML globally, then offers the optional integrations.

$ curl -fsSL https://tuiml.ai/install.sh | bash

Installs the latest PyPI release as a prebuilt wheel — no compiler needed. To build the newest unreleased code from GitHub main instead, set TUIML_CHANNEL=git (that one needs git and a C++ compiler — if git is missing the installer offers to install it, via Homebrew or the Xcode tools on macOS, your package manager on Linux, and winget/scoop/choco on Windows):

curl -fsSL https://tuiml.ai/install.sh | TUIML_CHANNEL=git bash

The installer asks which extras you want, and detects your GPU — CUDA, ROCm or Apple Metal — before offering the PyTorch-backed models. On a machine without one it still offers them, just not by default, since they run on CPU only slowly. Answer everything up front to skip the questions:

# Non-interactive: pick the extras yourself
curl -fsSL https://tuiml.ai/install.sh | TUIML_EXTRAS="sklearn,torch" bash

# Core only, no extras
curl -fsSL https://tuiml.ai/install.sh | TUIML_EXTRAS="none" bash

# Neural models and the TabICL foundation model
curl -fsSL https://tuiml.ai/install.sh | TUIML_EXTRAS="torch,foundation" bash

# Skip GPU probing; also picks the PyTorch build
curl -fsSL https://tuiml.ai/install.sh | TUIML_GPU=cpu bash

Run this in PowerShell (Windows PowerShell 5.1 or PowerShell 7). No admin rights needed — everything installs per-user.

> irm https://tuiml.ai/install.ps1 | iex

Installs the prebuilt 64-bit Windows wheel from PyPI — no compiler needed. Because iex cannot take arguments, the options are environment variables:

# Newest unreleased code from GitHub main.
# Needs git and the Visual Studio C++ build tools.
$env:TUIML_CHANNEL = "git"; irm https://tuiml.ai/install.ps1 | iex

# Non-interactive: skip the prompts
$env:TUIML_EXTRAS = "sklearn,capymoa,weka,torch"; irm https://tuiml.ai/install.ps1 | iex

If your policy blocks remote scripts, run it in a bypassed child shell instead: powershell -ExecutionPolicy Bypass -c "irm https://tuiml.ai/install.ps1 | iex". WSL also works — use the macOS/Linux command inside it.

Via pip / uv

If you already have a Python environment.

# Using pip
pip install tuiml

# Using uv
uv add tuiml

Everything beyond the core install is an extra. The core is pure Python and C++ — over 200 algorithms, including every tree, linear, clustering, anomaly, survival, uplift, conformal and classical forecasting model — and needs none of the below.

# scikit-learn estimators
pip install 'tuiml[sklearn]'

# CapyMOA streaming learners (needs Java 11+)
pip install 'tuiml[capymoa]'

# Weka learners via python-weka-wrapper3 (needs Java 11+)
pip install 'tuiml[weka]'

# All three wrapper backends at once
pip install 'tuiml[backends]'

# Neural models: FT-Transformer, SAINT, NODE,
# N-BEATS, N-HiTS, PatchTST. Pulls in PyTorch.
pip install 'tuiml[torch]'

# TabICL, a pretrained foundation model that
# predicts without training
pip install 'tuiml[foundation]'

# Everything. On Linux, pin CPU wheels unless you
# want several GB of NVIDIA CUDA libraries:
uv pip install --torch-backend=cpu 'tuiml[all]'

XGBoost, LightGBM and CatBoost are in the default install — nothing extra to type. They are ~111 MB of plain CPU wheels and they are what most people reach for first on tabular data. tuiml[boosting] still resolves, so an existing Dockerfile or CI line carrying it keeps working.

PyTorch is the one thing deliberately left out, and only because of what it drags behind it. PyPI serves the CUDA build by default, so on Linux pip install torch pulls roughly twenty NVIDIA runtime packages — several gigabytes — even on a machine with no NVIDIA GPU. That is a steep toll for 11 of TuiML’s 245 algorithms, every one of which has a no-dependency alternative already in the library. Install it when you want those 11, and pin the CPU wheels if you have no GPU.

Wrappers around another library register under a namespaced hub key — sklearn.SVC, capymoa.HoeffdingTree, weka.J48, foundation.TabICLClassifier — so they can never collide with a native name. The boosting and neural models keep bare names (XGBoostClassifier, NBEATSForecaster), because TuiML has no native algorithm called either.

An extra is only needed to fit. Importing TuiML never imports PyTorch or a boosting library, so list_algorithms() returns the same catalog on every install and you can read any model's parameters before deciding to install anything. tuiml[foundation] downloads a ~150 MB checkpoint on first use, into ~/.cache/huggingface; TuiML itself ships no model weights.

From source (development)

git clone https://github.com/tuiml/tuiml.git
cd tuiml
uv sync          # Install dependencies
uv run pytest    # Run tests

AI agent setup

Connect TuiML to your favourite AI tool. Two pieces do the work:

[+]SKILL.md: a knowledge file that teaches your agent TuiML's API, patterns, base classes, and conventions.

[+]MCP server: a local server exposing 200+ ML tools (train, evaluate, preprocess, serve) your agent calls directly.

Step 1: Run the setup command

$ tuiml setup

Detects and wires up 21 clients, safely and with backups: Claude Desktop, Claude Code, OpenAI Codex (one config covering the ChatGPT Desktop app, the Codex CLI and the IDE extension), Antigravity and its agy CLI, Perplexity, Cursor, Windsurf, Zed, VS Code, Continue, Goose, Cline, Roo, Kilo, OpenCode, Gemini CLI, OpenClaw and NemoClaw. Run tuiml setup --list to preview the changes, tuiml setup --client claude-desktop for one specific client, or --yes for a non-interactive run.

Step 2: Ask your agent to run something

No further wiring needed, the tools are already registered:

Train a classifier on the iris dataset, report accuracy, and save the model.

Your agent picks the algorithm, trains it, and reports back using TuiML tools.

Step 3: Optional, install the skill file by hand

Setup registers the MCP server for every client, and installs the skill file wherever the client has a skills directory (Claude Code, OpenClaw). Editors that read project rules instead want the file copied in by hand:

# Cursor
cp path/to/tuiml/tuiml/agent/prompts/SKILL.md .cursor/rules/tuiml.md

# Windsurf
cp path/to/tuiml/tuiml/agent/prompts/SKILL.md .windsurf/rules/tuiml.md

# GitHub Copilot
cp path/to/tuiml/tuiml/agent/prompts/SKILL.md .github/copilot-instructions.md

# Cline
cp path/to/tuiml/tuiml/agent/prompts/SKILL.md .clinerules

Optional: the tools work without it; the agent just has less context on how to use them well.

The featured CLI agent partner. Routes any agent inside OpenClaw to all 200+ TuiML tools.

Step 1: Register the MCP server

$ tuiml setup --client openclaw

Registers TuiML with OpenClaw's MCP registry. The native OpenClaw command does the same thing:

openclaw mcp set tuiml '{"command":"tuiml-mcp"}' && openclaw gateway restart

Either command is enough, you do not need both.

Step 2: Or edit the config by hand

If you prefer, add this block to ~/.openclaw/openclaw.json:

{
  "mcp": {
    "servers": {
      "tuiml": { "command": "tuiml-mcp" }
    }
  }
}

Step 3: Verify

openclaw mcp list    # should list tuiml
openclaw chat "train a random forest on iris and report accuracy using TuiML"

NVIDIA NemoClaw sandboxes are locked down by default, so PyPI has to be allowed before TuiML can be installed inside one.

Step 1: Allow PyPI on the host

nemoclaw <sandbox-name> policy-add pypi --yes
nemoclaw <sandbox-name> connect

The tuiml.ai/install.sh curl installer can be blocked by NemoClaw policy, so the built-in pypi preset is the simpler supported path.

Step 2: Install TuiML inside the sandbox

python -m venv /sandbox/.openclaw/workspace/tuiml_venv
. /sandbox/.openclaw/workspace/tuiml_venv/bin/activate
pip install tuiml

Step 3: Register it with OpenClaw

openclaw mcp set tuiml '{"command":"/sandbox/.openclaw/workspace/tuiml_venv/bin/tuiml-mcp"}'
openclaw gateway restart

Verify with openclaw mcp list, it should show tuiml.

Scientific citation

If you use TuiML in your research, please cite the framework using the following BibTeX record:

@software{tuiml2026,
  title={TuiML: Machine Learning that agents can actually call},
  author={Verma, Nilesh and Bifet, Albert and Pfahringer, Bernhard and Lim, Nick},
  year={2026},
  url={https://github.com/tuiml/tuiml}
}

License

TuiML is licensed under the BSD 3-Clause License.