Skip to content
ConsultEvo

What Is Model Context Protocol (MCP)? Architecture and Uses

Model Context Protocol (MCP) is an open protocol that lets compatible AI applications discover and use capabilities exposed by external servers, including tools, resources, and prompts. It can help an AI retrieve business context or request an action, but it does not decide whether that action is permitted by your organization.

For example, a user asks an AI client to find a project update. The client uses a permitted MCP tool to retrieve the update, and the AI summarizes the returned data. That is a read-oriented workflow: no project record changes. Anthropic introduced and open-sourced MCP on November 25, 2024. The protocol and its implementations have since evolved, so the protocol generation, client, SDK, and transport matter. The original announcement explains the launch, while the official MCP documentation is the better starting point for current specifications.

This article focuses on the practical decision: when MCP is useful, when a direct API or conventional automation is clearer, and which controls must be designed around any consequential tool call.

What is Model Context Protocol (MCP)?

MCP standardizes parts of the exchange between an AI application and an external server. The server can offer data for context or operations that a compatible client can call. A model may interpret a user request and select a suitable capability, but the surrounding application and destination system handle the actual interaction. Business rules that determine whether an action is allowed still need to be implemented and enforced by the relevant systems.

A limited analogy is USB-C: a shared connection standard can make it easier for compatible components to work together. MCP is not literally a connector, an API gateway, or “HTTP for AI.” It has its own messages, capabilities, transports, authorization behavior, and version rules. HTTP may be used as a transport by an implementation, but it does not define MCP itself.

How MCP components fit together, and why version matters

The familiar host-client-server model remains useful when reading older MCP material. The host is the AI application, such as an assistant, IDE, or developer tool. Its client manages communication with an MCP server. The server exposes capabilities to that client, potentially by connecting to an underlying service or API.

  • Tools are callable operations, such as searching a system, creating a ticket, or updating a record.
  • Resources provide data that a client can use as context, such as a document, file, or structured record.
  • Prompts are reusable prompt templates where the server and client support them.

Clients and servers can support different subsets of these capabilities. The label “MCP-compatible” does not tell you which features, protocol generation, authorization flow, or transport a particular pairing supports.

The official July 28, 2026 specification overview describes a stateless protocol core, request routing, cacheable discovery results, authorization hardening, and an extensions framework. Application-level state may still be needed, but that is different from assuming a protocol session persists across requests. Transport is also a separate compatibility question. Streamable HTTP is a current transport, but support varies by client and service.

The TypeScript SDK documentation and Python SDK documentation describe their respective implementations. Neither guarantees identical behavior across all clients. Before building, record the protocol version, client and SDK versions, server, supported capabilities, and transport. Test that exact combination before relying on it in production.

When to choose MCP, a direct API, or conventional automation

MCP does not replace APIs. An MCP server may call an API underneath, while MCP provides a standardized way for a compatible AI client to discover and invoke capabilities. Choose the operating pattern based on how much judgment or variation the task needs.

Operating choice Best fit Tradeoff
Direct API The endpoint, payload, sequence, and validation rules are known Requires an integration designed for the specific service
Conventional automation A fixed trigger and repeatable action sequence are sufficient Less suited to choosing different actions from variable intent
MCP A compatible AI client must select among permitted capabilities based on a request Requires compatibility and explicit controls around consequential actions

For a mixed process, let AI interpret unstructured input or suggest a tool, then use deterministic rules to validate the proposed action. If the endpoint, fields, and sequence are already known, a direct API or fixed automation is often the clearer choice. Zapier’s comparison of MCP and APIs provides additional context, but it is editorial guidance rather than a protocol specification.

Use MCP when an AI needs to choose among permitted capabilities. Use an API or fixed automation when the sequence and rules are already known.

Three practical patterns for MCP-enabled work

The examples below separate the AI task from the control that determines whether an action can proceed. The first is based on a documented Zapier MCP example. The CRM and outbound-email patterns are proposed editorial designs, not vendor-provided templates.

Trigger AI job and output Validation and destination Fallback
Support email Summarize the email and propose Jira fields plus a Slack destination Check required fields, project, channel, and connected-account permissions; create the Jira issue, then post its link to Slack Workflow owner reconciles a successful Jira creation followed by a failed Slack post
Form or inbound message with a stable event ID Extract candidate CRM values and a source reference; do not authorize the update Resolve exactly one record, validate field types and allowed values, apply overwrite policy, then update the CRM after approval where required CRM operations reviews ambiguous matches, rejected values, duplicate attempts, or failed writes
User requests an outbound email Draft the recipient, subject, body, and source reference; do not send Validate recipient and content rules, preserve the reviewed payload, obtain approval, then use a separate send action Communications or workflow owner investigates rejected drafts or uncertain delivery before retrying

A practical tool-use pattern: source, bounded AI task, action, exception

Zapier documents a sequential example in which an email is summarized, a Jira issue is created, and the issue link is posted to Slack. It demonstrates multiple tool calls, not a single atomic transaction. It does not establish built-in rollback, idempotency, or automatic recovery if a later step fails.

  1. Capture the source. Retain the source email ID and relevant content. The support operations or workflow owner should be identifiable before execution.
  2. Prepare candidate fields. AI returns a concise summary, Jira project, issue title, description, and notification destination. Its role is to structure the request, not to decide that every proposed action is authorized.
  3. Validate the request. Confirm required Jira fields, the intended project and Slack channel, and the permissions of the connected accounts. Route missing or ambiguous inputs to the workflow owner.
  4. Execute in order. Create the Jira issue, capture the returned issue link, and then post that link to Slack. Record the source ID, action results, and final status.
  5. Reconcile partial completion. If Jira succeeds but Slack fails, assign the incomplete notification to the named owner. The owner decides whether retrying is safe and records the resolution.
