MCP Google Ads na Claude Desktop 2026

MCP (Model Context Protocol) spuštěný Anthropic v listopadu 2024 překročil 200 veřejných serverů v oficiálním adresáři ke konci Q1 2026 (modelcontextprotocol.io), s adopcí zrychlující se u power users Claude Desktop, Cursor a Claude Code. Přesto méně než 5 veřejných MCP serverů pro Google Ads existuje v roce 2026 — jde o jednu z největších mezer ekosystému, a přesně tu se chystáme v tomto průvodci zaplnit. Řády velikosti pozorované na agregovaných datech Google Ads 2025-2026 : PPC manažer adoptující MCP-driven workflow typicky získá zpět 25 až 40 % operačního času dle velikosti účtu, s rozsahem 18 % až 52 % dle vertikál (vyspělý e-com dosahuje nejvyššího zisku, lead gen B2B mírného zisku kvůli dlouhým cyklům).

Zde přesně jak postavit MCP server Google Ads v TypeScript : architektura, copy-paste TypeScript kód, nastavení OAuth, vystavené nástroje, konfigurace Claude Desktop. Na konci průvodce budete mít setup, kde napsáním „proveď audit mého účtu Google Ads" v Claude Desktop spustíte skutečný audit přes váš MCP server. Repozitář GitHub github.com/steerads/mcp-google-ads-server obsahuje veškerý zdokumentovaný kód. Předpoklady : Node.js 18+, účet Google Ads, developer_token API (viz náš průvodce nastavením API Google Ads Python pro OAuth postup, identický na straně TypeScript). Pokud teprve začínáte s automatizací Google Ads, přečtěte si nejdříve náš průvodce 10 skripty ready-to-copy. Náš kalkulátor zbytečně vynaloženého rozpočtu odhaduje € spálené/měsíc broad bez negativních klíčových slov nebo nadměrným bounce LP.

Co je MCP a proč pro Google Ads ?

MCP (Model Context Protocol) je open-source protokol publikovaný Anthropic v listopadu 2024 pro standardizaci způsobu, jakým LLM (Claude, ale kompatibilní i s jinými modely) konzumují data a externí nástroje. Představte si ho jako ekvivalent LSP (Language Server Protocol) pro IDE : client-server protokol, kde klientem je LLM aplikace (Claude Desktop, Claude Code, Cursor, Zed) a server vystavuje resources (data ke čtení), prompts (předformátované šablony) a tools (funkce k volání) přes standardizované JSON-RPC rozhraní.

Pro Google Ads je přínos okamžitý. Místo ručního vyhledávání dat v rozhraní Google Ads (10 kliknutí pro získání statistiky) napíšete v přirozeném jazyce do Claude Desktop : „Která jsou mých 5 klíčových slov s nejvyšším CPA tento týden ?" a Claude automaticky zavolá nástroj pull_keyword_performance vystavený vaším MCP serverem, přečte odpověď a formuluje analýzu v srozumitelném jazyce. Jde o PPC manažerský workflow přepracovaný do konverzační formy.

Tři konkrétní přínosy pozorované ve veřejných benchmarcích na produkčních MCP Google Ads setupech :

1. Čas ušetřený na ad-hoc dotazech : 5 až 15 minut ušetřených na analytickou relaci (žádné přihlášení do rozhraní, žádné ruční filtrování, žádné kopírování do Excelu).
2. Syntéza napříč účty : MCP server může paralelně dotazovat 10 účtů a syntetizovat poznatky — u Skriptů nemožné.
3. Konverzační debugging : „proč CPA kampaně X explodovalo včera ?" spustí víceúrovňový audit (CPC, CTR, míra konverze, search terms, IS) aniž byste museli vědět, které reporty konzultovat.

MCP NENÍ vhodný pro : cron automatizace (MCP server čeká na interakci člověka přes Claude Desktop, nemá scheduler), bulk mutace nad 1 000 entit (nevhodné médium) nebo operace vyžadující bohaté UI (interaktivní grafy, drag-drop). Pro tyto případy zůstávají správným nástrojem Python API jako standalone nebo Google Ads Scripts.

Architektura : Claude Desktop -> MCP server -> Google Ads API

