MCP Server: What It Is, How It Works, and Why Marketing Analysts Should Care in 2026

By early 2026, over 10,000 MCP servers exist. Most marketing analysts haven't heard of them yet.

Model Context Protocol (MCP) servers act as connectors between AI agents and data sources. They give large language models secure, structured access to databases, APIs, and internal tools. Without an MCP server, your AI agent can't read your campaign data, access your CRM, or pull metrics from your ad platforms. With one, it can answer questions like "Which campaigns drove the most pipeline last quarter?" in seconds.

This guide explains what MCP servers are, how they work, why they matter for marketing analytics, and how to evaluate whether your team needs one. If you're responsible for data infrastructure or exploring AI-powered reporting, this is where MCP fits into your stack.

Key Takeaways

✓ MCP servers bridge the gap between AI agents and data sources — they translate requests from natural language into API calls, database queries, or tool commands.

✓ Anthropic launched the Model Context Protocol in November 2024 to standardize how AI systems access external data.

✓ Marketing analysts use MCP servers to connect AI agents to advertising platforms, CRMs, warehouses, and BI tools without writing custom code.

✓ MCP servers handle authentication, rate limiting, schema mapping, and error handling so AI agents can retrieve data reliably.

✓ The protocol separates three layers: the AI client (Claude, ChatGPT), the MCP server (connector logic), and the resource (your database or API).

✓ Teams building MCP servers need to manage security, versioning, and compliance — most marketing platforms don't expose MCP endpoints yet.

✓ Pre-built MCP servers exist for common tools like Slack, GitHub, and Google Drive, but marketing-specific connectors for Google Ads, Meta, or Salesforce are still rare.

✓ Marketing data platforms like Improvado now support MCP integration, allowing AI agents to query unified marketing datasets without building custom servers.

What Is an MCP Server?

An MCP server is a middleware layer that connects AI agents to data sources. It receives requests from an AI client, translates them into API calls or database queries, fetches the data, and returns it in a format the agent can understand.

The Model Context Protocol (MCP) is an open standard developed by Anthropic. It defines how AI systems communicate with external tools and data repositories. Before MCP, every AI integration required custom code. If you wanted Claude to read your Salesforce data, you had to build a one-off connector. If you switched to a different AI model, you rewrote the integration.

MCP standardizes this process. The protocol separates three components:

• The client — the AI agent or assistant (Claude, GPT, Gemini)

• The server — the connector that handles authentication, data retrieval, and formatting

• The resource — your database, API, or internal tool

The MCP server sits between the client and the resource. It handles the technical complexity so the AI agent doesn't need to know how your database is structured or which API endpoints to call.

How MCP Servers Work

Here's what happens when an AI agent queries data through an MCP server:

• A marketing analyst asks Claude: "What was my cost per lead from Google Ads last week?"

• Claude sends a structured request to the MCP server using the Model Context Protocol.

• The MCP server authenticates with the Google Ads API, fetches cost and conversion data, and calculates the metric.

• The server returns the result to Claude in a standardized format.

• Claude presents the answer to the analyst in natural language.

The MCP server handles authentication tokens, rate limits, schema mapping, and error handling. If the API returns an error, the server translates it into a message the AI agent can relay to the user.

This architecture has one major advantage: you write the connector logic once, and any MCP-compatible AI client can use it. If you build an MCP server for your marketing data warehouse, Claude, GPT, and future models can all query it without custom integration work.

MCP vs. API Wrappers

Marketing teams have used API wrappers for years. Tools like Zapier, Fivetran, and custom scripts connect platforms and move data. MCP servers serve a different purpose.

API wrappers move data. MCP servers let AI agents ask questions about data.

If you need to sync Google Ads spend into your data warehouse every night, you use an API wrapper. If you need Claude to answer "Which campaigns are over budget this week?" without preloading the data, you use an MCP server.

Why Marketing Analysts Should Care About MCP Servers

