MCP Server

probe-mcp is a separate Rust binary that exposes Probe's traffic to AI agents over the Model Context Protocol (JSON-RPC 2.0 over stdio). With it, Claude Code, Cursor, or any MCP-compatible client can read the captured requests, replay them, set breakpoints, manage Map Local / Map Remote / throttle rules, and run scripts — without you copy-pasting JSON into chat.

It ships inside the Probe install. You don't need to download anything separately or pass tokens by hand.

What the AI can do

probe-mcp exposes 117 tools, all prefixed probe_…, grouped by feature. Every one is listed below.

Traffic inspection — List, filter and search captured requests, read one in full, check the session summary and capture status, and clear or delete entries from the copy the API reads (the app's own log list is not touched).
probe_list_traffic probe_get_request probe_search_traffic probe_get_session_summary probe_clear_traffic probe_delete_traffic probe_get_capture_status

Capture control — Turn the tools' own traffic copy on or off. Traffic keeps flowing through the proxy, and the Probe app keeps recording in its own log either way; only what these tools can read stops.
probe_toggle_capture

Certificate — Read Probe's CA (PEM, SHA-256 fingerprint, the public-key hash for Chromium's --ignore-certificate-errors-spki-list, download URLs, the proxy address, whether this computer trusts it, and one line per client on how to trust it), or ask the running app to install and trust it on this Mac or PC. The install runs the app's own Install button: a person must approve the macOS or Windows prompt on screen, the tool takes no password, and an already trusted CA answers already_trusted without a prompt.
probe_get_ca probe_install_ca

Replay — Re-send a captured request, optionally with a different method, URL, headers or body. By default it goes through the proxy, so the replay is captured as a new entry you can diff against the original.
probe_replay_request

Diff — Compare two captured entries: method, URL, status, headers and body.
probe_diff_traffic

Export — Turn a captured entry into a runnable cURL command or raw HTTP text.
probe_export_curl probe_export_raw

Breakpoints — Create breakpoint rules that pause matching traffic (list, delete or clear them), see what is paused and in which phase, then resume, edit or abort it.
probe_create_breakpoint probe_delete_rule probe_list_rules probe_clear_breakpoints probe_list_intercepts probe_resume_intercept

Intercept hosts — Manage the SSL-proxying allowlist. These tools pause nothing: while the list is empty every HTTPS host is decrypted; once it has an entry, only the listed hosts (and their subdomains) are decrypted and logged with bodies.
probe_add_intercept_host probe_remove_intercept_host probe_list_intercept_hosts

Blocked hosts — Tunnel a host's traffic without decrypting or logging it, to cut analytics and telemetry noise.
probe_block_host probe_unblock_host probe_list_blocked_hosts

Blocked clients — The same silent forwarding by client label: a process name for local apps, an IP address for a phone.
probe_block_client probe_unblock_client probe_list_blocked_clients

Throttle — Set the global download cap, read the whole global profile, turn it all off, and list, add, change or delete the scoped throttle rules (the app saves rule changes, so they need it open).
probe_set_throttle probe_disable_throttle probe_get_throttle probe_list_throttle_rules probe_add_throttle_rule probe_update_throttle_rule probe_delete_throttle_rule

Scripting — Run JavaScript once in test mode, or manage the script rules that apply it to matching traffic, with a master switch.
probe_execute_script probe_list_script_rules probe_add_script_rule probe_update_script_rule probe_delete_script_rule probe_toggle_scripting

Sessions — List the open session tabs and your saved sessions, fetch the entries in either, and save a tab's capture (or one host, or some ids) as a saved session. The app answers from its live state and does the save.
probe_list_session_tabs probe_get_session_tab probe_list_saved_sessions probe_get_saved_session probe_save_session

Compose — Manage Composer collections, requests, folders and environments, send a saved or ad-hoc request, read the send history, and export a collection to Postman, cURL or Probe format, or import one (Postman v2.1, a cURL command, Probe format). Sending and importing need the Probe app open.
probe_list_collections probe_get_collection probe_create_collection probe_import_compose probe_add_compose_request probe_add_compose_environment probe_send_compose_request probe_send_request probe_delete_collection probe_update_compose_request probe_delete_compose_request probe_update_compose_environment probe_delete_compose_environment probe_add_compose_folder probe_list_compose_history probe_export_collection