Architektura MCP Google Ads setupu sleduje klasický client-server pattern rozčleněný do tří vrstev : LLM klient (Claude Desktop, Cursor, Claude Code), který orchestruje konverzaci a rozhoduje o volání nástrojů ; MCP server (váš kód), který vystavuje katalog nástrojů přes JSON-RPC protokol ; a podkladové business API (zde Google Ads API v17), které provádí skutečné operace. Tato separace dělá server znovupoužitelným : jeden TypeScript kód, více možných klientů. Na setupech, které nasazujeme, je počáteční vývojové úsilí v řádu 4 až 8 hodin pro MCP server se 4 nástroji, a poměr ušetřeného času / investovaného času se obrací průměrně za 2 až 3 týdny používání.

Vrstva 1 : Claude Desktop. Oficiální Anthropic desktopová aplikace dostupná na Mac a Windows (claude.ai/desktop). Hostuje konverzační zážitek, objevuje nainstalované MCP servery přes konfigurační soubor a orchestruje volání nástrojů. Mluvíte s Claude, Claude se rozhoduje volat vaše nástroje.

Vrstva 2 : MCP Server (váš kód). Node.js proces (nebo Python, Rust, Go — na tom nezáleží), který implementuje MCP protokol přes stdin/stdout (lokální stdio režim) nebo HTTP/SSE (vzdálený režim). Server vystavuje seznam nástrojů, každý s názvem, popisem, schématem argumentů. Při každém volání nástroje Claudem server provede kód a vrátí strukturovaný výsledek.

Vrstva 3 : Google Ads API. Knihovna google-ads-api (Node.js port oficiální knihovny, spravovaný komunitou) abstrahuje GAQL volání a mutace. MCP server se autentizuje přes OAuth2 + developer_token při startu, pak používá klienta pro volání API při každém tool callu.

Lokální stdio režim je zcela dostačující pro individuální použití : server běží na vašem stroji, Claude Desktop ho spouští jako subprocess, komunikace přes stdin/stdout JSON-RPC. Žádná síť, latence blízká nule, credentials nikdy nevystaveny jinde než na vašem stroji. HTTP/SSE vzdálený režim se stává relevantním pro týmy sdílející MCP server (např. agentura s 5 PPC manažery ukazujícími na stejný server). Pro tento průvodce zůstáváme na lokálním stdio.

Tabulka níže porovnává oba transporty pro správnou volbu dle vašeho setupu :

Nastavení Claude Desktop a konfigurace MCP

Před kódováním serveru nakonfigurovat Claude Desktop, aby mohl objevovat MCP servery. Stáhnout Claude Desktop z claude.ai/desktop, nainstalovat, přihlásit se účtem Anthropic.

Konfigurační soubor MCP pro Claude Desktop je :

• Mac : ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows : %APPDATA%\Claude\claude_desktop_config.json

Pokud soubor neexistuje, vytvořit ho. Zde je základní struktura :

{
  "mcpServers": {
    "google-ads": {
      "command": "node",
      "args": [
        "/Users/vasuser/dev/mcp-google-ads-server/dist/index.js"
      ],
      "env": {
        "GOOGLE_ADS_DEVELOPER_TOKEN": "YOUR_DEVELOPER_TOKEN",
        "GOOGLE_ADS_CLIENT_ID": "YOUR_CLIENT_ID",
        "GOOGLE_ADS_CLIENT_SECRET": "YOUR_CLIENT_SECRET",
        "GOOGLE_ADS_REFRESH_TOKEN": "YOUR_REFRESH_TOKEN",
        "GOOGLE_ADS_LOGIN_CUSTOMER_ID": "1234567890",
        "GOOGLE_ADS_DEFAULT_CUSTOMER_ID": "1112223333",
        "READ_ONLY_MODE": "false"
      }
    }
  }
}

Tři důležité klíče :

• command : příkaz pro spuštění serveru. Zde node, protože TypeScript se kompiluje, ale může být python, npx atd.
• args : absolutní cesta k buildu serveru. Vyhýbat se relativním cestám nebo cestám s nevyřešeným ~.
• env : proměnné prostředí předávané serveru. Zde se vstřikují credentials Google Ads.

Bezpečnostní poznámka : tento soubor obsahuje vaše credentials Google Ads v čistém textu. NIKDY ho necommitovat do Git, NIKDY nesdílet. Pro tým zvážit wrapper skript načítající credentials ze secret manageru při spuštění.