Marketing analysts spend hours answering the same questions every week. "How much did we spend on Meta last month?" "Which landing pages have the highest conversion rate?" "What's our CAC by channel?"

These queries require pulling data from multiple platforms, joining tables, and building dashboards. Even with a data warehouse, you need to know SQL or rely on a BI tool. Every new question means writing a new query or updating a dashboard.

MCP servers let AI agents handle this work. Instead of writing SQL, you ask Claude a question. Instead of building a dashboard, you describe what you need. The AI agent queries your data through an MCP server and returns the answer.

This doesn't replace data infrastructure. You still need clean, centralized data. But it changes how analysts interact with that data. The interface shifts from dashboards and queries to conversation.

When MCP Matters for Marketing Teams

MCP servers make sense in three scenarios:

• You have centralized marketing data — your campaign spend, conversions, and attribution data sit in a warehouse or unified platform.

• You answer repetitive questions — executives, account managers, or other teams ask for the same metrics every week.

• You want AI agents to access data securely — you need governance, permission controls, and audit logs when AI queries your systems.

If your marketing data is still siloed across platforms, MCP won't help yet. The protocol assumes you have structured, queryable data. If analysts manually export CSVs from ad platforms every week, you need data integration first.

But if you've already invested in a data warehouse, ETL pipeline, or marketing analytics platform, MCP servers let you layer conversational AI on top of that infrastructure.

What MCP Doesn't Solve

MCP servers are connectors, not data platforms. They don't fix data quality issues, normalize schemas, or transform raw API responses into usable metrics.

If your Google Ads and Meta data use different naming conventions for campaigns, the MCP server won't reconcile them. If your CRM has duplicate records, the AI agent will surface the duplicates. If your data warehouse has no attribution model, the AI can't calculate contribution.

MCP gives AI agents access to data. It doesn't clean, transform, or govern that data. You still need a layer that handles those tasks before the MCP server touches it.

How to Build or Deploy an MCP Server

Building an MCP server requires writing connector logic that conforms to the Model Context Protocol specification. The server needs to handle three tasks: authentication, data retrieval, and response formatting.

Anthropic provides SDKs in Python, TypeScript, and Go. Most marketing teams use Python because it integrates well with data infrastructure.

Architecture Requirements

An MCP server needs:

• A transport layer — handles communication between the AI client and the server (usually HTTP or WebSockets)

• Authentication logic — manages API keys, OAuth tokens, or database credentials

• Schema definitions — tells the AI client what data sources and operations are available

• Query execution — translates AI requests into database queries or API calls

• Error handling — catches API failures, rate limits, and invalid queries

The server exposes a set of "tools" to the AI client. Each tool represents an action the agent can take: query a table, call an API, read a file. The AI decides which tools to use based on the user's question.

Example: MCP Flow for Marketing Data

A marketing analyst asks Claude: "Show me the top five campaigns by ROAS last quarter."

• Claude identifies that this requires campaign performance data.

• Claude calls the query_campaigns tool exposed by the MCP server.

• The MCP server authenticates with the data warehouse using stored credentials.

• The server runs a SQL query: SELECT campaign_name, SUM(revenue) / SUM(spend) AS roas FROM campaigns WHERE date >= '2025-10-01' GROUP BY campaign_name ORDER BY roas DESC LIMIT 5

• The server returns the results to Claude in JSON format.

• Claude formats the data into a readable table and presents it to the analyst.

This requires the MCP server to know your database schema, have the right permissions, and handle errors if the query fails.

Pre-Built vs. Custom MCP Servers

From launch in November 2024 to early 2026, the MCP ecosystem grew to over 10,000 servers. Most are open-source connectors for common tools: Slack, Google Drive, GitHub, PostgreSQL.

Marketing-specific MCP servers are rarer. Google Ads, Meta Ads, Salesforce, and HubSpot don't provide official MCP endpoints. If you want Claude to query your ad platforms directly, you need to build a custom server or use a platform that exposes an MCP interface.

