Let your AI agent run your .http requests.
It never sees your secrets.
Karve ships a built-in MCP server, so Claude Code and other agents can find, run, and fix requests in your real workspace — while your tokens and environments stay in Karve, never in the chat.
claude mcp add --transport http karve http://localhost:8642/mcp
Already own Karve? Update to 1.0.6 and flip the switch — try Karve today →
> why does createOrder return 401? ⏺ karve · run_request createOrder 401 Unauthorized · 142 ms ⏺ karve · get_request createOrder POST {{baseUrl}}/orders Authorization: Bearer {{token}} The Authorization header uses {{token}}, but your active environment doesn't define it — the header goes out empty. ⏺ karve · set_active_environment staging ⏺ karve · run_request createOrder 201 Created · 96 ms
See it work
An agent finds a request, runs it, reads the live response, and fixes the file — every step visible in the real Karve window.
What is MCP?
The Model Context Protocol is an open standard, introduced by Anthropic, that lets AI agents use real applications as tools. Instead of copy-pasting between a chat window and your API client, the agent calls the app directly — asking it to search, read, and act on its behalf.
Karve embeds an MCP server inside the app. When you switch it on, agents like Claude Code get 11 focused tools for working with your .http files — find a request by name or route, run it, read the response, edit through a tab — all against the live workspace you're looking at.
What agents can do in your workspace
Find & read any request
Requests are addressed by name and route — the agent searches your whole workspace, open tabs and files on disk alike, and reads the exact raw block.
find_requests "orders" → get_request
Run it — visibly
Running a request opens its tab in the real UI and makes a real network call. You watch it happen; the agent gets status, headers, timing, and body back.
run_request → 200 · 96 ms · 1.2 KB
Edit through tabs, never behind your back
Edits go through an open tab and mark it dirty — nothing is ever silently written to disk. Saving stays your call, with undo intact.
set_editor_content → saved: false
Switch environments, see the map
Agents can list and switch environments by name (never their values) and read workspace resources — tabs, files, and every endpoint you have.
karve://workspace/endpoints
The agent sees {{token}}. It never sees the token.
Every MCP tool returns raw, unresolved request text. Variables resolve from file @vars and the active environment only at send time — inside Karve, on your machine. Environment contents, resolved values, and your request history are never exposed through any tool or resource. Compare that with pasting a cURL command — live token and all — into a chat window.
POST {{baseUrl}}/orders Authorization: Bearer {{token}} Content-Type: application/json
Raw placeholders, exactly as written in your .http file.
POST https://api.acme.dev/orders Authorization: Bearer eyJhbGciOi•••••••••••• Content-Type: application/json
Resolved at send time, on your machine — visible to the API, not the agent.
What you'll use it for
"Why does this call 401?"
The agent runs the request, reads the live response, spots the empty header or wrong environment, fixes the file in a tab, and re-runs — without ever touching your actual token.
Generate a client from real requests
"Write a typed client for the orders endpoints" — the agent reads every relevant request across your workspace and generates code from what actually works, not from stale docs.
Draft new requests from a spec
Point the agent at an API doc and let it draft the .http requests in a scratch tab — you review, run, and save what's worth keeping.
Get oriented in an unfamiliar API
Inherited a folder of requests with no context? The agent maps the endpoints, explains what each request does, and answers questions against the real files.
Let coding agents verify their work
An agent that just changed your API handler can hit the real endpoint through Karve and prove the fix works — with the run visible in your workspace, on the record.
AI help on internal APIs
Private endpoints and real credentials are exactly what you can't paste into a chat. With Karve MCP the agent orchestrates while the secrets never leave the app.
Setup — two steps
No accounts, no cloud relay, no config files inside Karve — one toggle and one command.
Switch the server on in Karve
Settings → MCP server. It's off by default, binds to localhost only, and uses port 8642 (configurable).
Connect your agent
For Claude Code, one command:
claude mcp add --transport http karve http://localhost:8642/mcp
For VS Code, Cursor, or any other MCP client that speaks Streamable HTTP, point it at the same URL:
{
"mcpServers": {
"karve": {
"type": "http",
"url": "http://localhost:8642/mcp"
}
}
}
That's it — start asking
"Run the health check." "Why does createOrder 401?" "Draft requests for the new invoices API." The agent works in your visible workspace; you stay in charge of what gets saved and sent.
An agent in your API client should earn your trust.
Beyond the secrets firewall, the whole posture is conservative: the server is opt-in, local-only, and everything an agent does happens in the open — in the same window you're working in.
- Off by default. One explicit toggle in Settings turns it on — and off.
- Localhost only. Binds to localhost and validates the Origin header on every request — nothing on your network can reach it.
- Everything visible. Tabs open and requests run in the real UI. No headless puppeteering, no focus stealing.
- No silent writes. Agent edits mark the tab dirty; saving to disk stays yours. History is never exposed over MCP.
- Ask before writes. Agents are instructed to confirm with you before POST, PUT, PATCH, or DELETE calls.
Common questions
Can the AI agent see my API keys or tokens?
No. Karve's MCP server always returns raw, unresolved request text — the agent sees {{token}}, never the value behind it. Variables resolve from file @vars and the active environment only at send time, inside Karve. Environment contents, resolved values, and request history are never exposed through any MCP tool or resource.
Is it safe to let an AI agent run my requests?
The server is opt-in and off by default, listens on localhost only, and validates the Origin header on every request. Everything an agent does is visible: tabs open in the real UI, requests run before your eyes, and edits are never silently saved to disk. Agents are instructed to confirm with you before state-modifying calls like POST, PUT, PATCH, or DELETE.
Which MCP clients work with Karve?
Any client that speaks MCP Streamable HTTP: Claude Code, Claude Desktop, VS Code, Cursor, and others. You point the client at http://localhost:8642/mcp (the port is configurable).
Does Karve MCP cost extra?
No. The MCP server ships as part of Karve — a one-time purchase with no subscription and no account. See pricing.
Does my API data leave my machine?
Karve never uploads anything. The MCP server listens on localhost only, so only agents running on your PC can connect. Responses from runs an agent starts are shared with that agent — that's the point — but your variables, environments, and stored history are not.
Which version of Karve has the MCP server?
It's available now, in Karve 1.0.6 and later. Get Karve from the Microsoft Store — or update if you already own it — and enable it in Settings → MCP server.
MCP is how agents reach Karve. Karve AI is the copilot inside it.
Also in the works: on-device AI that generates requests, explains failures, and writes tests — with the same local-first promise.
Your agent gets the workspace. Your secrets stay home.
The MCP server ships in Karve 1.0.6 — part of the same one-time purchase, no subscription and no account. Get Karve on the Microsoft Store, then flip it on in Settings.