9 posts tagged with "Developer Tools"

Claude Code is the best AI coding agent we've used. It runs in your terminal, has full access to your filesystem and shell, and writes real code against real projects. But out of the box, it can only work with what's on your machine — your files, your git repos, your local tools.

We kept hitting the same wall. We'd be deep in a debugging session and need to check a customer's Stripe payments, or pull someone's deal stage from HubSpot, or look at what queries are driving traffic in Google Search Console. Every time, we'd have to stop what we were doing, open a browser, log into a dashboard, click around, copy some data back, and paste it into the conversation. The AI had all the context about our codebase but zero visibility into the services our code actually talks to.

So we fixed it. We built a CLI that gives Claude Code authenticated access to 10,000+ tools across 500+ providers — every major SaaS platform, database, and API — and the AI handles everything. You just ask for what you need in plain English.

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.

Glama indexes 20,000+ MCP servers. Smithery has 8,000+. mcp.so has 6,000+. There's no shortage of servers to find.

The problem is everything that happens after you find one.

You pick a promising-looking Stripe MCP server from a directory. Now you need to clone the repo, install its dependencies (hope they don't conflict with yours), figure out whether it uses env or args for the API key, add your key to a JSON config file in plaintext, start the process, and configure your AI client to talk to localhost:3000. If you're lucky, it works. If the repo hasn't been updated in three months, it probably doesn't.

Repeat that for every service you want to connect. We got to five local MCP server processes before we gave up and built something better.

If you've set up an MCP server before, you know the drill. Clone a repo. Install dependencies. Add your API key to a JSON config file. Start the process. Configure your AI client to connect to localhost:3000. Repeat for every service you want to use.

It works. Until it doesn't. The process crashes silently. Your laptop sleeps and the server dies. You upgrade Node and the dependencies break. A teammate wants access and you're sharing API keys over Slack. You add a third service and now you're managing three server processes, three config files, and three sets of credentials in plaintext on your machine.

Local MCP servers are fine for trying things out. For daily use across a team, you need hosting.

The thing that makes Windsurf different from other AI editors is that Cascade is already watching. Open a file, and it's reading it. Switch to a terminal, and it sees the output. Hit a linter error, and it's noticed before you have. You don't explain context to Cascade — it's already there.

But that awareness stops at the boundary of your machine. Cascade sees your Stripe integration code but not your Stripe data. It sees your HubSpot sync logic but not your actual contacts. It can tell you there's a bug in your webhook handler but not whether that bug is hitting customers right now.

We wanted Cascade's contextual awareness to extend past the filesystem. Not just "read the code" but "read the code, check the live data, and fix both at once."

MCPBundles has always worked as an MCP server. You add it to Claude Desktop, Cursor, ChatGPT, or any MCP-compatible client, and your AI gets access to Stripe, HubSpot, Postgres, PostHog, Gmail, and every other service you've connected — with real credentials, real permissions, and real data.

The MCPBundles CLI is an alternative way to access those same tools. Instead of configuring MCPBundles as a remote MCP server in your client, you install a command-line tool and authenticate with an API key. The AI agent discovers and calls your tools through shell commands — the same 10,000+ tools, the same credentials, the same workspace permissions.

pip install mcpbundles

So we built an integration for Cursor's Cloud Agents API. Not because it was on some roadmap or anything. We did it because Cursor's literally our favorite coding tool and we use it every single day.

You've got PostgreSQL databases you query all the time. Maybe it's your local dev database running on your laptop. Maybe it's your production database on a remote server. You used to hook them up to a BI tool or write SQL queries manually.

Now you want to query them with AI instead. Ask questions in plain English, get answers back.

But Claude can't access localhost. ChatGPT can't connect to remote databases with username/password auth. They're stuck in their own environments.

Install mcpbundles. Problem solved.

We just integrated PostgreSQL—the powerful open-source relational database—into MCPBundles. But here's the challenge: PostgreSQL exposes 38 different database tools covering everything from SQL queries to schema inspection to performance optimization. How do you make 38 tools discoverable and useful without overwhelming users?

The answer: use-case driven bundles. Instead of dumping 38 tools into one massive bundle, we organized them into 6 focused bundles based on what database professionals actually do. Every tool appears in the main "PostgreSQL" bundle, plus at least one specialized bundle aligned to specific workflows.