Building a custom MCP server takes time. You need to:

• Write connector logic for each data source

• Handle authentication and token refresh

• Map platform schemas to a unified structure

• Test error handling and rate limits

• Deploy and maintain the server

Most marketing teams lack the engineering resources for this. The alternative is using a platform that already aggregates your data and exposes an MCP-compatible interface.

Improvado review

“Improvado allows us to have all information in one place for quick action. We can see at a glance if we're on target with spending or if changes are needed—without having to dig into each platform individually.”

Kasia Pasich

Data Analyst

MCP Servers for Marketing Data Platforms

Marketing data platforms sit between raw data sources and analytics tools. They connect to ad platforms, CRMs, and analytics systems, normalize the data, and load it into a warehouse or BI tool.

When these platforms expose an MCP interface, AI agents can query the unified dataset without building custom connectors for each source.

Here's what that looks like in practice:

• A marketing data platform connects to Google Ads, Meta, LinkedIn, Salesforce, and your data warehouse.

• The platform normalizes campaign names, maps metrics to a common schema, and applies attribution models.

• The platform exposes an MCP server that AI agents can query.

• An analyst asks Claude: "Which channels drove the most qualified leads last month?"

• Claude queries the MCP server, which retrieves data from the platform's unified dataset.

• The answer includes spend, conversions, and lead quality across all channels — no manual SQL required.

This approach has three advantages:

• No custom connector code — the platform handles API complexity for Google Ads, Meta, and other sources.

• Data is already normalized — campaign naming, metric definitions, and attribution logic are pre-configured.

• Security and permissions are managed — the platform enforces role-based access and audit logs.

What to Look for in an MCP-Ready Marketing Platform

Not all marketing data platforms support MCP yet. When evaluating tools, ask:

• Does the platform expose an MCP server? — can AI agents query your data using the Model Context Protocol?

• Which data sources are included? — does it connect to your ad platforms, CRM, and analytics tools?

• How is data normalized? — does the platform handle schema mapping and metric standardization, or do you need to configure it manually?

• What permissions exist? — can you control which users or AI agents access specific datasets?

• How are queries logged? — does the platform track what data the AI accessed and when?

The goal is to avoid building MCP infrastructure from scratch. If the platform already aggregates and normalizes your data, adding MCP support is straightforward. If it doesn't, you're back to writing custom connectors.

Security and Governance for MCP Servers

Giving AI agents access to your marketing data introduces risk. The agent can query sensitive information, expose customer records, or pull data it shouldn't see. MCP servers need security controls to prevent misuse.

Authentication and Authorization

MCP servers authenticate AI clients using API keys, OAuth tokens, or session-based credentials. The server verifies that the client is authorized to access the requested data.

Inside the server, you define permissions at the resource level. An analyst might have access to campaign performance data but not customer PII. A finance user might see spend data but not granular conversion metrics.

The MCP server enforces these rules before executing queries. If the AI agent requests data outside the user's permissions, the server returns an error.

Audit Logs

Every query the AI agent makes should be logged. The log should include:

• Who made the request (user or service account)

• What data was accessed

• When the query ran

• Whether it succeeded or failed

This is critical for compliance. If your team handles regulated data (healthcare, finance, EU customer data), you need to prove who accessed what and when. MCP servers that don't log queries create blind spots in your audit trail.

Data Masking and Filtering

MCP servers can mask sensitive fields before returning data to the AI agent. For example, the server might replace email addresses with hashed identifiers or redact customer names.

This is especially important when the AI agent writes responses visible to multiple users. If the agent includes sensitive data in its output, it could leak to someone without permission to see it.

Some teams configure the MCP server to filter data by role. An account manager might only see campaigns they own. A regional director might only see data for their geography. The server applies these filters automatically based on the authenticated user.