Pro ověření, že Claude Desktop vidí váš server, po restartu Claude Desktop otevřít novou konverzaci a napsat „které MCP servery jsou dostupné ?". Claude musí vypsat google-ads s jeho nástroji (po prvním spuštění, které je enumeruje).

Psaní MCP serveru v TypeScript : 4 klíčové nástroje

MCP nástroj je minimální jednotka rozšíření LLM : pojmenovaná funkce, popsaná v čitelné formě, parametrizovaná JSON schématem, která provede operaci a vrátí strukturovaný výsledek. Oficiální SDK @modelcontextprotocol/sdk poskytuje kostru serveru a routing nástrojů ; vy poskytujete obchodní logiku. Empirické pravidlo, které aplikujeme na produkční setupy : 6 až 12 nástrojů na MCP server, zaměřených na atomické operace (jeden nástroj = jedno obchodní sloveso), s popisem v méně než 200 znacích pro správný výběr LLM. 4 nástroje vyvinuté níže (search_campaigns, get_account_audit, pull_report, add_negative) pokrývají ve většině případů 70 až 80 % otázek kladených PPC manažerovi denně.

mcp-google-ads-server/
├── src/
│   ├── index.ts          # Entry point + MCP server setup
│   ├── google-ads.ts     # Client wrapper Google Ads API
│   ├── tools/
│   │   ├── search-campaigns.ts
│   │   ├── account-audit.ts
│   │   ├── pull-report.ts
│   │   └── add-negative.ts
│   └── types.ts
├── package.json
├── tsconfig.json
└── .env.example

Minimální package.json :

{
  "name": "mcp-google-ads-server",
  "version": "0.1.0",
  "main": "dist/index.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js",
    "dev": "ts-node src/index.ts"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^0.5.0",
    "google-ads-api": "^17.0.0",
    "zod": "^3.22.0"
  },
  "devDependencies": {
    "typescript": "^5.3.0",
    "ts-node": "^10.9.0",
    "@types/node": "^20.10.0"
  }
}

Entry point src/index.ts inicializuje MCP server a registruje nástroje :

// src/index.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { searchCampaignsTool } from "./tools/search-campaigns.js";
import { accountAuditTool } from "./tools/account-audit.js";
import { pullReportTool } from "./tools/pull-report.js";
import { addNegativeTool } from "./tools/add-negative.js";

const server = new Server(
  { name: "google-ads-mcp", version: "0.1.0" },
  { capabilities: { tools: {} } }
);

const TOOLS = [
  searchCampaignsTool,
  accountAuditTool,
  pullReportTool,
  addNegativeTool,
];

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: TOOLS.map((t) => ({
    name: t.name,
    description: t.description,
    inputSchema: t.inputSchema,
  })),
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const tool = TOOLS.find((t) => t.name === request.params.name);
  if (!tool) {
    throw new Error(`Unknown tool: ${request.params.name}`);
  }

  try {
    const result = await tool.handler(request.params.arguments);
    return {
      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
    };
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    return {
      content: [{ type: "text", text: `Error: ${msg}` }],
      isError: true,
    };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);
console.error("[MCP] google-ads server started on stdio");

Poznámka : console.error místo console.log, protože stdout je vyhrazen pro JSON-RPC protokol. Veškeré logy přes stderr, aby se neznehodnotil komunikační kanál. Toto pravidlo je nezanedbatelné : jediný parazitický console.log stačí k narušení JSON parsování klienta a zhroucení konverzace. Pro ladění při vývoji je doporučeným vzorem použít strukturovaný logger (pino, winston) nakonfigurovaný na write-stream na stderr s nastavitelnou úrovní verbosity přes env var. Na produkčních serverech, které nasazujeme, 30-60 % počátečního troubleshootingu absorbuji problémy znečištění streamu, které zmizí po správném zapojení loggeru.

Wrapper Google Ads v src/google-ads.ts :

// src/google-ads.ts
import { GoogleAdsApi } from "google-ads-api";

let clientInstance: GoogleAdsApi | null = null;

export function getGoogleAdsClient(): GoogleAdsApi {
  if (clientInstance) return clientInstance;

  clientInstance = new GoogleAdsApi({
    client_id: process.env.GOOGLE_ADS_CLIENT_ID!,
    client_secret: process.env.GOOGLE_ADS_CLIENT_SECRET!,
    developer_token: process.env.GOOGLE_ADS_DEVELOPER_TOKEN!,
  });

  return clientInstance;
}

export function getCustomer(customerId?: string) {
  const id = customerId || process.env.GOOGLE_ADS_DEFAULT_CUSTOMER_ID!;
  const loginId = process.env.GOOGLE_ADS_LOGIN_CUSTOMER_ID!;

  const client = getGoogleAdsClient();
  return client.Customer({
    customer_id: id,
    login_customer_id: loginId,
    refresh_token: process.env.GOOGLE_ADS_REFRESH_TOKEN!,
  });
}

Nástroj search-campaigns vystavující flexibilní GAQL vyhledávání :

// src/tools/search-campaigns.ts
import { z } from "zod";
import { getCustomer } from "../google-ads.js";

const inputSchema = {
  type: "object",
  properties: {
    customer_id: {
      type: "string",
      description: "Google Ads customer ID (10 digits, no dashes). Default if omitted.",
    },
    status_filter: {
      type: "string",
      enum: ["ENABLED", "PAUSED", "REMOVED", "ALL"],
      description: "Campaign status filter. Default: ENABLED.",
    },
    date_range: {
      type: "string",
      description: "GAQL date range: TODAY, LAST_7_DAYS, LAST_30_DAYS, etc.",
    },
    limit: {
      type: "number",
      description: "Max number of campaigns to return. Default: 50.",
    },
  },
};

export const searchCampaignsTool = {
  name: "search_campaigns",
  description:
    "List Google Ads campaigns with their KPI (impressions, clicks, cost, conversions, CTR, CPA) " +
    "filtered by status and date range. Returns top campaigns by spend.",
  inputSchema,
  handler: async (args: any) => {
    const customer = getCustomer(args?.customer_id);
    const status = args?.status_filter || "ENABLED";
    const dateRange = args?.date_range || "LAST_30_DAYS";
    const limit = args?.limit || 50;

    const statusClause =
      status === "ALL" ? "" : `AND campaign.status = '${status}'`;

    const query = `
      SELECT
        campaign.id, campaign.name, campaign.status,
        metrics.impressions, metrics.clicks,
        metrics.cost_micros, metrics.conversions,
        metrics.ctr, metrics.average_cpc
      FROM campaign
      WHERE segments.date DURING ${dateRange} ${statusClause}
      ORDER BY metrics.cost_micros DESC
      LIMIT ${limit}
    `;

    const rows = await customer.query(query);

    return rows.map((r: any) => ({
      id: r.campaign.id,
      name: r.campaign.name,
      status: r.campaign.status,
      impressions: r.metrics.impressions,
      clicks: r.metrics.clicks,
      cost_eur: (Number(r.metrics.cost_micros) / 1_000_000).toFixed(2),
      conversions: r.metrics.conversions,
      ctr_pct: (Number(r.metrics.ctr) * 100).toFixed(2),
      cpc_eur: (Number(r.metrics.average_cpc) / 1_000_000).toFixed(2),
      cpa_eur:
        Number(r.metrics.conversions) > 0
          ? (
              Number(r.metrics.cost_micros) /
              1_000_000 /
              Number(r.metrics.conversions)
            ).toFixed(2)
          : null,
    }));
  },
};

Nástroj account-audit agregující pohled auditu na vysoké úrovni :

// src/tools/account-audit.ts
import { getCustomer } from "../google-ads.js";