Map Local — Serve a canned response instead of contacting the origin: list rules, read one, preview which one matches a request, create, update, delete or toggle a rule, or flip the master switch.
probe_list_map_local_rules probe_check_map_local_match probe_get_map_local_rule probe_create_map_local_rule probe_update_map_local_rule probe_delete_map_local_rule probe_toggle_map_local_rule probe_set_map_local_enabled

Map Remote — Redirect matching requests to a different upstream. Same rule tools as Map Local; the match preview also returns the rewritten URL.
probe_list_map_remote_rules probe_check_map_remote_match probe_get_map_remote_rule probe_create_map_remote_rule probe_update_map_remote_rule probe_delete_map_remote_rule probe_toggle_map_remote_rule probe_set_map_remote_enabled

Mock Server — Manage the rules of the standalone mock listener, preview which rule would answer a request, check whether the listener is running, and start or stop it.
probe_list_mock_rules probe_get_mock_status probe_check_mock_match probe_get_mock_rule probe_create_mock_rule probe_update_mock_rule probe_delete_mock_rule probe_toggle_mock_rule probe_set_mock_enabled probe_start_mock_server probe_stop_mock_server

Flows — List and read saved API flows, create, rename, rewrite (whole graph, guarded by a revision) and delete them, run one end to end, and fetch the report of a run that outlived the 120 s wait. Writes and runs need the Probe app open.
probe_list_flows probe_get_flow probe_create_flow probe_update_flow probe_set_flow_graph probe_delete_flow probe_run_flow probe_get_flow_run

Files (remote-fs) — Work with the Files connections you already opened in the app: list connections and directories, create, rename and delete, queue downloads and uploads, watch the transfer queue and cancel a transfer. There is no connect tool; credentials stay in the app.
probe_list_remote_fs_connections probe_remote_fs_list_dir probe_remote_fs_mkdir probe_remote_fs_rename probe_remote_fs_delete probe_remote_fs_download probe_remote_fs_upload probe_remote_fs_transfers probe_remote_fs_cancel_transfer

Test runs — Group the requests one test produces and read exactly those (test_run_id on the traffic tools); stays in Probe's memory.
probe_begin_test_run probe_get_test_run probe_end_test_run probe_wait_for_request probe_add_test_rule probe_reset_test_rules

Traffic checks — Assert on what a test sent, or export the capture as HAR 1.2 (inline or to a file).
probe_assert_traffic probe_export_har

WebSocket — List captured WebSocket connections and read their frames (read-only).
probe_ws_list_connections probe_ws_get_frames

The full per-tool schema lives in MCP Tool Reference.

How it works

When Probe starts the proxy, it spins up an internal axum HTTP server on 127.0.0.1 at a random port and writes the port and a freshly-generated bearer token into ~/.probe/api-handshake.json (mode 0600 on Unix). When your MCP client launches probe-mcp, it reads that file, checks that Probe's PID is still alive, and forwards every tool call as an authenticated REST request.

The port and token change every time the proxy starts, so a stolen token stops working once the proxy restarts or Probe quits. You don't have to restart your AI client when that happens:

• Probe isn't running yet? probe-mcp still starts. Each tool answers "Probe is not running" until the app is up, then works without a restart.
• Probe or the proxy restarted? When a call can't connect, or the API answers 401, probe-mcp reads the handshake again and retries the call once with the new port and token.
• Running an isolated instance? Set PROBE_DATA_DIR in the server's environment and probe-mcp reads <PROBE_DATA_DIR>/api-handshake.json instead of ~/.probe/.

On the protocol side, probe-mcp negotiates MCP revision 2025-06-18, 2025-03-26 or 2024-11-05 (whichever your client asks for). It answers ping, never replies to a notification, and runs tool calls concurrently, so a long send or flow run doesn't block other calls. A notifications/cancelled from the client aborts the call it names. Each REST call has a 150-second limit, just above the 120 seconds the app gets for a send or a flow run. Every tool carries the MCP hints readOnlyHint and openWorldHint, and every tool that changes something also carries destructiveHint, so clients that ask before running a tool can skip the prompt for read-only ones.

Large results

Tools that return bodies take a max_body_chars argument: probe_get_request, probe_export_curl, probe_export_raw, probe_replay_request, probe_diff_traffic, probe_get_session_tab, probe_get_saved_session, probe_get_collection, probe_send_compose_request, probe_send_request, probe_list_compose_history, probe_get_flow, probe_run_flow, probe_ws_get_frames, probe_export_collection and probe_execute_script. Any body or other long text value is cut after that many characters (default 8000), with a marker saying how to get the rest. Pass 0 for no limit; a captured body can be up to 512 KB. probe_ws_get_frames also returns only the newest 100 frames unless you pass limit.

A write tool refuses any argument that still carries that marker (writing it back would save the marker instead of the real content): read the value again with max_body_chars: 0 before you send it.

Changes made through MCP show up in the app

With the Probe app open, a change an AI makes through MCP (or the REST API) is the same as a change you make in the UI:

• Rules and settings. Map Local, Map Remote and Mock rules (and their master switches), starting or stopping the Mock server, script rules and the scripting switch, breakpoints, ignored hosts and clients, and the global throttle are handed to the app, which applies them through its own code and shows them in its windows, so a later UI edit doesn't wipe them. Rules, master switches, breakpoints and the ignored lists are saved and survive a restart; the global throttle, the scripting switch and the Mock server's running state reset on restart, just as they do when you set them in the UI. If the app refuses a change or doesn't confirm it within 15 seconds, the tool reports an error that says the proxy applied it but it may not be saved. Until the app answers that change (at most 2 minutes), further rule and setting changes are refused with an error and change nothing.
• Composer collections. These are JSON files in ~/.probe/compose/. When a Compose tool writes a collection or adds a request, Probe's compose directory watcher sees the file change and reloads, so the new request appears in the Composer sidebar without a restart. The watcher coalesces a burst of writes (an agent creating a collection and then adding three requests) into one reload, and it picks up files written by any other tool too.
• Sessions. The session tools read the app's live tabs and your saved sessions, not files on disk.

The SSL-proxying allowlist (the intercept-host tools) is saved by the app too, and while it isn't empty the app shows a banner naming the hosts, with Decrypt All Hosts to clear it. Resuming a paused request with probe_resume_intercept closes the app's paused-request dialog for it.

One exception: when the proxy runs without the app's UI (a headless run such as the smoke test), rule and setting writes stay in the proxy's memory until it stops.

Three steps to wire it up

1. Install Probe. The probe-mcp binary is bundled with the app — nothing extra to install.
2. Add it to your AI client's config. One JSON block per client. See MCP Setup for Claude Code, Cursor, Continue, and generic stdio clients.
3. Ask the AI a traffic question. Try: "What were the last five requests Probe captured? Replay the most recent failed one with a fresh Authorization header."

Live UI updates from MCP writes

Composer collections are JSON files in ~/.probe/compose/. When you ask the AI to build a request and it calls a Compose tool that writes a new collection or adds a request, Probe's compose directory watcher sees the file change and reloads the in-memory collections — the new request appears in the Composer sidebar without you having to restart the app or click Reload.

The watcher coalesces filesystem events with a short debounce, so a burst of writes from one MCP call (typical when an agent creates a collection and immediately adds three requests) reloads once, not three times. This is what makes the round-trip — "ask Claude to draft a request → see it in the Composer → tweak and send" — feel like a single workflow instead of two disconnected tools.

The same watcher catches edits made in any other tool or sync target writing into ~/.probe/compose/. There's no special-casing for MCP — anything that drops a JSON file in there shows up.

What's NOT exposed

A few intentional gaps:

• No general filesystem access. Apart from the handshake file, the MCP can only read what the REST API returns — captured traffic, rule state, saved sessions via probe_list_saved_sessions. The one exception is the Files tools: probe_remote_fs_upload and probe_remote_fs_download read and write the absolute local paths the agent passes them, and only on a connection you already opened in the app.
• No system proxy toggle. Starting/stopping the proxy and flipping the system proxy setting are UI-only on purpose.
• No connect tool for Files. Passwords and keys stay in the app; the Files tools only drive connections you opened there.

Next steps

• MCP Setup (Claude / Cursor) — wire probe-mcp into your AI client.
• MCP Tool Reference — every tool, every parameter.
• End-to-end testing — the begin, wait, assert, mock, export loop for tests and CI.
• Internal REST API — what probe-mcp calls under the hood, in case you want to script against Probe directly.