MCP Servers vs. AI Agents vs. Copilots

The terms "MCP server," "AI agent," and "AI copilot" describe different parts of the same system. They're often used interchangeably, but they have distinct roles.

The MCP server is infrastructure. The AI agent is the intelligence. The copilot is the interface.

When an analyst asks a question, the copilot sends it to the AI agent. The agent decides what data it needs and queries the MCP server. The server fetches the data and returns it to the agent. The agent formats the answer and sends it back to the copilot.

This separation matters because it allows flexibility. You can swap out the AI agent (from Claude to GPT) without rebuilding the MCP server. You can change the copilot interface (from chat to Slack to API) without touching the data layer.

Common MCP Implementation Patterns for Marketing Teams

Marketing teams deploy MCP servers in three main configurations: warehouse-backed, platform-backed, and hybrid.

Warehouse-Backed MCP

The MCP server connects directly to your data warehouse (Snowflake, BigQuery, Redshift). The AI agent queries tables using SQL.

Pros:

• You control the schema and data model

• No dependency on third-party platforms

• Full access to historical data

Cons:

• You need to build ETL pipelines to get data into the warehouse

• The MCP server must generate valid SQL for your warehouse dialect

• No built-in metric definitions or attribution logic

This works well if you already have a mature data warehouse and a team that can write connector logic.

Platform-Backed MCP

The MCP server queries a marketing data platform or analytics tool. The platform handles API connections, data normalization, and schema mapping. The MCP server just translates AI requests into platform queries.

Pros:

• No custom connector code

• Pre-built metric definitions and attribution models

• Faster time to deployment

Cons:

• You depend on the platform's data coverage and refresh schedule

• Limited control over the underlying schema

• May require a contract or subscription

This is the fastest path for teams without engineering resources.

Hybrid MCP

The MCP server queries both a data warehouse and external APIs. For example, it pulls historical data from Snowflake and real-time data from ad platform APIs.

Pros:

• Combines warehouse flexibility with real-time data access

• Can federate queries across multiple sources

Cons:

• Complex to build and maintain

• Requires handling schema mismatches between sources

• Slower query performance if joining across systems

This pattern is common in large enterprises where different teams own different data sources.

MCP Server Performance and Scalability

MCP servers add latency to AI queries. The agent sends a request to the server, the server queries the data source, and the server returns the result. If the data source is slow, the AI response is slow.

Query Optimization

When the MCP server generates SQL or API calls, it should optimize for speed:

• Limit result sets — return only the top N rows unless the user asks for more

• Use indexes — ensure the warehouse has indexes on commonly queried fields

• Cache repeated queries — if the agent asks the same question twice, return cached results

• Parallelize API calls — if the query needs data from multiple sources, fetch them concurrently

Most AI agents send multiple queries per conversation. If each query takes 10 seconds, the conversation stalls. Fast MCP servers return results in under 2 seconds.

Rate Limits and Throttling

Marketing APIs enforce rate limits. Google Ads allows a certain number of requests per day. Salesforce limits API calls per hour. If your MCP server exceeds these limits, queries fail.

The server should track API usage and throttle requests to stay under limits. If the agent requests more data than the daily quota allows, the server should return a partial result or queue the request for later.

Concurrency

If multiple analysts use the same MCP server simultaneously, the server must handle concurrent queries. Each query should run in isolation — one analyst's request shouldn't block another's.

Most MCP servers use asynchronous execution. The server receives a query, starts processing it in the background, and immediately accepts the next query. Results are returned as they complete.

Real-World Use Cases for MCP Servers in Marketing

Here's how marketing teams use MCP servers today:

Ad-Hoc Reporting

Analysts spend hours building one-off reports for stakeholders. "How much did we spend on LinkedIn last quarter?" "Which campaigns drove the most demo requests?"

With an MCP server, the analyst asks Claude the question. The AI agent queries the data and returns the answer. No dashboard building required.