export const accountAuditTool = {
  name: "get_account_audit",
  description:
    "Run a high-level audit of the Google Ads account: total spend last 30 days, " +
    "campaign types breakdown, top 5 campaigns by spend, conversion volume, " +
    "average CPA. Returns a structured audit report.",
  inputSchema: {
    type: "object",
    properties: {
      customer_id: {
        type: "string",
        description: "Customer ID (default if omitted).",
      },
    },
  },
  handler: async (args: any) => {
    const customer = getCustomer(args?.customer_id);

    // 1. Account totals
    const totals = await customer.query(`
      SELECT
        metrics.cost_micros, metrics.clicks,
        metrics.conversions, metrics.impressions
      FROM customer
      WHERE segments.date DURING LAST_30_DAYS
    `);

    // 2. Top 5 campaigns
    const top5 = await customer.query(`
      SELECT campaign.name, metrics.cost_micros, metrics.conversions
      FROM campaign
      WHERE campaign.status = 'ENABLED'
        AND segments.date DURING LAST_30_DAYS
      ORDER BY metrics.cost_micros DESC LIMIT 5
    `);

    // 3. Campaign types breakdown
    const types = await customer.query(`
      SELECT
        campaign.advertising_channel_type,
        metrics.cost_micros
      FROM campaign
      WHERE campaign.status = 'ENABLED'
        AND segments.date DURING LAST_30_DAYS
    `);

    const totalCost =
      totals.reduce(
        (sum: number, r: any) => sum + Number(r.metrics.cost_micros),
        0
      ) / 1_000_000;
    const totalConv = totals.reduce(
      (sum: number, r: any) => sum + Number(r.metrics.conversions),
      0
    );

    return {
      period: "LAST_30_DAYS",
      total_spend_eur: totalCost.toFixed(2),
      total_clicks: totals.reduce(
        (s: number, r: any) => s + Number(r.metrics.clicks),
        0
      ),
      total_conversions: totalConv.toFixed(1),
      avg_cpa_eur:
        totalConv > 0 ? (totalCost / totalConv).toFixed(2) : null,
      top_5_campaigns: top5.map((r: any) => ({
        name: r.campaign.name,
        spend_eur: (Number(r.metrics.cost_micros) / 1_000_000).toFixed(2),
        conv: r.metrics.conversions,
      })),
      campaign_count_by_type: types.reduce(
        (acc: Record<string, number>, r: any) => {
          const t = r.campaign.advertising_channel_type;
          acc[t] = (acc[t] || 0) + 1;
          return acc;
        },
        {}
      ),
    };
  },
};

Zbývající 2 nástroje (pull_report pro vlastní exporty a add_negative pro mutace s potvrzením) sledují stejný pattern. Repozitář github.com/steerads/mcp-google-ads-server obsahuje veškerý kód plus 2 dodatečné nástroje (update_keyword_bid s potvrzením, list_audiences).

Rozdíl read-only vs mutace si zaslouží zmínku. Nástroje search_campaigns, get_account_audit, pull_report jsou bezpečné ze své podstaty : nemění stav účtu, lze je volat libovolněkrát a jejich cena je omezena na spotřebu API kvóty. Nástroje add_negative_keyword, update_keyword_bid, pause_campaign jsou mutující a vyžadují dodatečnou disciplínu. Dominantní pattern, který aplikujeme, je dvojité opt-in : globální flag READ_ONLY_MODE=true zcela deaktivující mutace na straně serveru, plus explicitní potvrzení vyžadované od LLM před každou individuální mutací. Dokumentováno na stránce Google Ads API best practices, tato dvouúrovňová ochrana zabraňuje náhodným mutacím při ladicích nebo průzkumných relacích.

OAuth autentizace Google Ads v MCP

OAuth pro Google Ads sleduje stejný pattern jako standalone Python nebo Node.js skript : developer_token + refresh_token + login_customer_id. Specifičnost MCP : tyto credentials jsou předávány serveru přes env v souboru claude_desktop_config.json, načteny při startu procesu.

Pro generování počátečního refresh_token je nejjednodušší použít oficiální google-ads-python skript (podrobný postup v našem průvodci nastavením Python API). Jakmile je refresh_token vygenerován, je platný trvale (Google ho zřídkakdy revokuje, ledaže se změní heslo nebo je manuálně revokován).

Flow autentizace v MCP serveru :

// src/auth-check.ts
import { getCustomer } from "./google-ads.js";

export async function validateCredentials() {
  const required = [
    "GOOGLE_ADS_DEVELOPER_TOKEN",
    "GOOGLE_ADS_CLIENT_ID",
    "GOOGLE_ADS_CLIENT_SECRET",
    "GOOGLE_ADS_REFRESH_TOKEN",
    "GOOGLE_ADS_LOGIN_CUSTOMER_ID",
  ];

  const missing = required.filter((k) => !process.env[k]);
  if (missing.length > 0) {
    throw new Error(
      `Missing required env vars: ${missing.join(", ")}. ` +
        `Check claude_desktop_config.json.`
    );
  }

  // Test query : ověřit platnost credentials
  try {
    const customer = getCustomer();
    const test = await customer.query("SELECT customer.id FROM customer LIMIT 1");
    if (!test || test.length === 0) {
      throw new Error("Empty response from API");
    }
    console.error(`[Auth] OK customer ${test[0].customer.id}`);
  } catch (err) {
    const msg = err instanceof Error ? err.message : String(err);
    throw new Error(
      `Auth failed: ${msg}. Check refresh_token and login_customer_id.`
    );
  }
}

