Model Context Protocol (MCP)

Veri speaks the Model Context Protocol, so MCP clients such as Claude Code, Claude Desktop, and Cursor can inspect deployment metrics and request failures, query bounded training metrics, check account burn, and—when writes are enabled—submit, cancel, or clean up runs on your behalf. There are two ways to connect, with the same tools either way:

Hosted endpoint (recommended): https://api.veri.studio/mcp — nothing to install, authenticated with your API key.
Local server: veri mcp serve runs as a subprocess of your MCP client and uses your veri login credentials. Use it if you prefer not to place an API key in client config.

Hosted endpoint

Connect with your Veri API key as a bearer header (create one from the dashboard’s API keys page). Every call acts as that key’s owner — the same permissions you have from the CLI, nothing more. Claude Code:

claude mcp add --transport http veri https://api.veri.studio/mcp \
  --header "Authorization: Bearer $VERI_API_KEY"

Claude Desktop and Cursor take a URL entry under mcpServers:

{
  "mcpServers": {
    "veri": {
      "url": "https://api.veri.studio/mcp",
      "headers": { "Authorization": "Bearer vk_..." }
    }
  }
}

For an unattended agent, use https://api.veri.studio/readonly/mcp instead — the creation and cancellation tools are not registered at all on that path (see Read-only mode). Verify with /mcp inside a Claude Code session, or ask the agent “what is my Veri credit balance?”

Local server setup

The local server runs on your own machine: your MCP client starts it as a subprocess and talks to it over stdin/stdout, so there is no port to open and no API key in client config — it authenticates with your stored veri login credentials.

Install the SDK with the mcp extra

The MCP server ships with the SDK behind an optional mcp extra:

uv tool install 'veri-sdk[mcp]'

pipx install 'veri-sdk[mcp]'

pip install 'veri-sdk[mcp]'

Confirm the command is available:

veri mcp serve --help

The server reads your stored credentials, so log in once:

veri login

You never paste an API key into the MCP client. The server uses the credentials from veri login (or the VERI_API_KEY environment variable if you set one).

Add Veri to your MCP client. The command the client runs is always veri mcp serve.Claude Code has a one-liner. The part after -- is the command it will spawn:

claude mcp add veri -- veri mcp serve

By default this registers Veri for you in the current project. Use -s user to make it available in every project, or -s project to write a .mcp.json that your whole team shares (each teammate still runs their own veri login).Claude Desktop and Cursor are configured with a JSON file. Add a veri entry under mcpServers:

{
  "mcpServers": {
    "veri": {
      "command": "veri",
      "args": ["mcp", "serve"]
    }
  }
}

The file location depends on the client:

Client	Config file
Claude Desktop (macOS)	`~/Library/Application Support/Claude/claude_desktop_config.json`
Claude Desktop (Windows)	`%APPDATA%\Claude\claude_desktop_config.json`
Cursor (global)	`~/.cursor/mcp.json`
Cursor (per project)	`.cursor/mcp.json` in the project root

Restart and verify

Restart the client so it picks up the new server.In Claude Code, run claude mcp list (or /mcp inside a session) and confirm veri shows as connected. In Claude Desktop and Cursor, the Veri tools appear once the server connects. Ask the agent something like “what is my Veri credit balance?” to confirm it can reach your account.

Read-only mode

By default every tool is available, including ones that create billable GPU jobs and deployments. Your MCP client prompts you to approve each tool call, so creation is gated by that approval. Tools that spend credits have descriptions that begin with CREATES A BILLABLE ... so the intent is clear in the approval prompt. For an automated or unattended setup where no human approves each call, run the server read-only so the creation and cancellation tools are not registered at all. Pass --readonly in the command:

claude mcp add veri -- veri mcp serve --readonly

{
  "mcpServers": {
    "veri": {
      "command": "veri",
      "args": ["mcp", "serve", "--readonly"]
    }
  }
}

Setting the environment variable VERI_MCP_READONLY=1 has the same effect. On the hosted endpoint, use the /readonly/mcp path instead:

claude mcp add --transport http veri-readonly https://api.veri.studio/readonly/mcp \
  --header "Authorization: Bearer $VERI_API_KEY"