Budget Monitoring

Account managers need to know if campaigns are over or under budget. Instead of checking dashboards daily, they ask the AI: "Show me campaigns that are within 10% of their monthly budget."

The MCP server queries current spend and budget data, calculates the percentage, and returns the list. The manager gets an answer in seconds.

Attribution Analysis

Marketing leaders want to know which channels contribute to pipeline. Traditional attribution models require pre-configured dashboards. With MCP, the leader asks: "Which channels assisted the most closed deals last quarter?"

The MCP server queries attribution data from the warehouse, applies the team's attribution model, and returns the results. The AI agent presents the answer with channel breakdowns and contribution percentages.

Anomaly Detection

Analysts notice unusual spikes or drops in metrics. Instead of manually investigating, they ask the AI: "Why did Google Ads spend increase 30% yesterday?"

The MCP server queries spend data by campaign, compares it to the previous week, and identifies which campaigns drove the increase. The agent explains the anomaly in plain language.

Forecasting

Finance teams need to project spend for the rest of the quarter. The analyst asks: "At the current pace, what will our total ad spend be by end of quarter?"

The MCP server queries daily spend data, calculates the run rate, and projects the total. The agent returns the forecast with a confidence interval.

Improvado review

“On the reporting side, we saw a significant amount of time saved! Some of our data sources required lots of manipulation, and now it's automated and done very quickly. Now we save about 80% of time for the team.”

Kasia Pasich

Data Analyst

Choosing the Right MCP Infrastructure for Your Team

Marketing teams have three options when adopting MCP: build a custom server, use a pre-built open-source server, or use a platform that exposes MCP natively.

Build a Custom MCP Server

Best for: Large enterprises with engineering resources and complex data infrastructure.

Effort: High — requires writing connector logic, testing, deployment, and ongoing maintenance.

Pros: Full control over schema, permissions, and integrations.

Cons: Slow to deploy, high maintenance burden, requires specialized knowledge.

Use an Open-Source MCP Server

Best for: Teams with technical skills who want to move faster than building from scratch.

Effort: Medium — requires configuring the server, connecting data sources, and deploying.

Pros: Faster than custom builds, community support available.

Cons: Limited to supported data sources, may not handle marketing-specific needs (attribution, metric definitions).

Use a Platform with Native MCP Support

Best for: Marketing teams that want MCP without engineering overhead.

Effort: Low — the platform handles data integration, normalization, and MCP server deployment.

Pros: Fastest time to value, no custom code, built-in governance and permissions.

Cons: Depends on platform capabilities, may have feature gaps for niche use cases.

Most marketing teams choose the third option. They don't have the resources to build and maintain MCP infrastructure, and pre-built open-source servers don't cover marketing-specific data sources like Google Ads or Salesforce.

Limitations and Challenges of MCP Servers

MCP servers are powerful, but they have constraints. Understanding these limits helps set realistic expectations.

Not All AI Models Support MCP

As of early 2026, Claude has the most mature MCP implementation. GPT and Gemini support the protocol, but with less tooling and documentation. Smaller or proprietary models may not support MCP at all.

If your team uses a custom-trained model or a vendor-specific AI assistant, check whether it can connect to MCP servers. You may need to build a translation layer.

Complex Queries Can Fail

AI agents struggle with ambiguous or multi-step queries. "Show me the ROI of all campaigns that ran in Q4, excluding brand campaigns, and compare to the previous year" requires the agent to:

• Identify the date range

• Filter out brand campaigns

• Calculate ROI

• Fetch comparison data

• Format the results

If the MCP server doesn't expose tools for each step, the query fails. The agent may ask clarifying questions, return partial results, or give up.

This improves over time as AI models get better at reasoning, but for now, complex queries often require breaking them into simpler steps.

Data Quality Still Matters

