The Model Context Protocol (MCP) is not a marketing technology. It is infrastructure — a JSON-RPC 2.0 based open standard that defines how AI models connect to external systems, and which Anthropic donated to the Linux Foundation in December 2025 to ensure it stays a neutral, open standard. What makes MCP significant for MarTech developers is not the AI part; it is the capability negotiation layer that removes the one-off integration work that has characterized every AI-plus-MarTech implementation for the past two years.

If you have spent any time building against HubSpot, Klaviyo, GA4, or Salesforce APIs in the context of an AI-assisted workflow, you already understand the problem MCP is solving. Every model needs bespoke tool definitions, every integration is its own adapter, and nothing is reusable across clients. MCP standardizes that.

What the Protocol Actually Defines

MCP operates on a client-server model. The MCP server is an independent process that exposes capabilities to any compliant client. The MCP client is the AI host application (Claude, a custom agent runtime, or a workflow orchestrator like n8n) that initiates a stateful 1:1 connection, negotiates capabilities, and routes tool calls to the correct server.

Three primitive types carry all the functionality:

Tools are callable functions — the equivalent of REST endpoints for agent actions. A HubSpot MCP server exposes tools like create_contact, update_deal_stage, and search_contacts. The server returns a tools/list response containing each tool’s name, description, and JSON Schema input definition. The AI model uses the description to decide when to call the tool; the schema validates the parameters it passes.

Resources are read-only data exposed as addressable URIs. A GA4 MCP server might expose ga4://properties/{propertyId}/events as a resource containing recent event data. Resources follow a read model — they are context the agent can retrieve, not actions it can trigger.

Prompts are server-defined prompt templates that clients can retrieve and inject. Less common in MarTech implementations, but useful for standardizing how agents interact with domain-specific workflows.

The lifecycle: client connects → initialization handshake with version and capability negotiation → capability-specific requests → explicit termination. The protocol does not assume statefulness beyond the connection lifetime.

Transport: stdio vs. Streamable HTTP

The June 2025 spec update (2025-06-18) formalized two transport options and retired the previous HTTP+SSE transport:

stdio runs the MCP server as a local subprocess. The client communicates via stdin/stdout using newline-delimited JSON-RPC messages. Zero network configuration required. Correct for local development, CLI tool integrations, and single-client desktop agents.

Streamable HTTP handles remote and multi-client scenarios. The client POSTs JSON-RPC messages to an HTTP endpoint; the server can respond with a direct JSON response or open a server-sent event stream for long-running operations. The June 2025 update also classified MCP servers as OAuth Resource Servers, requiring clients to implement Resource Indicators (RFC 8707) — authentication is now part of the spec, not an afterthought.

For production MarTech integrations where multiple agent clients may connect to the same HubSpot or Salesforce MCP server, Streamable HTTP is the correct transport. stdio is adequate for single-tenant local integrations.

Building a MarTech MCP Server

The pattern below covers a minimal MCP server that exposes a Klaviyo profile enrichment tool. It uses the official @modelcontextprotocol/sdk Node.js package and Streamable HTTP transport.

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import { z } from "zod";
import express from "express";

const server = new McpServer({
  name: "klaviyo-mcp",
  version: "1.0.0",
});

// Tool: fetch a Klaviyo profile by email
server.tool(
  "get_profile_by_email",
  "Retrieve a Klaviyo subscriber profile and their suppression status by email address.",
  {
    email: z.string().email().describe("The subscriber's email address"),
  },
  async ({ email }) => {
    const revision = "2024-10-15";
    const response = await fetch(
      `https://a.klaviyo.com/api/profiles/?filter=equals(email,"${email}")`,
      {
        headers: {
          Authorization: `Klaviyo-API-Key ${process.env.KLAVIYO_API_KEY}`,
          revision,
          accept: "application/json",
        },
      }
    );

    if (!response.ok) {
      throw new Error(`Klaviyo API error: ${response.status}`);
    }

    const data = await response.json();
    const profile = data.data?.[0];

    if (!profile) {
      return {
        content: [{ type: "text", text: `No profile found for ${email}` }],
      };
    }

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify({
            id: profile.id,
            email: profile.attributes.email,
            subscriptions: profile.attributes.subscriptions,
            suppression_reason: profile.attributes.suppression_reason ?? null,
          }),
        },
      ],
    };
  }
);

// Express server + Streamable HTTP transport
const app = express();
app.use(express.json());

app.post("/mcp", async (req, res) => {
  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: undefined, // stateless mode
  });
  await server.connect(transport);
  await transport.handleRequest(req, res, req.body);
});