Available tools

Read tools (always available)

Tool	What it does
`veri_whoami`	Confirm the key is valid, and return the account identity and credit balance. Call this first.
`veri_list_training_jobs`	List training jobs, with optional status and method filters.
`veri_get_training_job`	Get one job: status, cost, dashboard URL, and any error.
`veri_get_training_metrics`	Get bounded native training curves and the W&B run URL when available.
`veri_list_deployments`	List deployments, with an optional status filter.
`veri_get_deployment`	Get one deployment: status, endpoint, GPU, and running cost.
`veri_get_deployment_summary`	Get a compact single-call overview of one deployment.
`veri_get_deployment_metrics`	Get compact lifetime request, token, percentile latency, error, uptime, and cost metrics.
`veri_get_deployment_metrics_timeseries`	Get metric buckets over a time range.
`veri_query_deployment_metrics`	Query up to 500 server-aggregated metric buckets for a time range (seven days by default).
`veri_list_deployment_requests`	List compact request telemetry, optionally restricted to failures or a time range.
`veri_chat_deployment`	Send a chat request to a running deployment.
`veri_list_models`	List custom models in your registry.
`veri_get_hf_export`	Poll the status of a Hugging Face export.
`veri_list_datasets`	List datasets available for training.
`veri_list_volumes`	List persistent volumes with their size and file count.
`veri_list_gpus`	List the GPU catalog: types, providers, and hourly price.
`veri_list_regions`	List the launch regions you can target.
`veri_estimate_cost`	Estimate the cost of a GPU job before submitting it.
`veri_billing_balance`	Get your current credit balance.
`veri_billing_burn_rate`	Get the current spend rate.
`veri_billing_overview` / `veri_get_billing_overview`	Get balance, training and deployment burn, runway, active resources, and recent transactions.
`veri_get_cost_summary`	Get the supported historical cost breakdown for up to 30 days.

Write tools (available unless read-only)

Tool	What it does
`veri_create_training_job`	Submit a managed training run. Returns the job and a pre-submit cost estimate.
`veri_create_deployment`	Create an inference deployment from a training job or a HuggingFace model.
`veri_cancel_training_job`	Cancel a queued or running job.
`veri_stop_deployment`	Stop a running deployment.
`veri_register_model`	Register a completed job’s checkpoint as a reusable custom model.
`veri_push_model_to_hf`	Push a library model to the connected Hugging Face account.

Delete tools (available unless read-only)

Deletes are irreversible and, unlike provisioning, cost nothing, so your MCP client’s approval prompt is the only safeguard. Every description below starts with PERMANENTLY DELETES so the stakes are visible in that prompt. Use read-only mode for any unattended agent.

Tool	What it does
`veri_delete_training_job`	Delete a finished job and its stored checkpoints.
`veri_delete_dataset`	Delete a dataset.
`veri_delete_deployment`	Delete a stopped deployment and its request history.
`veri_delete_model`	Remove a model from the library.
`veri_delete_volume`	Delete a volume and every file in it.

Lifecycle webhooks, Prometheus metrics export, and per-replica drain have no MCP tools today. Reach them over REST; see the API reference.

Test deployment observability with MCP

MCP is optional for deployment observability—the dashboard, SDK, and REST API expose the same underlying telemetry. MCP is the agent-facing interface for investigating that telemetry in natural language. For a safe test, register the server in read-only mode:

claude mcp add veri-observe -- veri mcp serve --readonly

Send a buffered and a streaming request to a serving deployment, then ask:

Inspect deployment dep_... over the past hour. Report request volume, p50/p95/p99 TTFT and end-to-end latency, token throughput, error rate, and cost efficiency. List failed requests grouped by error category. Do not modify resources.

The agent should use:

veri_get_deployment_metrics for compact lifetime health and cost context.
veri_query_deployment_metrics for server-aggregated time-series buckets.
veri_list_deployment_requests for the terminal records behind errors.

Time-series queries return at most 500 buckets, and request-history queries return at most 50 rows per call. Pass an explicit deployment ID and time window when you want repeatable results.