01Identify the source eventStore the message ID and assign the owner responsible for unclear requests.
02Produce candidate fieldsAI returns the summary, Jira fields, and proposed Slack destination in a structured result.
03Check fields and destinationsConfirm required values, project and channel selection, and connected-account permissions.
04Create and notifySave the Jira result and use its returned link in the Slack action.
05Reconcile incomplete executionIf notification fails, the workflow owner decides on retry or manual completion and records the outcome.

Useful pilot measures include completed task rate, exception rate, duplicate rate, and human review burden. Define the event grain before measuring. A single inbound email or form submission is not the same record as a prompt run, tool-call attempt, or monthly aggregate.

Designing a controlled CRM write-back

The following is a hypothetical editorial design, not a vendor-provided MCP template. Treat one processing record as one inbound source event, such as a form submission or email. Keep that event distinct from a prompt run or individual tool call, which may be retried while processing the same event.

For example, a form event with a stable ID arrives with a request to change a lifecycle field. AI extracts candidate values and a source reference. Deterministic logic resolves exactly one CRM record, checks field types and allowed values, and applies the organization’s overwrite policy. Ambiguous matches or sensitive changes go to a human reviewer. The CRM remains the system of record, while a processing record preserves the link from source event to CRM record and tool result.

{
  "source_event_id": "form-84721",
  "record_resolution": {
    "candidate_record_id": "crm-123",
    "match_method": "exact_verified_email",
    "ambiguity_flag": false
  },
  "proposed_update": {
    "field_name": "lifecycle_stage",
    "proposed_value": "Customer",
    "source_reference": "submission-84721, field: request"
  },
  "governance": {
    "approval_required": true,
    "prompt_run_id": "run-2026-001"
  }
}

This illustrative contract describes an event-level processing record. A separate tool-call record should identify each invocation and retry. A reported daily summary should be stored at aggregate grain rather than substituted for the underlying event records.

Use the AI proposal as typed input to deterministic checks, not as authorization to write. Verify that exactly one record matches, validate the field type and permitted value, and reject a change that violates the overwrite policy. Store the source event ID, source reference, destination record ID, approval result where applicable, and tool result.

Deduplication decision point

A stable source event ID identifies the work item. A prompt-run or tool-call ID identifies an attempt. A lookup followed by create can still race when two workers process the same event. Where supported, enforce a database-level unique key and use a transactional upsert. If the destination lacks atomic upsert, use a durable processing ledger or idempotency service before issuing the external write.

For an event-level key, use a stable combination such as source system plus source event ID. Do not use a daily date, model name, or brand as a substitute for event identity. For CRM processes that need clearer ownership, matching rules, and data-quality controls, see CRM systems consulting.

Security and governance: what MCP does not guarantee

Protocol adoption does not automatically provide least privilege, approval, PII filtering, retries, rollback, idempotency, or end-to-end auditability. Assess the full control chain: server identity and implementation, client behavior, configured tool scope, connected-account permissions, destination-app permissions, and operational ownership.

Scope actions by consequence. Read-only retrieval is different from staging a proposed change, and both differ from sending an external message or changing a sensitive record. For high-impact writes, use an explicit approval or deterministic gate. Record the approver, exact approved payload, execution result, and exception status so review can distinguish what was authorized from what was actually sent.

For outbound email, keep drafting separate from sending. AI prepares a recipient, subject, body, and source reference. Deterministic checks validate the recipient and applicable content rules. A human approves the final payload, and a separate send action uses that approved version. If delivery status is uncertain, the communications or workflow owner investigates before retrying rather than risking a duplicate message.

Getting started with Zapier MCP: verify scope, client, and usage

Zapier’s official quickstart describes this setup sequence: create an MCP server, select actions, connect the relevant app accounts, connect a compatible AI client, test, and run an action. One server can expose multiple configured actions, but that does not enable every Zapier app or action or authorize every destination. Usable scope depends on selected tools, connected accounts, client support, plan, and destination-app permissions.

Zapier’s current help documentation states that Zapier MCP supports Streamable HTTP and not SSE. As of November 18, 2026, its Zapier MCP overview states 9,000+ apps and 40,000+ actions. Other Zapier pages publish different catalog counts, so treat these figures as page-specific and changeable. The usage guidance accessed November 18, 2026 says each successful tool call consumes two tasks, successful test calls count, and failed tool calls do not consume tasks. Verify current product, plan, sharing, client, transport, and billing details before rollout.

Check before enabling actions
  • Confirm the client, protocol generation, SDK behavior, and transport work together.
  • Expose only the actions needed for the defined job and confirm their destination permissions.
  • Test required fields, representative inputs, and failure behavior.
  • Check current task accounting and plan implications, including successful test calls.
  • Name the person who owns failed, uncertain, or partially completed actions.

For teams evaluating setup across systems, Zapier automation consulting is relevant to reviewing action scope and the operating process before launch.

A decision rule for adopting MCP

Start with the job, not the protocol. Define the trigger, inputs, system of record, event grain, and exception owner. If the action sequence is fixed, use a direct API or conventional automation. If a compatible AI client must choose among permitted capabilities in response to variable intent, MCP may fit. For consequential writes, validate the proposed action deterministically and keep it attributable to its source.

Before adopting MCP, ask: Is the task defined? Is the system of record clear? Does AI need to choose among tools? Are writes validated and attributable? Is there an owner for exceptions? If any answer is unclear, resolve the process gap before exposing more capabilities. Teams defining an agent role and its operating boundaries can explore AI agent systems.

Measure completed tasks, exception rate, duplicate rate, and review burden at the correct grain. MCP can standardize interaction, but sound outcomes still depend on the process, permissions, validation, and ownership built around it.