app.listen(3100, () => console.log("Klaviyo MCP server listening on :3100"));

Three things to get right in tool definitions: the description matters more than you think — the AI model uses it to decide when to call this tool versus another. The JSON Schema input definition controls validation. And error handling needs to throw explicitly; MCP clients expect exceptions to surface as error responses, not silent failures.

What Major Platforms Expose via MCP

As of mid-2026, the following platforms have published MCP servers or are in beta:

  • HubSpot — contact CRUD, deal management, company records, timeline events
  • Salesforce — CRM objects, campaign management, Pardot campaign records
  • Google Analytics (via Measurement Protocol + MCP wrapper) — property event schemas, reporting API reads
  • Klaviyo — profile management, segment reads, event creation, campaign status
  • Shopify — order management, product catalog, customer records
  • Zapier — NLA-based tool exposure for any connected Zap

None of the current MarTech MCP servers expose write access to financial records, billing, or user authentication operations. The scope is operational — the data and actions a marketing agent legitimately needs.

Where MCP Breaks in MarTech Integrations

Rate limit collisions. A HubSpot MCP server shared across multiple agent clients shares the portal’s rate limit. If you have three agents calling search_contacts concurrently, they are consuming from the same 100 requests/10 seconds budget. Build server-side rate limiting into the MCP server, not just in the client.

Tool description drift. Tool descriptions are what the model uses for routing decisions. If create_contact and upsert_contact have similar descriptions, the model will pick incorrectly in ambiguous situations. Be explicit about when each tool is appropriate — include the conditions under which it should not be used.

Stateless HTTP and session context. Streamable HTTP in stateless mode (as shown above) means each request carries no memory of previous requests. For multi-step agent tasks — search contacts, then update deal stage, then create a task — the agent runtime must track state, not the MCP server. If your server needs session state, implement a session ID generator and manage session maps.

Pagination. Most MarTech APIs paginate large result sets. MCP tools that return the first page of results without exposing the pagination cursor leave the agent unable to retrieve complete data. Either paginate transparently server-side (acceptable for small to medium datasets) or expose a cursor parameter and let the agent manage pagination explicitly.

The integrations that survive production are not the ones with the most tools. They are the ones where the tool surface area matches what the agent actually needs, rate limits are managed server-side, and error messages are specific enough for the agent to handle failures without human intervention.

Frequently Asked Questions

What is Model Context Protocol, and why does it matter for marketing engineering specifically?

MCP is a JSON-RPC 2.0 open standard, donated by Anthropic to the Linux Foundation in December 2025, that lets AI models discover and call tools exposed by an external server through a standardized capability-negotiation layer. For MarTech teams, it replaces the bespoke, non-reusable tool definitions every prior AI-plus-CRM integration required with a single reusable protocol across HubSpot, Klaviyo, GA4, and Salesforce.

Do I need MCP if I already have a working API integration with HubSpot or Klaviyo?

Not urgently, but the direction is clear: Adobe and Salesforce have both moved to add native MCP support, which means enterprise platforms your clients run on will increasingly expect an MCP-speaking integration layer. Building your existing HubSpot or Klaviyo integration as an MCP server now means the same tool-discovery pattern carries forward when a new platform ships its own server.

Is it safe to give an AI agent write access to a CRM through MCP?

Only with deliberate scoping. MCP itself doesn’t secure the connection — you handle auth at the HTTP layer and enforce a field-level allowlist in the tool handler (e.g., update_deal_stage should not also permit arbitrary property writes). None of the major published MarTech MCP servers expose write access to financial records or billing, which is the model to follow for your own scope.

Should a MarTech MCP server use stdio or Streamable HTTP transport?

Use stdio for local development, CLI tools, or a single-tenant desktop agent — it requires zero network configuration. Use Streamable HTTP for production, where multiple agent clients connect to the same HubSpot or Salesforce integration concurrently; the June 2025 spec update also classified MCP servers as OAuth Resource Servers, so Streamable HTTP deployments need Resource Indicators (RFC 8707) implemented for authentication.

Which marketing platforms already have published MCP servers?

As of mid-2026, HubSpot (contact and deal CRUD, timeline events), Salesforce (CRM objects, Pardot campaigns), Klaviyo (profiles, segments, events), Shopify (orders, catalog, customers), and Zapier (NLA-based tool exposure across connected Zaps) have shipped or beta MCP servers, with a Google Analytics wrapper available via the Measurement Protocol. Coverage is operational — none currently expose billing or authentication write access.