Deployment observability smoke test

Generate buffered and streaming traffic, verify dashboard charts, test SDK and REST queries, and interpret every metric.

Self-hosting the HTTP server

veri mcp serve-http is the multi-tenant streamable HTTP server behind the hosted https://api.veri.studio/mcp endpoint. You can also run it yourself, for example on an internal host shared by a team of agents:

veri mcp serve-http --host 0.0.0.0 --port 8321

The HTTP server does not use your local veri login credentials. Every request must carry your Veri API key as a bearer token, and each call acts as that key’s owner:

claude mcp add --transport http veri https://your-host:8321/mcp \
  --header "Authorization: Bearer $VERI_API_KEY"

{
  "mcpServers": {
    "veri": {
      "url": "https://your-host:8321/mcp",
      "headers": { "Authorization": "Bearer vk_..." }
    }
  }
}

Two endpoints are served:

Path	Tools
`/mcp`	Full surface — write tools gated by your MCP client’s per-call approval, same as stdio.
`/readonly/mcp`	Read tools only. The HTTP analogue of `--readonly` for unattended agents.

The transport is stateless, so the service scales horizontally behind a plain load balancer, and GET /healthz is an unauthenticated liveness probe. Requests are forwarded to the Veri API with the caller’s own key — the server holds no credentials of its own. Point it at a different control plane with --upstream-url or VERI_MCP_UPSTREAM_URL.

Training analysis with W&B

Use Veri MCP for infrastructure, lifecycle, deployment telemetry, and billing. Connect the official W&B MCP alongside it for rich cross-run training analysis, artifacts, and reports. Veri returns a bounded native training metric series and the W&B run URL when available. It does not proxy W&B credentials or reimplement W&B’s query surface.

Working with datasets and rewards

The server does not upload local files. Upload your dataset with the CLI first, then pass its id to the agent:

veri datasets upload ./data/train.jsonl --name my-data

Rewards need no upload step: veri_create_training_job takes a reward_source parameter carrying the reward function’s Python source text, so the agent passes the code inline when it creates the job.

Harness-in-the-loop RL jobs

Harness RL jobs — method grpo_harness, where your own agent (OpenAI SDK, LangChain, or Anthropic SDK) drives the GRPO rollouts unmodified — are regular training jobs to MCP: they appear in veri_list_training_jobs, veri_get_training_job, logs, and metrics like any other run. Submission is CLI-only today (veri run-harness, because the harness code directory is uploaded with the job; veri_create_training_job does not accept this method), and the per-rollout trajectory archive lives on the job’s dashboard page. When a user asks their agent how to RL-train the model behind an existing agent or harness, the setup is small enough to explain conversationally: the agent keeps its normal loop and reads OPENAI_BASE_URL / ANTHROPIC_BASE_URL (pointed at the in-training policy per rollout) plus the task from VERI_TASK_INPUT; a TRL-signature reward function (attached to the job inline) scores each finished trajectory. The full contract and a worked demo: Harness-in-the-loop RL and the URL-extraction agent demo.

Get started

Training

Deployments

CLI

Volumes

Webhooks

Hosted endpoint

Local server setup

Read-only mode

Available tools

Read tools (always available)

Write tools (available unless read-only)

Delete tools (available unless read-only)

Test deployment observability with MCP

Deployment observability smoke test

Self-hosting the HTTP server

Training analysis with W&B

Working with datasets and rewards

Harness-in-the-loop RL jobs

​Hosted endpoint

​Local server setup

​Read-only mode

​Available tools

​Read tools (always available)

​Write tools (available unless read-only)

​Delete tools (available unless read-only)

​Test deployment observability with MCP

Deployment observability smoke test

​Self-hosting the HTTP server

​Training analysis with W&B

​Working with datasets and rewards

​Harness-in-the-loop RL jobs

Hosted endpoint

Local server setup

Read-only mode

Available tools

Read tools (always available)

Write tools (available unless read-only)

Delete tools (available unless read-only)

Test deployment observability with MCP

Self-hosting the HTTP server

Training analysis with W&B

Working with datasets and rewards

Harness-in-the-loop RL jobs