Cursor MCP Tools: Give Your AI Coding Agent 10,000+ Real API Tools

Here's the thing nobody tells you about Cursor's agent mode: it's brilliant at working with code and completely blind to everything your code talks to.

Last week we were debugging a webhook handler. Cursor had the code open, understood the control flow, spotted a race condition in the retry logic. Genuinely impressive. Then we needed to know whether the bug was actually hitting production — were customers seeing duplicate charges? The agent that just did 15 minutes of sophisticated code analysis couldn't answer a basic factual question about our own Stripe data.

So we opened a browser tab, logged into Stripe, searched for the customer, scrolled through PaymentIntents, compared timestamps manually, went back to Cursor, and typed what we found. The AI had all the context and none of the data.

We got tired of being the copy-paste bridge between our IDE and our dashboards.

The Setup Nobody Reads (But You'll Be Glad You Did)

Three commands in Cursor's terminal:

pip install mcpbundles
mcpbundles connect my_workspace
mcpbundles init

That last command drops a skill file into your project directory. Cursor reads it automatically. From that point on, the agent knows how to discover tools, call them, and chain results across services. No mcp.json to maintain. No local server processes.

The nuance that matters: mcpbundles init writes the workflow, not a static tool list. So when your team adds a new service to the workspace next month, the agent discovers it at runtime. Nothing to update.

The Part That Actually Matters: The Agent Writes Code From Real Data

Other AI coding tools can call APIs. The difference with Cursor is what happens after the data comes back. The agent doesn't just show you the result — it feeds it back into the code it's writing.

We asked Cursor to build a billing dashboard component. Instead of hallucinating TypeScript interfaces for Stripe's response shape, it called the actual Stripe API, looked at a real PaymentIntent object, and generated types that matched the production response exactly. Field names, nesting, nullable fields — all correct on the first try. No // TODO: update with real types.

That only works in an IDE where the AI can call an API and edit your files in the same turn.

Another example we hit this week: we were writing tests for our HubSpot sync and needed realistic fixture data. Instead of inventing fake contacts, Cursor queried our actual HubSpot instance, pulled 5 real contacts (with the exact property naming conventions HubSpot uses internally — firstname not first_name, hs_object_id not id), and generated test fixtures from them. The tests passed against the real API immediately because the fixtures were real data.

Background Agents Are Where This Gets Interesting

Cursor's inline agent is good. But background agents change the economics of how you use external tools.

An inline agent call to Stripe takes 2-3 seconds and you're watching it happen. Fine for quick lookups. But when we started using background agents, we found ourselves writing prompts like:

"Audit our subscription billing. Pull all active subscriptions from Stripe, cross-reference with our database to find any where the Stripe status doesn't match our local status, check HubSpot for the deal stages of any mismatches, and write a report as a markdown file."

That takes 40+ tool calls across three services. You wouldn't do that interactively — too slow, too many things to watch. But a background agent handles it overnight. You come in the next morning to a finished report and a PR that fixes the two subscription records that were out of sync.

The skill file in your project gives background agents the same tool access as your inline sessions. Same credentials, same services, same authentication. You just write a bigger prompt and let it run.

What We Actually Use Daily

We're not going to list every service MCPBundles supports — there are 500+ providers and 10,000+ tools and you can browse them yourself. Here's what we actually call from Cursor, ranked by how often:

1. PostgreSQL — "How many users signed up this week?" answered by querying the database directly instead of navigating to an analytics dashboard. This is the one that, once you set up, you can't go back.
2. Stripe — Customer lookups during debugging. "Does this customer have an active subscription?" is a 3-second answer instead of a browser tab.
3. Google Search Console — We run SEO checks from Cursor. "What are our top pages by clicks this week?" feeds directly into content decisions.
4. Ahrefs — Keyword data and backlink checks. We cross-reference this with GSC data in the same conversation. 112 tools.
5. GitHub — PR reviews, issue creation from bug investigations. The agent finds a problem, creates the issue, all without leaving the IDE.
6. Sentry — "Any new errors since the last deploy?" is our morning routine. Cursor reads the errors and can immediately open the relevant source files.

The pattern is always the same: we ask a question about our live systems, the agent answers it, and then it does something useful with the answer — writes code, creates an issue, generates a report. The data and the action happen in the same context.

CLI vs mcp.json — We Use Both

Cursor supports MCP natively through .cursor/mcp.json. You can add MCPBundles as a remote server there and tools show up in the agent's tool list directly. We actually use both approaches depending on the situation.

We use mcp.json for single-service setups where someone just needs one bundle. Add the URL, restart Cursor, done:

{
  "mcpServers": {
    "mcpbundles": {
      "url": "https://mcp.mcpbundles.com/bundle/YOUR-BUNDLE-SLUG"
    }
  }
}

We use the CLI for multi-service workflows. The exec command lets the agent write Python that calls tools from different services in a single script — Stripe + HubSpot + PostgreSQL in one loop. That's not possible through mcp.json alone.

mcpbundles exec "
customers = await list_customers(bundle='stripe', limit=10)
for c in customers['data']:
    contact = await search_contacts(bundle='hubspot-crm', query=c['email'])
    print(c['email'], c['created'], len(contact.get('results', [])), 'HubSpot matches')
"

One gotcha: after any mcp.json change, you have to quit Cursor entirely and reopen it. Just closing the window doesn't reload MCP servers. Full details in the Cursor setup guide.

Getting Started

pip install mcpbundles
mcpbundles connect my_workspace
mcpbundles init

Browse available services at mcpbundles.com/providers or search individual tools at mcpbundles.com/tools. Same CLI works in Claude Code and Windsurf if you use those too.

FAQ

How do I add MCP tools to Cursor?

Fastest: pip install mcpbundles && mcpbundles init in the terminal. Or add a bundle URL to ~/.cursor/mcp.json manually. Both work — the CLI gives you runtime discovery and cross-service scripting, mcp.json is simpler for single-bundle setups.

Do background agents work with MCP tools?

Yes. The skill file in your project gives background agents the same access as inline sessions. We use background agents for audits, data reconciliation, and multi-service reports that would take too many interactive turns.

Does the CLI work with other AI agents?

Same CLI, same workflow in Claude Code, Windsurf, Codex, or anything with terminal access.