MCP servers surface whatever data exists in your warehouse or platform. If the data is wrong, the AI agent returns wrong answers. If campaign names are inconsistent, the agent can't group them correctly. If attribution data is missing, the agent can't calculate contribution.

MCP doesn't fix data issues. It just makes bad data more accessible.

No Proactive Insights

MCP servers respond to queries. They don't monitor data, detect anomalies, or send alerts. If spend doubles overnight, the agent won't notify you unless you ask.

Some teams build automation on top of MCP — scheduled queries that check for anomalies and send alerts. But the protocol itself is reactive, not proactive.

The Future of MCP in Marketing Analytics

The Model Context Protocol is less than two years old. By early 2026, adoption is still early, but growing fast. Here's where the ecosystem is heading.

More Pre-Built Marketing MCP Servers

The open-source community is building MCP servers for common marketing tools. Expect pre-built connectors for Google Ads, Meta, LinkedIn, Salesforce, and HubSpot within the next year.

These servers will handle authentication, rate limiting, and schema mapping so teams don't need to write custom code. But they won't solve normalization — you'll still need a layer that unifies data across platforms.

Platform-Native MCP Endpoints

Marketing platforms will start exposing MCP servers natively. Instead of building a custom connector, you'll authenticate with the platform's MCP endpoint and query data directly.

This shifts the integration burden to the platform. They handle API complexity, and you just point your AI agent at the endpoint.

Agentic Workflows

AI agents will move beyond answering questions. They'll execute multi-step workflows: pull data, identify issues, suggest fixes, and apply changes.

For example, an agent might notice a campaign is underperforming, recommend a budget reallocation, and update the ad platform automatically — all through MCP servers.

This requires trust and governance. Teams will need approval workflows, rollback mechanisms, and audit logs to track what the agent changed.

Multi-Modal MCP

Current MCP servers return structured data: tables, JSON, metrics. Future versions will handle unstructured data: images, videos, documents.

An AI agent might query an MCP server for campaign creative, analyze the images, and suggest which creatives to A/B test. This requires the server to handle file storage, not just database queries.

Conclusion

MCP servers bridge AI agents and data sources. They let marketing analysts ask questions in natural language and get answers from unified datasets. The Model Context Protocol standardizes how this works, so you write the connector once and any AI client can use it.

For marketing teams, MCP matters when you have centralized data and want to layer conversational AI on top of it. The server handles authentication, query execution, and error handling so the AI agent doesn't need to know how your systems work.

Building a custom MCP server requires engineering resources most marketing teams don't have. The faster path is using a platform that aggregates your data and exposes an MCP interface. That way, the AI agent queries normalized, governed data without custom code.

MCP is still early. By 2026, adoption is growing, but marketing-specific connectors and tooling are limited. Over the next year, expect more pre-built servers, platform-native MCP endpoints, and agentic workflows that go beyond answering questions.

If you're exploring AI-powered analytics, MCP is the infrastructure layer that makes it work. It's not the data platform, the AI model, or the user interface — it's the connector that ties them together.

Frequently Asked Questions

What is the difference between an MCP server and a regular API?

An API is a set of endpoints that applications call to exchange data. An MCP server uses APIs internally but adds a layer that lets AI agents interact with those APIs using natural language. The MCP server translates the agent's request into API calls, handles authentication, and formats the response so the agent can understand it. A regular API requires the caller to know the exact endpoint, parameters, and authentication method. An MCP server abstracts that complexity, allowing the AI agent to ask questions without knowing the underlying API structure.

Can I use MCP without a data warehouse?

Yes, but it's harder. MCP servers can query APIs directly, but you lose the benefits of centralized, normalized data. If your marketing data is scattered across platforms, the AI agent will return inconsistent results because each platform uses different naming conventions and schemas. A data warehouse or marketing data platform unifies the data first, so the MCP server queries a single source of truth. Without that layer, you need to build normalization logic into the MCP server itself, which is more complex to maintain.

Is MCP secure for sensitive marketing data?