Volat validateCredentials() při startu serveru (po inicializaci transportu, před přijímáním tool calls). Pokud autentizace selže, server zaznamená chybu na stderr a ukončí se s kódem 1 — Claude Desktop uvidí server jako nefunkční a zobrazí chybu uživateli.

Produkční bezpečnost : pokud nasazujete MCP server na sdílený server (HTTP/SSE režim), NIKDY nekódovat credentials jako plain text. Použít secret manager (AWS Secrets Manager, GCP Secret Manager, HashiCorp Vault) a načítat credentials při startu. Pro lokální individuální stdio režim je claude_desktop_config.json v čistém textu přijatelný, protože není commitovaný a stroj je ze své podstaty důvěryhodný.

Případy použití : audit, optimalizace, reportování přes konverzační Claude

Jakmile je MCP server nainstalován, workflow se radikálně změní. Zde 5 vzorů použití, které revolucionizují produktivitu PPC.

Vzor 1 — Konverzační audit : „proveď audit mého účtu"

Uživatel : „Proveď audit mého účtu Google Ads, co vidíš neobvyklého tento týden ?"

Claude zavolá get_account_audit, obdrží KPI a formuluje strukturovanou analýzu : „Za posledních 30 dní jste utratili 45 230 EUR za 247 konverzí, tedy průměrné CPA 183 EUR. Tři oblasti ke sledování : kampaň 'Brand Search FR' představuje 38 % výdajů, ale pouze 12 % konverzí (nepřiměřené CPA), kampaň 'PMax Generic' má CPA 412 EUR vs 145 EUR na Search Brand (pochybná přírůstkovost), a 4 kampaně mají CTR pod 2 %, které potřebují asset refresh."

To je audit, který byste provedli ručně za 30 minut, doručený za 8 sekund.

Vzor 2 — Ad-hoc deep dive : „proč CPA explodovalo včera ?"

Uživatel : „CPA kampaně 'Search Generic FR' se včera zdvojnásobilo, co se stalo ?"

Claude řetězí několik tool calls : pull_report (CPC + CTR + míra konverze včera vs LAST_7_DAYS), případně pull_search_terms (search query report), případně pull_competitor_metrics (impression share). Syntéza : „Průměrný CPC vzrostl z 1,20 EUR na 2,45 EUR (+104 %) na klíčovém slovu 'software CRM'. Absolute impression share klesl z 65 % na 32 % (-33 pp). Pravděpodobná příčina : nový konkurent agresivně biddující. Doporučení : zkontrolovat broad klíčová slova matchující na generický 'CRM' a zvážit negative pro zachování pouze phrase + exact match."

Vzor 3 — Týdenní reportování : „udělej mi přehled týdne"

Uživatel : „Vygeneruj týdenní report pro mé 3 největší kampaně."

Claude zavolá pull_report 3× s příslušnými filtry, naformátuje markdown digest, který lze zkopírovat do emailu nebo Slacku. Rychlejší než digest skript, lépe přizpůsobitelný než nativní reporty Google Ads.

Vzor 4 — Mutace s potvrzením : „přidej 'zdarma' jako negativní"

Uživatel : „Přidej 'zdarma' jako negativní na kampaň 'Search Premium B2B'."

Claude zavolá add_negative_keyword s krokem potvrzení : „Přidám 'zdarma' jako phrase match negativní na úrovni kampaně 'Search Premium B2B' (ID 12345). Potvrdit ?" Po kladné odpovědi nástroj provede mutaci a vrátí resource_name. Workflow rychlejší než navigace v UI Google Ads, kontrolovanější než automatický skript.

Vzor 5 — Syntéza napříč účty (více účtů)

Uživatel : „Porovnej výkon mých účtů Francie a UK tento měsíc."

Claude zavolá get_account_audit dvakrát (jeden na customer_id), syntetizuje odchylky : „Účet FR vydává 1,8× více než UK za 1,4× více konverzí, tedy o 28 % vyšší CPA na straně FR. Rozdíl CPA je primárně způsoben vyšším průměrným CPC ve FR (+34 %) kvůli místní konkurenci, částečně kompenzovaným lepším CTR (+8 pp)."

