# Getting started
Your first session with the Jumperless V5 + MCP server + an AI tool.
**MCP** (Model Context Protocol — see [modelcontextprotocol.io](https://modelcontextprotocol.io)) is an open standard that lets AI tools like Claude talk to local programs. The `jumperless-mcp` server implements that standard so Claude can control your Jumperless directly.
## What you'll need
- A Jumperless V5 (and a USB cable that carries data, not just power)
- A computer running Linux, macOS, or Windows
- The **Rust toolchain** (we'll install this in a sec — it's just a one-line command)
- An MCP-aware AI tool. Both of Anthropic's first-party tools work:
- [Claude Code](https://claude.com/claude-code) — terminal CLI, fastest setup
- [Claude Desktop](https://claude.ai/download) — GUI app
- Or any third-party MCP-aware tool (Cursor, Continue, OpenCode, etc.)
You do **not** need to know Rust. The toolchain is just how we install the server. Once it's running, you talk to the V5 through your AI tool in plain English.
## Step 1: Install the Rust toolchain
If you've never used Rust before, head to [rustup.rs](https://rustup.rs) and follow the one-command install. On macOS or Linux it's:
```bash
On Windows, the page gives you a `.exe` to download.
After it finishes, restart your terminal and verify:
```bash
cargo --version
```
You should see something like `cargo 1.85.0`. Good. Cargo is Rust's package manager — like `pip` for Python or `npm` for JavaScript. We'll use it to install the MCP server.
## Step 2: Install jumperless-mcp
```bash
cargo install jumperless-mcp
```
This downloads the source, compiles it, and drops the binary into a folder on your PATH (the list of directories your terminal searches when you type a command). Takes a minute or two the first time — it's pulling and compiling all the dependencies. After that, `jumperless-mcp` is a normal command you can run from any directory.
Verify it's installed:
```bash
jumperless-mcp --version
```
## Step 3: Plug in the V5 and say hi
Plug the V5 into your computer via USB. The front-edge LEDs should light up — that means the device is powered and the firmware is running.
Now have the MCP server check the connection:
```bash
jumperless-mcp firmware-probe
```
You should see output like:
```text
firmware_codebase = "JumperlOS"
firmware_version = "5.6.6.2"
jumperless_module_attrs = 384
hashlib_available = false
```
If you got that, your V5 is healthy and the MCP server can talk to it. If you got an error, see [TROUBLESHOOTING.md](../TROUBLESHOOTING.md).
## Step 4: Tell Claude about the server
### If you're using Claude Code (terminal CLI)
One command:
```bash
claude mcp add jumperless jumperless-mcp
```
Then start a Claude Code session: `claude` in your terminal.
### If you're using Claude Desktop (GUI app)
Claude Desktop needs a config file pointing at the MCP server. The file lives at:
- **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
- **Linux:** `~/.config/Claude/claude_desktop_config.json`
If the file doesn't exist yet, create it. Open it in a text editor and paste:
```json
{
"mcpServers": {
"jumperless": {
"command": "jumperless-mcp"
}
}
}
```
Save. Quit Claude Desktop completely (not just close the window — actually quit) and reopen it.
## Step 5: Watch the marquee
When your Claude tool starts (or you start a Claude Code session), it launches
the MCP server in the background. The server connects to the V5 and plays the connect ceremony: an orange `MCP CONNECTED` banner scrolls across the breadboard, and four corner brackets light up as the persistent "MCP is active" indicator.
If you see the marquee, **you're done setting up**. The next steps are just things to try.
## Step 6: Your first interactive moment
In Claude Desktop, start a new chat and ask:
> Connect row 1 to TOP_RAIL on the Jumperless. Then connect ADC0 to row 1 and tell me what voltage you read.
(ADC = Analog-to-Digital Converter — the V5 has four channels, ADC0–ADC3, each of which can measure a voltage. TOP_RAIL is the 5 V supply rail.)
Claude should call the tools `connect`, `connect`, and `adc_get` and report back something like _"Row 1 is at 5.02 V."_
That's the loop: you describe what you want in plain English, Claude figures out the tool calls, and the V5 does the work.
## Step 7: Ask for a board snapshot
Try this:
> Show me the current state of the breadboard as an ASCII picture.
Claude will call `get_state` with `view: "pretty"` and you'll see something like:
```text
=== JUMPERLESS V5 STATE ===
slot: 0 bridges: 1 nets: 7 source: synthesized
RAILS
DAC0: 3.30 V
DAC1: 0.00 V
TOP_RAIL: 5.00 V
BOTTOM_RAIL: 0.00 V
ADC
ADC0: 5.0200 V ADC1: 0.0005 V ...
NETS
#6 Net 6 [orange ] 1,TOP_RAIL,ADC0
OVERLAYS (# = lit, . = dark)
_DIRECT_PIXELS_ @ row=1 col=1 (10x30)
###..........................###
#..............................#
...
```
This is the "view": Claude can see the whole board state in one call. It's the magic that makes the MCP server worth running.
## What to try next
- **LED blink:** [led-blink-via-pwm.md](led-blink-via-pwm.md)
- **Sensor reading:** [sensor-reading.md](sensor-reading.md)
- Or just ask Claude: "What can the Jumperless do that we haven't tried?" — and see where it goes.
When you're done, quit Claude Desktop. The MCP server shuts down cleanly, runs the disconnect ceremony, and releases the V5's USB port.