Kiln

<!-- mcp-name: io.github.codeofaxel/kiln -->
<p align="center">
  <img src="docs/assets/kiln-banner-1280x640.svg" alt="Kiln" width="640">
</p>

<p align="center">
  <a href="https://pypi.org/project/kiln3d/"><img src="https://img.shields.io/pypi/v/kiln3d" alt="PyPI"></a>
  <a href="https://pypi.org/project/kiln3d/"><img src="https://img.shields.io/pypi/pyversions/kiln3d" alt="Python"></a>
  <a href="https://github.com/codeofaxel/Kiln/blob/main/LICENSE"><img src="https://img.shields.io/github/license/codeofaxel/Kiln" alt="License"></a>
  <a href="https://github.com/codeofaxel/Kiln/blob/main/SIGNING.md"><img src="https://img.shields.io/badge/verified%20by-sigstore%20%2B%20SLSA-0f6fdc?logo=sigstore&logoColor=white" alt="Verified by Sigstore + SLSA"></a>
</p>

---

**Kiln is an open-source MCP server that lets AI agents (Claude Desktop, Claude Code, Codex, or any custom MCP client) drive real 3D printers end to end — Bambu Lab, Creality, Prusa, Elegoo, Voron, Sovol, AnkerMake, Artillery, FlashForge, QIDI, RatRig, and SparkX, over OctoPrint, Moonraker/Klipper, PrusaLink, and Direct USB.**

In a single conversation, an agent can design a part, slice it, queue it on the right printer, monitor the camera, recover from failures, and ship the result. No human in the middle.

```bash
pip install kiln3d
```

<p align="center">
  <img src="docs/assets/kiln-demo-loop.svg" alt="A Kiln agent session: the user asks for a coaster with their dog's photo; Kiln designs it, checks it will print, slices, and prints it on a Bambu A1 — done in 41 minutes." width="640">
</p>

<p align="center">
  <img src="docs/site/public/demo/ash-coaster.jpg" alt="A 3D-printed coaster with a relief portrait of a French bulldog and the name ASH along the bottom edge, held in a hand" width="640">
</p>

<p align="center">
  <em>"a coaster with a photo of my dog Ash" — start to finish, from one sentence.</em><br>
  <a href="https://kiln3d.com#demo">Watch the demo →</a>
</p>

<p align="center">
  <sub>Kiln's built in the open. If it made your printing more fun, or just saved you a headache, a ⭐ on the repo helps the next maker find it.</sub>
</p>

## Quick Start

Three steps. Then ask your AI to make something.

**1. Install**

```bash
pip install kiln3d
```

**2. Connect your AI** — Kiln sets itself up inside Claude Desktop, Claude Code, and Codex:

```bash
kiln signin        # create your free account
kiln install-mcp   # connects Kiln to your AI apps
```

