I recently built a small demo that changed how I think about agent tooling and platform integrations.
In short, I gave a chat-based application operational access to my entire Cloudflare account by connecting Cloudflare’s managed MCP servers to a LangChain agent powered by Claude.
- No custom APIs.
- No giant tool schemas.
- No hand-written adapters.
Just MCP.
The idea
Most agent setups today treat tools as static. You define them upfront, wire them into prompts, and hope the model uses them correctly.
That works for small demos. It starts breaking down once you point an agent at a real platform like Cloudflare, which exposes hundreds of possible operations across many services.
MCP changes that model.
Instead of shipping a massive list of tools, the agent connects to MCP servers that describe available capabilities. The model can then discover tools dynamically at runtime and load only what it actually needs.
What I built
In the demo, I connect a LangChainJS agent to multiple Cloudflare MCP servers, including:
- the Browser MCP to fetch and convert live web pages
- the Docs MCP for up-to-date Cloudflare documentation
- Cloudflare’s GraphQL MCP for analytics queries
Using Anthropic’s native MCP toolset and tool search, Claude explores the available tools, decides what to use, and executes them on demand.
From the outside, it just looks like a chat interface. Under the hood, that chat app has real operational access to my Cloudflare account.
Why this felt different
What stood out to me while building this is how little glue code was needed.
I didn’t have to:
- model every API endpoint as a tool
- maintain schemas as the platform evolves
- preload hundreds of tools into the prompt
Instead, the agent discovers capabilities as it goes. Tools feel less like rigid contracts and more like something the agent can explore.
That’s a big shift if you’re thinking about agents interacting with real infrastructure, not just answering questions.
Why MCP matters
MCP is interesting not because it’s another protocol, but because it enables a different mental model:
- platforms expose capabilities, not static tools
- agents discover and load functionality dynamically
- providers like Cloudflare can safely expose large surfaces without overwhelming the model
This feels much closer to how we’ll want agents to interact with production systems going forward.
The code and the video
I walk through the full setup, including the LangChain agent, MCP configuration, and dynamic tool discovery, in this video:
🎥 https://www.youtube.com/watch?v=n-Hw_K_GsOg
👉 https://github.com/christian-bromann/langchat
If you’re experimenting with MCP or thinking about giving agents access to real platforms, I’d love to hear what you’re building.
Top comments (0)