MCP vs API: which layer does the work?
An engineer wants to put an MCP server in front of Salesforce. You already have Salesforce API access, and it works. The question underneath is MCP vs API: whether this is a new thing to run, or a second route to the same place.
It is a second route. The app's API still does the work. MCP is the layer in front of it that lets an AI client find a tool, read its input schema, sign in and make the call.
MCP (Model Context Protocol) is the standard way an AI assistant calls tools in other apps.
That boundary holds up during a review. No MCP server adds a capability the API did not already have. If the API cannot refund a charge, nothing sitting in front of it can either.
What does MCP add that a REST API does not?
Four things: a discovery method, machine-readable schemas, one sign-in pattern and one wire format. A REST API has all four in some form. MCP makes them the same shape across every server a client meets. That is what lets a client the vendor has never seen connect without a human writing config.
The wire format is JSON-RPC 2.0, a lightweight remote procedure call protocol encoded in JSON (jsonrpc.org, checked November 2026). The methods and transports are set out in the MCP specification (checked November 2026). Elaichi serves MCP over the Streamable HTTP transport at POST /mcp, as JSON-RPC 2.0 messages. The endpoint is stateless, keeps no session and accepts POST only. A GET or DELETE answers HTTP 405 with an Allow: POST header. If you want the single request laid out byte by byte, that is covered in the walkthrough of one JSON-RPC call.
Discovery is where the daily difference shows. A client calls tools/list and receives names, descriptions, input schemas and annotations, as set out in the specification's tools section (checked November 2026). Elaichi's endpoint speaks four MCP revisions, the newest being 2026-07-28, so an older client still completes the handshake.
Sign-in is the other half, and it is the half IT lives with. Against a plain REST API, each client invents its own answer: a key in a header, a key in a dotfile, a key in a repository. Over HTTP, the MCP specification's answer is OAuth, and the path is discoverable, as the specification's authorization section sets out (checked November 2026). Elaichi's 401 carries WWW-Authenticate: Bearer resource_metadata="https://api.elaichi.ai/.well-known/oauth-protected-resource", which is how a client finds the authorization server. The client then registers itself. Dynamic client registration (RFC 7591), at POST https://api.elaichi.ai/oauth/register, is what Elaichi accepts, and it is the only way an OAuth client for its MCP endpoint is created. The specification now prefers client ID metadata documents instead; Elaichi's authorization server does not advertise support for them, and a client_id has to be one Elaichi issued at registration. Registration is open and needs no Elaichi credential, so nobody looks up a client ID or pastes a secret. PKCE is mandatory and S256 is the only method accepted. The full sequence, from challenge to token, is in how MCP authorization works end to end.
What MCP does not replace
MCP does not replace the app's permission model, its rate limits or its error semantics. Those stay exactly where they were, and they still decide the outcome of every call.
Permissions first. Every call through an Elaichi connection fetches that connection's own stored credentials. So the call reaches the app as the account that signed in there. A connection someone shares runs on its owner's account, not the caller's. Whatever Salesforce or Notion would refuse that account, it still refuses. MCP moves no boundary inside the app.
Rate limits next. An upstream 429 is still an upstream 429. Elaichi's caller-facing message for one reads "Notion asked Elaichi to slow down. Try again in a minute." There is a second limit in front of that: POST /mcp allows 120 requests per 60 seconds per connected app's authorization, answering HTTP 429 with Retry-After: 60 past it.
Result size is the third thing people assume MCP fixes. It does not. Elaichi caps tool results value by value before they leave: at most 32,000 characters per string and the first 200 items of an array. Over MCP a result is also held to 30,000 characters of JSON in all, with long text shortened and the cut flagged. That is a sensible budget for a model's context window. It is not a bulk export path.
Prompt injection is the fourth, and it is the claim most often made for a server in front. Elaichi's MCP endpoint has no prompt-injection defense of its own. Nothing on the POST /mcp path scans tool results for injected instructions or second-guesses a call. The endpoint receives a tool name and arguments, never the person's typed request. That defense belongs to the client, and what a poisoned tool can and cannot reach is covered in the tool poisoning post. Elaichi's tool annotations are hints for clients, not gates; the server's own scope and restriction checks are the gate.
When is calling the API directly the better choice?
When no model is involved, or when the job runs unattended, call the API. MCP earns its keep when a language model has to choose the call. It is overhead when the caller is a script that already knows.
Unattended work is the clearest case. Elaichi's MCP sign-in supports only the authorization-code grant with PKCE, plus refresh. There is no device-code grant and no client-credentials grant, so a new grant always needs a person to approve a consent screen in a browser. A nightly reconciliation job should therefore talk to the app's API with the app's own credential. If you want the scheduled run inside Elaichi instead, a workflow that starts on a schedule comes with the Black plan. Each run acts as the workflow's owner, with that owner's access and restrictions applied while it runs. That is described in the workflows post.
Bulk reads are the second case. Paging a million rows through a chat model costs tokens, time and patience, and the result caps above will truncate it anyway. Export it with the API.
Fixed, deterministic steps are the third. If the sequence never varies, a script is cheaper to write, cheaper to test and easier to debug than a model that re-derives it every morning. And if a single team uses a single app, with no cross-app question to answer and no audit requirement yet, you may not need a layer in front at all. The case for waiting is a real one, and worth reading before you buy.
How Elaichi's connectors call each app's API behind one address
Elaichi is the MCP server, and its connectors make the ordinary API calls to each app behind it. The address is https://api.elaichi.ai/mcp, the same string for every organization. Which organization, which person and which tools a client reaches comes from the OAuth grant behind its token, not from the URL.
The catalog holds two kinds of connector, and the difference matters for who fixes a broken tool. Most are connectors Elaichi authors and runs itself, calling the app's API directly. The rest are native MCP connectors, where the vendor builds and runs its own MCP server and Elaichi handles sign-in, access and audit in front of it. A team on Gold can also bring its own remote MCP server under the same rules. The current list, 650+ connectors, is at the connector catalog.
Credentials do not sit with the AI client. A separate credential service holds each connected account's secrets in encrypted form, at rest under AES-256-GCM. Elaichi fetches them into memory only for the call that needs them. The client holds an Elaichi token and nothing else, which is the shape where tokens live for AI agents goes through in detail.
Discovery is adapted to the size of a real catalog. In Elaichi, connected tools are never listed one by one, however few there are. A model finds one with search_tools and runs it with read_tool for a read or execute_tool for anything. Search is lexical, a BM25F ranking over tool names, connector labels and descriptions, with no embeddings. That is why a query of concrete tool words beats a sentence.
Elaichi works out each connected tool's tier from the call it really makes: an HTTP DELETE counts as destructive whatever the method is called. Every call that reaches execution writes an audit row naming the person, the connector, the connection and the MCP client, with the surface recorded as mcp.
What neither layer decides: who may call which tool
Neither the API nor MCP answers the question your security reviewer will ask. The API knows what an account can do. MCP standardizes how a client reaches it, and its authorization section covers how a client gets a token, not which employee may run which tool (the MCP specification on authorization, checked November 2026). That is a third thing, and it has to be configured somewhere.
Over MCP, the consent screen is the first control. Elaichi's authorization server has six scopes: four that decide what a client can do and two identity scopes that only unlock /oauth/userinfo. The trap is assuming one of them means read-only. The "Use your connected apps" scope, mcp:tools, runs every tier of connected tool, deletes included. "Delete things" covers Elaichi's own deletes, not the connected app's. To hold a client to reads, pick toolboxes of read tools at consent, or write a restriction.
Restrictions are the second control, and they are written in Elaichi rather than in the client. A rule names whole connectors or single tools, and it targets a role or one member. In Elaichi, a change takes effect within about two minutes. The shape of those rules is laid out in the governance overview, and what they look like afterwards in reading the audit log.
If you are weighing whether to run a server yourself or put one in front of several, the server and gateway comparison sets the two request paths side by side. If the decision is already made and you want the first team to set up, start from the use cases and pick the one that matches the app your people are already pasting data into.