If finops setup doesn't auto-configure, run:

finops setup claude

Or add manually to claude_desktop_config.json:

With uvx (recommended):

{
  "mcpServers": {
    "nable": { "command": "uvx", "args": ["--python", "3.12", "finops-mcp"] }
  }
}

With absolute path:

{
  "mcpServers": {
    "nable": { "command": "/usr/local/bin/finops-mcp" }
  }
}

Use the path from which finops-mcp.

Config file locations:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json
• Linux: ~/.config/Claude/claude_desktop_config.json

Why uvx? Claude Desktop is a GUI app and doesn't inherit your shell's PATH. uvx runs finops-mcp in its own isolated environment. It's the most reliable option on corporate machines with managed Python installs.

nable is not just tools your agent reads from. It is a pre-action gate your agent calls before it makes a cost-affecting change: it prices the change, checks it against your budget, and offers a cheaper path. It never applies anything itself. Propose-only, your agent proposes and a human approves.

Add one line to your agent's system prompt (Claude Code, Cursor, or any MCP client):

Before you apply any infrastructure change (a terraform apply, a helm upgrade, creating or resizing a resource) or start an expensive job, first call check_action_policy with the action and the change (a terraform plan, a helm diff, or a monthly_delta_usd). Relay the verdict, the dollar impact, and the cheaper path when one is offered. Never apply a block or an escalate action; surface it to the human. nable is advisory and propose-only.

The gate returns allow / warn / block / escalate against your policy, the monthly and annual dollar impact, and a spot alternative when the change is compute. One-way doors (delete, terminate, buy a commitment) and over-budget changes always escalate to a human, and over-budget changes are blocked outright when the policy sets on_budget_breach: deny.

And a budget for the agent itself. Run nable ai-budget once, it asks whether you are on a flat plan or a metered API and what you pay, then remembers. On a flat plan it tracks how much subsidized compute you pull for your fixed fee and warns before you run low; on metered it gates on a dollar spend cap. check_ai_budget does the same for the agent mid-task. It reads your Claude Code usage locally, nothing uploaded. Every response is priced at its own model's list rate, cache writes and reads included, and the report splits cost by model and by session. A per-task cap (nable ai-budget --session-cap 40, or "this task may spend at most $40" to the agent) is measured against one Claude Code session, subagents included, and check_ai_budget returns the headroom left under it. Add to your system prompt:

Before starting a large task, call check_ai_budget. If it returns warn or over, tell me where I stand before continuing.

It reports your real usage and burn rate against your budget, not a fabricated percentage of a plan's hidden rate limit.

nable guard install puts the same check in front of the agent's shell commands as a hook, so it runs whether or not the agent remembers to call the gate:

nable guard install --all --global      # every supported agent found on this machine
nable guard install --harness gemini    # one agent, this project only
nable guard doctor                      # what is covered here, and what is not

--global writes the user-level file instead (~/.claude/settings.json, ~/.cursor/hooks.json, $CODEX_HOME/hooks.json, ~/.copilot/hooks/, ~/.gemini/settings.json, ~/Documents/Cline/Hooks/). A hook the user installed is one the user can remove.

Managed deployment. To make the hook a policy a user cannot remove, deploy it through the agent's admin settings. Replace <version> with the release you tested (nable --version), and make sure uvx is on the users' PATH, or use the absolute path of an installed finops binary instead of the uvx form.

Claude Code reads managed-settings.json from /Library/Application Support/ClaudeCode/ (macOS), /etc/claude-code/ (Linux and WSL) or C:\Program Files\ClaudeCode\ (Windows), or a drop-in file in managed-settings.d/ next to it. User, project and local settings add their hooks beside a managed one but cannot remove it, and a user's disableAllHooks cannot turn it off:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "^(Bash|mcp__.*)$",
        "hooks": [
          {"type": "command", "command": "uvx --from finops-mcp==<version> finops guard hook", "timeout": 30}
        ]
      }
    ]
  }
}

Codex reads /etc/codex/requirements.toml (%ProgramData%\OpenAI\Codex\requirements.toml on Windows). A hook there is managed: always on, trusted without the "Hooks need review" step, and not something a user can disable:

[[hooks.PreToolUse]]
matcher = "^(Bash|mcp__.*)$"

[[hooks.PreToolUse.hooks]]
type = "command"
command = "uvx --from finops-mcp==<version> finops guard hook"
timeout = 30

Both also have a switch that runs only the managed hooks and ignores every user, project and plugin hook: "allowManagedHooksOnly": true in Claude Code's managed settings, allow_managed_hooks_only = true at the top level of Codex's requirements.toml. Set it only if no one's own hooks should run. Copilot CLI has the same idea in policy hook files, /etc/github-copilot/policy.d/*.json (root-owned, not group or world writable), in the format of .github/hooks/nable-guard.json.

Sources: Claude Code managed settings, allowManagedHooksOnly, Codex codex-rs/config/src/config_requirements.rs and codex-rs/hooks/src/engine/discovery.rs in openai/codex, Copilot hooks reference.

The guard is a seatbelt, not a security boundary: give agents read-only cloud credentials and keep write access behind a human.

Azure roles. The Azure tools span three RBAC roles, granted to the service principal on each subscription (run finops doctor to check):

# repeat per subscription
az role assignment create --assignee <client-id> --role 'Cost Management Reader' --scope /subscriptions/<sub-id>
az role assignment create --assignee <client-id> --role Reader --scope /subscriptions/<sub-id>
az role assignment create --assignee <client-id> --role 'Monitoring Reader' --scope /subscriptions/<sub-id>

What is a FinOps MCP server? An MCP (Model Context Protocol) server that answers cloud-cost questions from inside an AI editor. nable runs locally as one, so you can ask Claude, Cursor, or VS Code about your AWS, Azure, GCP, and AI spend and it reads your real cost data on your machine to answer.

Is nable free? Yes. The terminal scan, every cost query, anomaly detection, all waste and rightsizing findings, and every connector are free forever. Every install starts with a 7-day trial of Pro features. Pro ($25/mo) adds ticket creation (Jira, Linear, GitHub Issues), email reports and digests sent on request, and the org-wide rollup across accounts. Team ($1,000/mo flat, unlimited seats) adds the conversational Slack bot and chat remediation. Forecasts, commitment recommendations, remediation PRs, and the Ledger are free today while their pricing is decided. Reports and alerts on a schedule, sent without anyone asking, are nable Cloud; this install sends them when you ask.

Does my billing data leave my machine? No. nable is local-first and read-only by default. It reads your cost data on your machine and never uploads it, and you can confirm the no-egress behavior in the source.

What clouds and providers does it support? AWS, Azure, GCP, and Vertex; Kubernetes (Kubecost, OpenCost); AI and LLM providers (OpenAI, Anthropic, Bedrock, OpenRouter, LiteLLM, Modal, Together, Replicate, Cohere, Mistral, Langfuse); data platforms (Databricks, Snowflake, MongoDB); and SaaS (Datadog, New Relic, Cloudflare, Twilio, Vercel, Stripe).

How is it different from AWS Cost Explorer? Cost Explorer is AWS-only and console-bound. nable is cross-cloud, runs in your terminal and in Claude/Cursor, covers AI and GPU spend no cloud console shows, and proposes fixes as pull requests. nable scan also makes zero paid API calls by default.

Is there an open-source alternative to Vantage or CloudHealth? nable is an open-source (Apache-2.0), local-first alternative for cost queries, waste detection, rightsizing, and AI/GPU cost, running on your machine instead of a hosted SaaS.