MCP servers can be secure if implemented correctly. They should authenticate AI clients using API keys or OAuth, enforce role-based permissions, log all queries for audit purposes, and mask sensitive fields before returning data. The protocol itself doesn't enforce security — it's up to the team building the server to add those controls. If you're handling regulated data (GDPR, CCPA, HIPAA), ensure the MCP server logs access, encrypts data in transit, and restricts queries based on user permissions. Platforms that expose MCP endpoints should handle these security layers automatically.

Which AI models support MCP?

As of early 2026, Claude has the most mature MCP implementation. Anthropic developed the protocol and provides SDKs and documentation. GPT (OpenAI) and Gemini (Google) support MCP, but with less tooling. Smaller models or custom-trained LLMs may not support the protocol at all. If you're using a vendor-specific AI assistant (Salesforce Einstein, HubSpot AI), check whether it can connect to MCP servers. Some vendors build proprietary connectors instead of adopting the open standard.

How long does it take to build an MCP server?

Building a custom MCP server from scratch takes weeks to months, depending on the complexity of your data sources. You need to write connector logic, handle authentication, map schemas, test error cases, and deploy the server. Using a pre-built open-source MCP server reduces this to days or weeks — you still need to configure it and connect your data sources. Using a platform that exposes MCP natively can get you operational in days, because the platform handles data integration and normalization. Most marketing teams choose the third option to avoid long development cycles.

Do I need engineers to use MCP servers?

It depends on your implementation. If you build a custom MCP server, yes — you need engineers to write connector code, deploy the server, and maintain it. If you use a platform that exposes MCP natively, no — the platform handles the technical work, and marketing analysts can configure permissions and queries without code. Open-source MCP servers fall in the middle — they require technical setup but less than building from scratch. For most marketing teams, the goal is to adopt MCP without engineering overhead, which means choosing a platform that supports it out of the box.

Can MCP servers replace dashboards?

Not entirely. Dashboards are useful for monitoring metrics over time, spotting trends, and sharing consistent views with teams. MCP servers excel at ad-hoc queries and answering one-off questions. You still need dashboards for recurring reports and executive overviews. But MCP reduces the number of dashboards you need to build. Instead of creating a new dashboard every time someone asks a question, the AI agent queries the data directly. Over time, teams use dashboards for high-level monitoring and MCP for deep dives and exploratory analysis.

What happens if an MCP query fails?

If the MCP server encounters an error — the API rate limit is exceeded, the database is unavailable, the query is invalid — it returns an error message to the AI agent. The agent relays the error to the user, usually in natural language. For example, if the Google Ads API is down, the agent might say, "I couldn't retrieve Google Ads data because the API is temporarily unavailable. Please try again in a few minutes." Well-built MCP servers log errors and retry transient failures automatically. If the error is permanent (invalid credentials, missing permissions), the server returns a clear explanation so the user can fix it.

Can I use MCP with custom metrics and attribution models?

Yes, if your MCP server queries a data warehouse or platform where those metrics are already calculated. The AI agent can't invent new metrics — it can only query data that exists. If your team uses a custom attribution model, ensure the model runs before the MCP server queries the data. For example, if you calculate multi-touch attribution in your warehouse, the MCP server can query the attribution table. If the model isn't pre-calculated, the agent can't apply it on the fly. The server returns raw data, and you'll need to define custom tools that execute the attribution logic before returning results.

How does MCP handle real-time data?

MCP servers return data as fresh as the underlying source. If your data warehouse updates nightly, the AI agent sees yesterday's data. If the MCP server queries live APIs, the agent sees real-time data. Most marketing teams use a hybrid approach: historical data comes from the warehouse (fast, reliable), and real-time data comes from APIs (slower, subject to rate limits). The MCP server can federate queries across both sources, but this adds latency. For time-sensitive questions like "How much have we spent today?" the server should query the API directly. For historical trends, it should query the warehouse.