EP 178: Sarat Vemuri – MCP4Acumatica: Acumatica MCP for Claude
- Sarat wanted to connect Claude to his company’s Acumatica 2025 R2 instance without waiting for the official Acumatica MCP Server
- So he built his own, called it MCP4Acumatica, and released it on GitHub with extensive documentation
- But I’m not a developer and so I need help understanding exactly what it is
- Let’s go through it in detail and pester Sarat with questions...
AI Summary (written by AI, edited by Tim)
The Real Secret Sauce in Connecting AI to Acumatica Isn’t the MCP Server
MCP sounds like one of those technologies that's easy to make more mysterious than it needs to be. Model Context Protocol sits in the middle between an AI agent and another system, giving the agent a standard way to discover tools, call them, and use the results. In the case discussed on ERP Seal Episode 178, that other system was Acumatica. But the most interesting part of the discussion was not really the protocol itself.
The more important idea was what happens after the plumbing works. Once an AI agent can reach an ERP system, two questions immediately become more important than the connection: What is the agent actually allowed to see, and does it understand what the data means? That is where governance, security, descriptions, business context, and plain old human judgment start to matter.
That was the thread running through Tim Rodman’s discussion with Sarat, a CFO and CIO who built an open-source MCP server for Acumatica. Sarat approached the project from both sides of the table. His technical background made him comfortable with APIs, cloud infrastructure, and software architecture. His CFO role made him skeptical of technology spending that exists mainly because the technology is cool.
That combination turned out to be useful. The project was not about turning Acumatica over to an autonomous AI and hoping for the best. It was about reducing friction around a much narrower use case: letting authorized users ask questions about ERP data in plain English while keeping the connection read-only, governed, observable, and constrained.
AI Has Become Useful Enough to Take Seriously—But Not Trust Blindly
Sarat had not always been bullish on using AI inside the business. Through much of 2025, he was actively telling people to slow down. The models hallucinated too often, produced confidently wrong answers, and were not something he wanted people depending on for important work.
In his view, something changed in late 2025 and early 2026. Newer frontier models, including the Sonnet and Opus families he was using, became much more useful for reasoning through information and synthesizing material quickly. They still hallucinated. They still could be wrong. But the balance shifted enough that the productivity gain became real.
He is still skeptical of the “10x productivity” language coming out of Silicon Valley. His point was more modest: the tools can make people substantially more productive when used correctly. At his company, adoption started gradually, and by the time of the discussion, roughly half the organization was using AI in some fashion.
The important qualifier is “when used correctly.” Sarat does not treat Claude or ChatGPT like a replacement for Google where someone types two words and expects the perfect answer. He sees the models as much better at synthesizing information when the user gives them context, explains the goal, and tells them what matters.
That matters because many of the people getting value from AI are not technologists. Sarat described plumbers and construction project managers using the tools in interesting ways. They may not know the underlying technology, but they know their domain. Once they understand how to give the AI context and direction, the domain expertise is already there.
His analogy was a very smart intern with a hundred PhDs. The intern can move unbelievably fast, but somebody still has to explain the assignment. The person who understands the business problem remains part of the system.
Tim liked that framing because it avoids two opposite mistakes. One mistake is dismissing AI as hype because it still makes errors. The other is anthropomorphizing it into something that “thinks” like a human. Sarat was especially resistant to that second idea. To him, the model is a machine performing next-token prediction, not a person with judgment, cognition, or feelings.
That distinction changes how someone should interact with it. If an answer looks wrong, there is no reason to protect the AI’s feelings. Push back. Tell it the numbers do not make sense. Tell it two facts should not be true at the same time. Give it more context and make it try again.
The Shift From Chatbots to Agents Is What Makes MCP Interesting
Sarat also draws a distinction between an LLM and an agent. The LLM is the underlying brain. The agent is the surrounding system that can maintain context, use tools, make web calls, access files, and perform multiple steps toward a goal.
That's a big change from the earlier chatbot experience. Early LLM usage often felt like opening a window, typing a prompt, receiving an answer, and closing the window. A lot of “prompt engineering” grew around trying to squeeze the right behavior out of that single interaction.
Current agents can do more than answer one prompt. They can be given a goal, constraints, and tools. They can decide which tool to use, call it, inspect the result, call another tool, and then synthesize an answer. That's where a protocol such as MCP becomes useful.
MCP, at a high level, lets a server advertise what tools it has and what those tools do. The exchange happens in structured JSON, but the tool descriptions are meaningful to the language model. The agent can look at a tool description, determine that it is relevant to the user’s request, call it with the appropriate parameters, receive structured results, and then use those results in its response.
In other words, MCP is not magic. It's a standardized way for the agent to ask, “What can you do?” and then use the available capabilities. A common implementation wraps an API, although Sarat pointed out that an MCP server does not have to be an API wrapper.
Why Connect an AI Agent to an ERP System at All?
The strongest business case in this episode was not transaction entry. Sarat’s Acumatica MCP server is intentionally read-only. He is not yet comfortable giving an AI agent permission to make changes inside the ERP system, and that boundary is deliberate.
The useful first problem is analysis. LLMs are very good at synthesizing unstructured information—documents, text, and similar content—but ERP systems contain structured, deterministic data. The actual sales orders, purchase orders, GL transactions, customers, inventory balances, and other operational records live in the ERP.
MCP provides a bridge between those two worlds. The agent contributes the language interface and synthesis. Acumatica contributes the governed source data. Put them together and a nontechnical user can ask a question in plain English that previously might have required a report, a Generic Inquiry, several screens, or help from an analyst.
The time savings can come from eliminating the round trip. A CFO may have a very specific question but not know how to write the query. Traditionally, that question might go to IT or a data analyst, who then has to understand the request, build something, test it, and return the answer. Depending on the organization, that loop can take days or even weeks.
With the agent connected to Acumatica, the question can be asked directly. Sarat said procurement users at his company were already using the connection to investigate replenishment levels and items that appeared low. The same questions could be answered inside Acumatica, but the agent reduces the friction of gathering and combining the data.
That friction reduction is especially obvious when the question is compounded. Looking up one GL account may be faster in an Acumatica screen. But if the question requires ten screens, remembering values from several places, applying multiple filters, and combining the results, the natural-language interface starts to earn its keep.
Tim connected that point to his own experience with other AI workflows. He does not buy the idea that traditional user interfaces are simply going to disappear. In his own calorie-tracking setup, there are times when asking through a natural-language interface is convenient and other times when opening the Airtable table is faster. The same principle applies to ERP.
Everything is not a nail just because AI is the new hammer. A chat interface is another interface. Sometimes it removes enormous friction. Sometimes the existing screen is better.
How the Acumatica MCP Server Is Put Together
Sarat did not begin by planning to become an MCP-server developer. He had users asking why they could not simply ask Claude questions about Acumatica data. The answer was obvious once stated: Claude did not know anything about their Acumatica instance because it was not connected to it.
At the time of the July 10, 2026 discussion, Sarat had not found an Acumatica-provided MCP server that solved the problem he wanted to solve. He had looked at what was available and at Acumatica’s roadmap, but there was uncertainty around exactly when an inbound MCP capability would arrive. Rather than wait, he asked Claude what it would take to build one around Acumatica’s contract-based REST API.
The development process itself became an example of AI-assisted work. Sarat used Claude to reason through the architecture and create a Markdown specification. He then handed that specification to Claude Code to implement. Claude generated a great deal of the code and documentation, but Sarat emphasized that he made the architectural decisions, corrected the AI, imposed constraints, and decided what the final system should do.
That distinction matters. Saying “AI built it” does not mean a human typed one sentence and blindly published whatever came back. Sarat compared the shift to moving from assembly language to a higher-level programming language. The abstraction layer changes. The human is still responsible for the outcome.
The runtime architecture uses a Cloudflare Worker as the middle layer between the AI agent and Acumatica. Sarat liked the serverless approach because it avoided standing up and maintaining a conventional server. The worker can run TypeScript, and Cloudflare provides the supporting primitives needed for things such as token storage and logging.
The cost was not presented as a major obstacle. Sarat described Cloudflare Workers as inexpensive and noted that a free tier exists. The larger usage cost depends on the AI plan being used by each person, because the AI interaction still belongs to that user’s Claude or other agent account.
The server talks to Acumatica in two main ways. In Sarat’s current architecture, OData is used for Generic Inquiries, while Acumatica’s contract-based REST API is used for standard entities. That gives the server a path both to more standardized ERP objects and to company-designed GIs.
Governance Was Built In, Not Bolted On Later
The security model is probably the most CFO-like part of the project. Sarat’s requirement was that the MCP server act as an intermediary rather than a place where ERP credentials and business data accumulate.
The first layer is per-user authentication through Acumatica. When a user connects the AI client to the MCP server, the authentication flow redirects the browser to Acumatica. The user signs in through the same mechanism normally used there, including SSO when configured. The MCP server does not collect the user’s password.
Acumatica then provides a bearer token tied to that authenticated user. Subsequent calls to Acumatica are made using that user context. The intent is that the person should receive only the data that person is already authorized to access, including row-level restrictions.
Authentication alone was not enough for Sarat. He also added an explicit access gate inside Acumatica so an administrator has to intentionally allow a person to use the MCP server. The implementation uses an access-check GI because user-role information itself is not exposed through the API in the way needed for this test.
The next layer is informed consent. The system warns the user that Acumatica is being connected to an AI system and that the AI is not perfect. That may sound simple, but it reinforces an important point: capability and permission are not the same thing.
Sensitive-field redaction adds another layer. Sarat built pattern-based detection that, by default, looks for things such as Social Security numbers, bank-account-like values, and credit-card-like values. The patterns can be configured. Email addresses are not redacted by default because that could remove a large amount of otherwise useful data.
Observability is part of governance too. The server records who called which tool so there's an audit trail for debugging and forensics. Sarat specifically distinguished those logs from the underlying business data. The server does not log the user’s original prompt because it never receives that prompt, and the design is not intended to store the ERP data returned by the calls.
That architecture reflects a broader lesson for ERP AI projects. “Can the AI do it?” is the wrong first question. ERP people also have to ask who is allowed to do it, what data can leave the system, what gets logged, how access is revoked, and what happens when the model is wrong.
The Plumbing Matters, but the Content Wins
The most important part of the episode came after the architecture was already working. Sarat had initially made many Generic Inquiries discoverable through the MCP server. In a real Acumatica environment, that created a new problem: the agent could see roughly 150 to 170 GIs and had very little information about what any of them actually meant.
A GI name is not enough context. If the agent sees dozens or hundreds of similarly named inquiries with no useful description, it has to guess which one applies to the question. That's exactly the kind of situation where a language model can confidently choose the wrong thing.
Sarat therefore added a separate “exposed to MCP” control for GIs. The default became that no GI is exposed until someone deliberately enables it. That is separate from whether the GI is exposed through OData for some other purpose. A GI might be available to another reporting tool without automatically becoming available to an AI agent.
He also added descriptions at both the GI level and the result-column level. The GI-level description can be a paragraph or two explaining what the inquiry is designed to do, what its limitations are, and the kinds of questions it's appropriate for. Column descriptions can be shorter—often a sentence explaining what the field means and any gotchas the model should know.
This is where Sarat’s line “the content always wins; it’s not the plumbing” becomes the central idea. The infrastructure has to expose the right fields and tools, of course. But once that works, the language around the data becomes the differentiator.
Acumatica’s standard REST API has an advantage here because its published API metadata already describes much of the structure. The agent has more clues about what a customer entity is or how a standard endpoint works. A custom GI is different. It reflects the company’s own choices, filters, calculations, naming conventions, and business meaning.
The AI does not automatically know those company-specific semantics. A field name may be technically correct and still be ambiguous in the context of the business. A GI may produce exactly the intended numbers while still being easy for an agent to misuse if nobody explains its purpose and limitations.
That makes descriptions look a lot like a lightweight semantic layer. They turn technical structures into business meaning that a language model can consume. The MCP server makes the data reachable; the descriptions make the data interpretable.
A Standard MCP Server Can Still Need Company-Specific Meaning
Tim raised an interesting question about whether there can really be a standard MCP server for an ERP product. Every company configures Acumatica differently. Modules vary. Customizations vary. GIs vary. Business rules definitely vary.
Sarat’s view was that a standard server can still work. Other platforms publish standard MCP servers, and there is nothing inherently unique about Acumatica that prevents the same model. The common server can expose the standard capabilities, while company-specific tailoring happens through the data structures and descriptions that each organization chooses to expose.
That distinction is especially clear between REST endpoints and GIs. The standard API can carry more of the generic description burden because Acumatica defines it. Generic Inquiries require more work from the customer because the customer created the meaning.
The “secret sauce” therefore does not need to live inside the open-source MCP code. Sarat was comfortable publishing the server because the company-specific knowledge is elsewhere. The generic plumbing can be shared. The descriptions and business context attached to a company’s own data remain specific to that organization.
AI Can Help Write the Descriptions That AI Needs
One of the more delightfully circular ideas was using Claude to help document the GIs for Claude. Sarat suggested taking a GI’s XML, giving it to Claude, and asking the model to draft the description.
But he did not recommend simply saying “describe this” and accepting the answer. The better prompt is to give the XML, explain what the GI is supposed to do, and ask the AI what additional questions it needs answered before writing the description. That turns the exercise into a collaboration between the person who understands the business purpose and the model that can inspect the technical structure.
Tim described this as a form of packaging the knowledge once so the AI can learn it faster later. The live agent may not have access to the original GI XML when it is answering a question over MCP, and having it rediscover the meaning every time would be slower anyway. A well-written description precomputes some of that understanding.
This is another place where human involvement remains essential. The AI can inspect the XML and produce language quickly. The person still has to explain why the GI exists, what the numbers mean, and where the traps are.
Real-World Guardrails Include Performance Limits Too
Security is not the only thing that can go wrong when an agent starts querying an ERP system. It can also hammer the application with perfectly authorized but badly shaped requests.
Sarat built rate limits and record caps into the server for that reason. At the time of the episode, the defaults included a maximum of three concurrent queries, 40 queries per minute, and 1,000 records returned per query. If a request needs more than 1,000 rows, the intended response is not to paginate endlessly but to narrow the question with a better filter.
The 50,000-item example makes the point. An agent should not casually decide to retrieve an entire item master just because it can. That wastes time, consumes resources, and can slow down Acumatica for everyone else.
Sarat also ran into normal developer “war stories” around OData. One specific warning was about GIs with required parameters. In his experience, exposing a GI with required parameters and failing to supply those parameters could return incorrect results rather than simply failing in an obvious way. His practical conclusion was to avoid exposing those parameterized GIs through this path.
Those details are easy to dismiss as implementation trivia until they cause a bad answer. An AI layer does not eliminate the quirks of the underlying ERP APIs. It can actually make them more important because the user no longer sees every technical step the agent is taking.
The Admin Experience Matters More Than It Sounds
Not every operating decision should require editing code. Sarat built a browser-based admin interface for the deployment so settings such as record limits and redaction patterns can be adjusted, and logs can be reviewed, without modifying the TypeScript project directly.
Tim was especially interested in that detail because it makes the project feel operational rather than experimental. A technically impressive proof of concept is one thing. A tool that an administrator can tune, inspect, and troubleshoot through a simple interface is much easier to imagine living inside a real company.
The repository also offers more than one deployment path. There's an easier deployment route for people who want to get running quickly and a more manual path for people who want to understand the pieces. Sarat’s own preference for understanding the architecture is visible throughout the project, even though AI handled much of the implementation work.
Open Source Is Part of the Feedback Loop
Sarat chose to make the Acumatica MCP server open source because the generic infrastructure was not a competitive advantage for his company. The real company-specific knowledge sits elsewhere, while the server itself can improve if other people find bugs, add features, test edge cases, or contribute better ideas.
That's the classic open-source bargain. The company gives something useful to the community and, in return, gets a larger group of people exercising the code and improving it. Sarat expects Acumatica itself may eventually provide overlapping MCP capabilities anyway, so keeping a generic connector private did not make much sense to him.
The community angle also fits his view of how quickly AI is changing. At a recent Acumatica user-group roundtable in Atlanta, he saw people at every level of adoption—from basic consumer use to advanced MCP work. The point was not that everyone should be doing the same thing. The useful part was seeing what other people are trying, what they trust, what they do not trust, and which platforms they are using.
Nobody really knows everything in this space. Sarat went so far as to say that someone claiming to be an expert in AI is probably overstating it. The field is moving too quickly. Community becomes a way to compare notes while everyone is still learning.
So Is This the Right Time to Connect AI to ERP?
Tim and Sarat ended up in an interesting middle position on AI adoption. They were both skeptical of the hype and the feeling that every business is already hopelessly behind. Enterprise technology usually has a long adoption curve, and companies have more important things to do than chase every shiny object.
At the same time, Sarat does not think waiting a couple of years is a safe strategy. His concern is the rate of acceleration. Capabilities are changing quickly enough that two years of waiting might represent a much larger practical gap than two years did in earlier technology cycles.
Tim used an apple-picking analogy that fits the moment pretty well. Pull an apple too early and it takes force because it's not ready. Wait too long and it falls off the tree and turns to mush. His sense was that AI has moved past the stage where businesses have to yank hard just to get something useful out of it.
That does not mean every company should unleash autonomous agents inside the ERP. The more practical path in this episode is much narrower: learn the tools personally, use them for research and document synthesis, understand where they fail, then move into governed business use cases where the ROI is understandable.
Read-only ERP analysis is a good example of that progression. It offers real utility without giving the agent permission to change transactions. It exposes the organization to the hard questions—authentication, access, privacy, semantics, performance, and auditability—before the risk gets much higher.
The Bigger Lesson for ERP Consultants
The takeaway is not that every Acumatica customer needs this exact MCP server. The more durable lesson is that connecting AI to ERP data is only the beginning of the work.
The connection solves reachability. OAuth, REST, OData, Cloudflare Workers, MCP tools, rate limits, and token storage are what allow the agent to reach the system safely enough to do something useful.
Governance solves permission. Users still need explicit access boundaries, consent, sensitive-data controls, and an audit trail. The agent should not receive broader ERP access merely because it happens to be good at natural language.
Descriptions solve meaning. The model needs to know why a GI exists, what a column represents, which limitations apply, and which questions a dataset can safely answer. Without that context, a perfectly functioning API can still produce a confidently wrong business answer.
Human judgment solves the part that remains. Someone still has to decide what should be exposed, what should stay private, whether an answer makes sense, and when the old-fashioned Acumatica screen is simply the faster tool.
That may be the least flashy conclusion possible, which is probably why it's useful. The future of AI in ERP is not just “chat with your data.” It's giving a powerful but imperfect machine controlled access to trustworthy data, enough business context to interpret it, and clear limits on what it's allowed to do.
The MCP server is the plumbing. The real work is deciding what should flow through it and teaching the AI what that data actually means.