Restart your AI app and it can run your printer. (Claude Code and Codex can even run this whole setup for you — the one-prompt version lives at [kiln3d.com/install](https://kiln3d.com/install).) Using a different MCP client? `kiln install-mcp --print` prints the config — or paste it yourself:

<details>
<summary><strong>Manual MCP config (any client, no sign-in needed)</strong></summary>

```json
{
  "mcpServers": {
    "kiln": {
      "command": "python3",
      "args": ["-m", "kiln", "serve"]
    }
  }
}
```

Drop this into Claude Desktop, Claude Code, Codex, Cursor, or any MCP-capable agent. Runs on the free tier until you sign in.
</details>

**3. Ask** — paste a sentence like this into your agent. Kiln does the rest:

> I have a Bambu A1, make me a coaster with my dog's photo on it

That's the whole happy path. Your AI does the designing, slicing, and printing — you never touch a CLI. OS-specific walkthrough (Windows, WSL 2, Linux) at **[kiln3d.com/install](https://kiln3d.com/install)**.

> [!TIP]
> `kiln doctor` checks your whole setup and tells you exactly what to fix. `kiln self-update` upgrades in place when a new release lands.

<details>
<summary><strong>Prefer to drive it yourself? (CLI tour)</strong></summary>

```bash
# Discover printers on your network (mDNS + HTTP probe)
kiln discover

# Add your printer (see the printer table under "Supported Printers")
kiln auth --name my-printer --host http://octopi.local --type octoprint --api-key YOUR_KEY
# Other types:
# kiln auth --name prusa  --host http://192.168.1.100      --type prusalink --api-key YOUR_KEY
# kiln auth --name klipper --host http://192.168.1.100:7125 --type moonraker
# kiln auth --name bambu  --host 192.168.1.100             --type bambu --access-code LAN_CODE --serial SERIAL

kiln status                       # Printer state + job progress
kiln upload model.gcode           # Upload a file
kiln print model.gcode            # Start printing
kiln slice model.stl --print-after  # Slice an STL and print in one step
kiln print *.gcode --queue        # Batch print
kiln wait                         # Monitor a running print
kiln snapshot --save photo.jpg    # Webcam snapshot
kiln history --status completed   # Print history

# Every command supports --json for agent consumption
kiln status --json
```

Global option: `--printer <name>` targets a specific printer per command. The full command reference is in [Project Docs](docs/PROJECT_DOCS.md).
</details>

<details>
<summary><strong>Connect a specific agent (Claude Code, Claude Desktop, env vars)</strong></summary>

**Claude Code** — add to `.claude/settings.json` (project) or `~/.claude/settings.json` (global):

```json
{
  "mcpServers": {
    "kiln": { "command": "kiln", "args": ["serve"] }
  }
}
```

Claude Code uses your `~/.kiln/config.yaml` for printer credentials (set via `kiln setup` or `kiln auth`). No env vars needed if a printer is already configured.

**Claude Desktop** — add to `~/.config/Claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "kiln": {
      "command": "python3",
      "args": ["-m", "kiln", "serve"],
      "env": {
        "KILN_PRINTER_HOST": "http://192.168.1.100",
        "KILN_PRINTER_API_KEY": "your_key",
        "KILN_PRINTER_TYPE": "prusalink"
      }
    }
  }
}
```

Set `KILN_PRINTER_TYPE` to your backend: `octoprint`, `moonraker`, `bambu`, `prusalink`, `elegoo`, or `serial` — or skip env vars entirely if you've run `kiln setup`.

**Any other LLM (OpenRouter)** — Kiln works with any model that supports OpenAI-compatible function calling, not just Claude:

```bash
export KILN_OPENROUTER_KEY=sk-or-...
kiln agent --model openai/gpt-4o
kiln agent --model meta-llama/llama-3.1-70b-instruct --tier essential
```

Tool tiers auto-match model capability: **essential** (16 tools) for smaller models, **standard** (61 tools) for mid-range, **full** (133 tools) for stronger models. All <!-- KILN_MCP_TOOL_COUNT:OLD --> 828 tools are available over MCP via `kiln serve`.
</details>

<details>
<summary><strong>Platform &amp; printer setup notes (Linux/WSL 2, Ethernet-only, Bambu)</strong></summary>

### Prerequisites by printer type

| Printer | `--type` | What you need |
|---------|----------|---------------|
| **Prusa MK4/XL/Mini+** | `prusalink` | IP + API key (Settings › Network › PrusaLink on the LCD) |
| **OctoPrint** (any printer) | `octoprint` | OctoPrint URL + API key (Settings › API) |
| **Klipper/Moonraker** | `moonraker` | Moonraker URL (usually `http://<ip>:7125`) |
| **Creality K1/K2/Hi/Ender V4/V3 KE** | `creality` | IP + `printer_model` (e.g. `creality_k1_max`); probes local Moonraker ports |
| **Bambu Lab** | `bambu` | IP + LAN access code + serial number (all on the LCD) |
| **Elegoo** (SDCP) | `elegoo` | IP only — no auth. Neptune 4 / OrangeStorm Giga use `moonraker`. |
| **Direct USB** (Marlin) | `serial` | USB cable only — no network. Ender 3, Prusa MK3, CR-10, any Marlin/RepRap printer. |

Kiln only needs IP reachability on your LAN. Ethernet-only printers are fully supported.

**Optional tools:** [PrusaSlicer](https://www.prusa3d.com/prusaslicer/) or OrcaSlicer for slicing STL → G-code (`brew install --cask prusaslicer`); [OpenSCAD](https://openscad.org/) for local text-to-3D generation (`brew install openscad`); set `KILN_GEMINI_API_KEY` to enable Gemini-generated geometry.

### Linux / WSL 2

`pipx` installs Kiln into its own isolated environment and puts `kiln` on your PATH. (The pip package is `kiln3d`; the CLI command is `kiln`.)

```bash
sudo apt install pipx && pipx ensurepath
git clone https://github.com/codeofaxel/Kiln.git && cd Kiln
pipx install ./kiln
sudo apt install prusa-slicer openscad   # optional: slicing + generation
kiln verify

# Update / uninstall
git pull && pipx install --force ./kiln
pipx uninstall kiln3d
```

**WSL 2 networking:** WSL 2 uses NAT, so mDNS discovery (`kiln discover`) won't see printers on your home network. Connect directly by IP instead (same as Ethernet-only setups).

### Ethernet-only printers (no Wi-Fi)

Kiln works the same over Ethernet and Wi-Fi — it talks to printer APIs over LAN IP. Verify the printer endpoint responds, then register by IP:

```bash
curl http://<ip>/api/version                              # OctoPrint
curl http://<ip>:7125/server/info                         # Moonraker / Creality (local Moonraker)
curl -H "X-Api-Key: YOUR_KEY" http://<ip>/api/v1/status   # Prusa Link
# Bambu uses MQTT — ensure port 8883 is reachable:  nc -zv <ip> 8883

kiln auth --name my-printer --host http://<ip> --type prusalink --api-key YOUR_KEY
```

If PrusaSlicer isn't on your PATH: `export KILN_SLICER_PATH=/path/to/prusa-slicer`.

### Bambu TLS &amp; webcam

Kiln pins the printer certificate (TOFU) on first connection in `~/.kiln/bambu_tls_pins.json`. Overrides:

```bash
export KILN_BAMBU_TLS_MODE=ca         # strict CA/hostname (usually fails on stock self-signed printers)
export KILN_BAMBU_TLS_MODE=insecure   # legacy, no validation — trusted LANs only
export KILN_BAMBU_TLS_FINGERPRINT=0123abcd...   # explicit SHA-256 pin
```

Webcam capture is model-dependent: **A1, A1 Mini, P1P, P1S** serve frames over TLS+JPEG (no extra software). The **X1 series** (X1C, X1E) serves RTSPS, which Kiln relays via `ffmpeg` — so on an X1, both snapshots *and* the live stream need `ffmpeg` (`brew install ffmpeg` / `sudo apt install ffmpeg`). `can_snapshot` is reported `True` for every Bambu model; on an X1 without `ffmpeg`, the attempt surfaces a clear model-specific error rather than failing silently.