Pro agenturu auditující 10+ účtů jde o zásadní změnu.

Nad pět výše uvedených vzorů, pokročilé použití spočívá v řetězení více MCP serverů ve stejné konverzaci. Instalujete paralelně MCP server Google Ads, MCP server GA4 (analytics), MCP server BigQuery a MCP server Slack. Claude pak může řetězit : získat data Google Ads, porovnat s GA4 událostmi, agregovat v BigQuery a odeslat digest na Slack — vše v přirozeném jazyce. Dle pozorovaných vertikál se tento multi-server vzor adoptuje spíše v growth týmech s již vyspělou analytics stackem ; vyžaduje disciplínu pojmenování nástrojů (vyhýbat se kolizím mezi servery) a bdělost ohledně oprávnění (každý server má vlastní credentials, takže rozsah autorizace zůstává hermetický mezi servery).

Aktuální limity a roadmapa MCP

MCP v Q1 2026 zůstává mladým protokolem (15 měsíců po specifikaci Anthropic), s ekosystémem ve výstavbě a zdokumentovanými funkčními mezerami. Protokol exceluje v synchronním konverzačním vzoru (člověk položí otázku, LLM zavolá nástroje, server odpoví), ale zůstává omezený v asynchronních, multi-agent nebo batch vzorech. Dle pozorovaných vertikál adopce MCP v PPC zůstává soustředěna na technické power users ; rozšíření k netechnickým PPC manažerům počká na vrstvu abstrakce instalovatelnou jedním kliknutím. Následující pět limitů je třeba znát před nasazením MCP vrstvy do produkce.

Limit 1 — Žádný scheduler. MCP server nemůže běžet jako cron. Spouští kód pouze když ho zavolá Claude Desktop. Pro opakující se automatizace (hodinové upozornění, denní reporty) je třeba kombinovat MCP + externí cron (nezávislý Python skript odesílající poznatky přes webhook). Viz náš průvodce n8n Google Ads pro cron automatizace.

Limit 2 — Žádné bohaté UI. Claude Desktop zobrazuje text a markdown. Pro graf, interaktivní tabulku, drag-drop MCP není správné médium. Pouze text-first případy použití.

Limit 3 — Kumulativní latence. Každé volání nástroje přidává ~500 ms až 2 s latence (LLM thinking + provádění nástroje + syntéza LLM). Řetězec 5 tool calls = 5 až 10 sekund čekání. Pro PPC manažera zvyklého na okamžité dashboardy jde o změnu tempa.

Limit 4 — Příliš mnoho nástrojů = špatný výběr LLM. Nad 12-15 nástrojů ve stejném serveru Claude začíná váhat nad správným nástrojem k volání. Rozdělit do více tematických MCP serverů.

Limit 5 — Žádné nativní batch operace. Jedno volání nástroje = jedna operace. Pro 1 000 mutací není proveditelné 1 000 tool calls. Ponechat bulk operace u samostatných skriptů, přes MCP vystavovat pouze jednotkové akce.

Roadmapa MCP (jak oznamuje Anthropic ve Q4 2025) předpokládá pro rok 2026 : nativní podpora plánování na straně MCP (pro eliminaci limitu 1), lépe indexovaný oficiální adresář s hodnoceními (kvalita serverů), vyspělejší HTTP/SSE transporty pro týmové setupy a vrstva observability (telemetrie tool calls, ladící UI). Sledovat oficiální dokumentaci MCP pro aktualizace.

Pro účty, které chtějí industrializovat řízení Google Ads s managed AI vrstvou (bez kódování vlastního MCP serveru), náš modul Auto-optimalizace pokrývá případy auditu, monitoringu a upozorňování v managed režimu s dedikovaným UI — viz také náš audit checklist Google Ads pro základ auditu, který musí předcházet jakékoli AI vrstvě. Pro ostatní části automatizačního puzzle viz náš průvodce nastavením Python API a náš průvodce n8n flows.

Pro oficiální zdroje MCP viz modelcontextprotocol.io (specifikace protokolu) a dokumentace Claude MCP (průvodci Anthropic).

Zdroje

Oficiální zdroje použité v tomto průvodci:

• schema.org
• blog.google
• anthropic.com
• platform.openai.com

FAQ