Use direct API integration when your application owns the agent runtime and its tool connections. Add MCP when the AI hosts you intend to support can consume a shared tool interface and that reuse justifies maintaining the adapter. An MCP server can call your existing REST API, so adopting MCP does not require replacing it.
A working CRM API does not become obsolete because a team wants an AI assistant. The decision is where to translate the assistant’s requested operation into the business system’s contract, and how much of that translation the next client can reuse.
A team supporting one internal application has a different maintenance problem from a software vendor supporting several customer-selected AI hosts. Count those consumers before commissioning another integration service.
REST endpoints and MCP tools sit at different boundaries
A REST API exposes a service to software clients through HTTP resources and operations. MCP standardises an exchange between an AI application and a server that supplies tools or context. Those boundaries can coexist in the same request path.
The MCP architecture overview describes hosts creating clients that connect to MCP servers. Servers can expose tools, resources and prompts. MCP focuses on context exchange; it does not dictate how the host uses a model or manages that context.
For tools specifically, the MCP specification defines discovery through tools/list and invocation through tools/call. A tool definition describes the operation and its input schema. The server implementation still has to perform the work, such as calling a CRM endpoint.
Direct function calling provides another route. OpenAI’s function-calling guide describes the model returning a call, the application executing code with its arguments, and the application returning a tool result. That code can call the same CRM API without an MCP server in between.
MCP and function calling can also appear in one system: a host discovers MCP tools and makes their capabilities available to its model. They are not mutually exclusive purchases.
Keep the business operation reusable before adding clients
Consider a hypothetical consultancy that wants to create proposal drafts from approved opportunities. Its existing application already checks whether an opportunity is eligible and creates the draft in its document system.
A useful design keeps that operation behind one service contract:
Existing application --------------------> Proposal service
Owned agent -> function-call dispatcher --> Proposal service
Compatible AI host -> MCP adapter -------> Proposal service
The diagram shows alternative consumers, not a requirement to build every route. The proposal service can expose a REST endpoint; an adapter inside the same deployment can also call the underlying service code directly.
Eligibility rules belong in the shared business implementation. If the MCP adapter reimplements those rules while the existing application keeps its own copy, the team has created another place for policy to diverge. Standardising the tool exchange will not reconcile those copies.
Define an operation that corresponds to the work people recognise, such as create_proposal_draft. Its implementation can coordinate several lower-level requests. Exposing every API endpoint as a model tool would leave the agent to reconstruct that coordination, increasing the behaviour you must test.
This boundary is an architectural recommendation, not an MCP requirement. It also helps a direct function integration. The integration bottleneck guide covers the separate problem of making system calls complete reliably.
Choose against the clients you will actually support
| Deployment situation | Starting route | Evidence to obtain before expanding |
|---|---|---|
| One internal agent in an application your team controls | Direct function tools backed by the existing service | Show the specific host requirement that an MCP adapter would satisfy. |
| Several intended AI hosts support the required MCP features | Shared MCP adapter over the business service | Connect the named hosts and record the setup or custom code each still requires. |
| A selected host supports MCP but offers no suitable custom API integration route | MCP adapter, subject to that host’s restrictions | Prove the required operation works in that host, including its authentication path. |
| A fixed event already determines the next business action | Existing API workflow | Establish whether model judgement adds value before introducing an agent interface. |
The last case is a different decision. If an approved status change always creates the same document, an ordinary workflow can call the service directly. The agents versus workflow automation comparison helps locate the judgement that warrants involving a model.
Host support must be checked at the feature and protocol-version level. A claim that a product “supports MCP” does not establish that it supports your server’s transport or the interaction your workflow requires. Include the actual intended client in the acceptance demonstration.
Authentication to the adapter leaves another boundary to resolve
A successful login to an MCP server does not establish which identity the downstream CRM will receive.
The MCP authorisation specification defines transport-level access to restricted MCP servers, with an authorisation flow for HTTP transports. It distinguishes that flow from credentials supplied through the environment for stdio implementations.
Your adapter still needs a deliberate downstream identity design. It can use an appropriately scoped service identity or a supported delegated-user mechanism, depending on the destination and deployment. Record which one applies and demonstrate its effect with the intended user. Do not assume that a user signing into the host automatically inherits the correct CRM permissions.
The existing MCP permissions article addresses those access and review decisions in more depth. They apply to direct integrations too; choosing a protocol cannot settle them on its own.
Make a second client reveal the remaining work
Before funding a broad conversion of endpoints into MCP tools, run a bounded exercise on one non-destructive operation. For the proposal example, use synthetic opportunity data and a draft-only destination.
First, agree what the operation must return. Include an ineligible opportunity so a client cannot pass by creating a document for every request. Establish the result through the existing route, then connect a second intended client to the same business implementation.
Record the changes required to make that second client work:
| Change observed | What it tells the buyer |
|---|---|
| Host configuration and credentials, with no business-service changes | The adapter is providing reuse for this operation and these clients. |
| A different result transformation or tool description for each host | There is residual client-specific maintenance to budget. |
| Duplicated eligibility logic in the new adapter | The business boundary needs correction before extending the pattern. |
| Unsupported transport or an incomplete login flow | Compatibility remains unproven despite the protocol label. |
| Correct tool discovery followed by an incorrect proposal result | Interface compatibility has passed a narrower test than workflow correctness. |
Keep the configuration record and changed-file diff with the acceptance evidence. They make the maintenance discussion concrete. This is a proposed exercise, not a benchmark performed against particular hosts, and it establishes no general latency or cost advantage.
Model Operator is a Dubai-based AI product studio led by Alexander Chrisostomou. Through AI Initiative Consulting, Alexander helps teams scope consequential workflows and choose the implementation route. For an integration decision, bring the existing API contract and the intended host list to a Model Operator build conversation. Resolve the shared business operation before commissioning adapters around it.