MCP Server in Practice – 5 Boldare Implementations
MCP servers are becoming the standard in 2026 – and that makes sense from both sides: the engineering one and the business one. From an engineering perspective, it’s one standardized way to connect systems to AI agents (Claude, Cursor, Copilot, and dozens of others) instead of building a separate integration for each – you build the connection once, and every compatible agent, today and in the future, simply uses it. From a business perspective, it means fewer maintenance hours, fewer points of failure, and systems that are ready for agents you don’t know about yet, because there will be more of them next year than there are today.
Below, we show what that looks like in practice on live servers and real deployments – a public institution that now talks to its documents instead of scrolling through them; a contact form an AI agent fills out on its own, in a single interaction; a CMS where publishing an article takes one prompt, not half an hour of clicking. Each one below is a specific business problem and a specific solution.
Table of contents
Case 1 – The cultural institution that started talking to its documents
650 research documents. No search engine that understood a question instead of just matching keywords.
The institution – a Polish public organization managing knowledge in the culture sector – had hundreds of research reports and grant applications sitting in PDFs and web descriptions. The knowledge existed, but reaching it meant either manually opening files one by one or knowing the exact phrase someone had used in a document title three years earlier.
Boldare built a RAG-based search prototype over roughly 650 documents – more than 92,000 text chunks after indexing. The pipeline combines hybrid search (dense embeddings + BM25) with a local cross-encoder re-ranker that narrows the top-20 search results down to the top-5 most relevant before they reach the model. GPT-4o-mini generates answers with source citations and a confidence score – hallucinations are addressed directly in the architecture, not patched afterward. Vector data lives in Qdrant, deployed on AWS. Integration with Cursor and Claude.ai runs through an MCP server.
Result: a working demo running on the client’s real data, presented at the first sales meeting instead of a slide deck. The client could ask the system questions live, in natural language, and get answers with a cited source.
Case 2 – The contact form an agent fills out, not a human
Increasingly, the person on the other side of a contact form isn’t a person with a browser anymore. It’s an AI agent, acting on behalf of someone who’s currently comparing ten software houses at once.
For an agent like that, a classic form is a dead end – it has to parse HTML, guess which field is which, and risk a validation error along the way. Boldare had the same problem every company with a contact form has.
The answer is a public MCP server that exposes the RFQ process as a set of tool definitions available to any compatible agent – Claude, Cursor, or a custom workflow a client has built internally. Before going live, the server was tested and validated with MCP Farmer – the same audit path Boldare applies to client deployments.
Result: an AI agent submits a project brief in a single interaction. No form, no waiting for a callback, no risk of a failed validation.
The server runs in production, handling real traffic, and follows the same maintenance rules Boldare offers its clients on their own deployments.
Case 3 – The blog that publishes itself with one prompt
30 minutes. That’s how long it took to publish one article on Boldare’s blog: uploading content to the CMS, formatting, metadata, images, publishing.
This was exactly the kind of task that shouldn’t require manual work: a fully predictable, repeatable process with no real decisions for a human to make.
Boldare built an MCP server connecting Claude directly to Netlify CMS. The agent gets access to CMS operations as defined tools, with no need to integrate with the Netlify API from scratch every time the platform changes.
Result: 30 minutes of manual CMS work → one prompt. The entire manual publishing workflow was eliminated, not just shortened.
The server is used daily by Boldare’s marketing team – not a prototype for show, but part of day-to-day work.
Case 4 – MCP Farmer and Jira MCP in daily dev team work
Before Boldare started selling MCP implementations to clients, it had to solve its own problem: how to check whether an MCP server actually works correctly before letting a production agent near it.
The answer was MCP Farmer – an open-source CLI Boldare built for its own needs and published publicly (GitHub, NPM). The tool auto-detects MCP servers from common client configs, and lets you interactively explore a server – calling tools, reading resources, fetching prompts – before a real agent ever touches it. The ‘probe’ command generates AI-based test inputs and calls the server’s tools with them, writing a report of what happened. The ‘grow’ command generates new tools based on the server’s existing structure. OAuth support (–oauth) lets you test the full authentication flow before deployment. Every server Boldare builds for a client – RFQ, Netlify CMS, and others – goes through the same validation before it sees production traffic.
A separate, smaller example of the same approach: Jira MCP, through which Boldare’s developers create tickets from the terminal – without switching to a browser, finding the right project in Jira, and filling out a form mid-flow.
Case 5 – Figma MCP in frontend work
The traditional design-to-code handoff looks like this: a developer opens a Figma file, reads off values – spacing, colors, component names, hover and focus states – and manually rewrites them in code. Every design change means repeating the same exercise, file after file.
Figma MCP changes that step. The server exposes data from a Figma file to an agent as structured tools – the agent reads the values directly and uses them in code, without that manual, intermediate translation between design and implementation. Boldare wrote about this in the article “How AI and Figma MCP changed the way I build frontend in large-scale projects” – on how MCP integration changes day-to-day work on large, multi-component frontend projects.
Five implementations, one pattern
Each of these cases started the same way: something a human did manually and repeatedly could do itself, if an AI agent had direct access to the system. The cultural institution didn’t need a better search engine – it needed a way to talk to the documents it already had. The contact form didn’t need to be filled out by a human, if an agent was on the other end anyway. Publishing an article didn’t need to take 30 minutes, if the whole process was predictable enough to automate.
What connects these deployments isn’t one technology – it’s one pattern: you build the connection once, and every compatible agent simply uses it. Two servers already run in production, every day. One is at prototype stage, but it’s already changed how a client tests an idea. MCP Farmer shows that Boldare holds itself to the same validation standards it sells to clients.
If you’re wondering whether your system is ready for the same – order an MCP architecture blueprint and see exactly what needs to be built.
Share this article:
