mcp-server-creation

name	mcp-server-creation
description	MCP Server Creation is the skill of building Model Context Protocol servers that expose tools, resources, and capabilities to AI agents through a standardized interface.

MCP Server Creation

Part of Agent Skills™ by googleadsagent.ai™

Description

MCP Server Creation is the skill of building Model Context Protocol servers that expose tools, resources, and capabilities to AI agents through a standardized interface. MCP has emerged as the universal integration layer for AI agent tooling — a single protocol that lets any compliant agent (Claude Code, Cursor, Codex, and others) discover and invoke server-side tools without custom integration code. Building production-quality MCP servers on Cloudflare Workers enables global, low-latency tool access with zero infrastructure management.

This skill draws from the production MCP server powering the Buddy™ agent at googleadsagent.ai™, deployed on Cloudflare Workers in the workers/buddy-agent/ directory. That server exposes Google Ads analysis tools, knowledge base search, entity memory management, and web search capabilities through MCP, making them available to any MCP-compatible client. The architecture handles authentication, rate limiting, and multi-tenant isolation at the edge.

The MCP specification defines three core primitives: tools (executable functions the agent can invoke), resources (read-only data the agent can access), and prompts (reusable prompt templates). A well-designed MCP server exposes a focused set of high-value tools with clear schemas, meaningful descriptions, and robust error handling. The transport layer supports both stdio (for local development) and SSE/HTTP (for remote deployment), with authentication integrated at the transport level.

Use When

• You need to expose custom tools to AI agents through a standardized protocol
• Building integrations that work across Claude Code, Cursor, and other MCP clients
• Deploying agent tools to Cloudflare Workers for global edge access
• Creating a tool marketplace or shared tooling infrastructure for your organization
• Migrating from proprietary tool interfaces to the open MCP standard
• Your agent needs tools that require server-side secrets or API access

How It Works

graph TD
    A[AI Agent / MCP Client] -->|MCP Protocol| B[Transport Layer]
    B -->|stdio| C[Local Development]
    B -->|SSE/HTTP| D[Remote Server]
    D --> E[Cloudflare Worker]
    E --> F[Authentication]
    F --> G[Tool Router]
    G --> H[Tool: search_knowledge]
    G --> I[Tool: analyze_campaign]
    G --> J[Tool: get_metrics]
    H --> K[Knowledge Base]
    I --> L[Google Ads API]
    J --> L
    G --> M[Resource: config]
    G --> N[Resource: schema]

The MCP server sits between the AI agent client and the actual data sources or APIs. The transport layer handles protocol negotiation (stdio for local, SSE/HTTP for remote). For Cloudflare Workers deployment, incoming requests are authenticated (OAuth, API key, or JWT), then routed to the appropriate tool handler. Each tool handler implements the business logic — calling external APIs, querying databases, or performing computations — and returns structured results that the agent can reason over.

Implementation

MCP Server on Cloudflare Workers:

import { McpAgent } from "agents/mcp";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";

export class BuddyMCPServer extends McpAgent {
  server = new McpServer({
    name: "buddy-agent",
    version: "1.0.0",
  });

  async init() {
    this.server.tool(
      "search_knowledge",
      "Search the Google Ads knowledge base for patterns and best practices matching a query. Use BEFORE making recommendations.",
      { query: z.string(), category: z.enum(["bidding", "targeting", "creative", "budget", "general"]).optional(), maxResults: z.number().default(5) },
      async ({ query, category, maxResults }) => {
        const results = await this.searchKnowledgeBase(query, category, maxResults);
         { : [{ : , : .(results, , ) }] };
      }
    );

    ..(
      ,
      ,
      { : z.(), : z.([, , ]).(), : z.(z.()).() },
       ({ campaignId, dateRange, metrics }) => {
         analysis =  .(campaignId, dateRange, metrics);
         { : [{ : , : .(analysis, , ) }] };
      }
    );

    ..(
      ,
      ,
      { : z.(), : z.([, , , ]), : z.(), : z.().().().() },
       ({ userId, entityType, content, importance }) => {
         .(userId, entityType, content, importance);
         { : [{ : , :  }] };
      }
    );
  }

    () {
     patterns =  ...({ : category ?  :  });
     results = [];
     ( key  patterns..(, limit || )) {
       pattern =  ...(key., );
       (pattern && .(query, pattern)) {
        results.(pattern);
      }
    }
     results;
  }
}

Wrangler Configuration:

// wrangler.jsonc
{
  "name": "buddy-mcp-server",
  "main": "src/index.ts",
  "compatibility_date": "2025-01-01",
  "compatibility_flags": ["nodejs_compat"],
  "kv_namespaces": [
    { "binding": "KNOWLEDGE_KV", "id": "your-kv-id" },
    { "binding": "MEMORY_KV", "id": "your-memory-kv-id" }
  ],
  "vars": {
    "ENVIRONMENT": "production"
  },
  "placement": { "mode": "smart" 

MCP Client Configuration (Claude Code):

{
  "mcpServers": {
    "buddy-agent": {
      "type": "sse",
      "url": "https://buddy-mcp.googleadsagent.ai/sse",
      "headers": {
        "Authorization": "Bearer ${BUDDY_API_KEY}"
      }
    }
  }
}

MCP Client Configuration (Cursor):

{
  "mcpServers": {
    "buddy-agent": {
      "url": "https://buddy-mcp.googleadsagent.ai/sse",
      "headers": {
        "Authorization": "Bearer ${BUDDY_API_KEY}"
      }
    }
  }
}

Local Development with stdio Transport:

import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

const server = new McpServer({ name: "buddy-agent-dev", version: "1.0.0-dev" });

server.tool(
  "search_knowledge",
  "Search the local knowledge base for development and testing.",
  { query: z.string() },
  async ({ query }) => {
    const results = searchLocalKnowledge(query);
    return { content: [{ type: "text", text: JSON.stringify(results) }] };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Best Practices

1. Write tool descriptions that explain when to use the tool — the AI agent selects tools based on descriptions; "Use BEFORE making recommendations" is actionable guidance the model can follow.
2. Use Zod schemas with descriptive enums — constrained parameter types eliminate invalid inputs; enums are especially effective at guiding model parameter selection.
3. Return structured JSON, not prose — structured results are easier for the model to reason over and consume fewer tokens than narrative responses.
4. Implement authentication at the transport layer — never expose MCP servers without authentication; use OAuth, JWT, or API keys validated before tool routing.
5. Keep tool count focused — 5-10 well-designed tools outperform 50 overlapping tools; models perform better with fewer, clearer choices.
6. Test with multiple MCP clients — behavior can differ across Claude Code, Cursor, and other clients; test tool invocation on each target client.
7. Deploy to the edge with Cloudflare Workers — edge deployment minimizes latency for geographically distributed users and provides built-in DDoS protection.
8. Version your MCP server — as tools evolve, maintain backward compatibility or clearly version-bump to avoid breaking existing client configurations.

Platform Compatibility

Feature	Claude Code	Cursor	Codex	Gemini CLI
MCP client support	✅ Native	✅ Native	⚠️ Limited	⚠️ Limited
stdio transport	✅ Full	✅ Full	⚠️ Custom	⚠️ Custom
SSE transport	✅ Full	✅ Full	⚠️ Custom	⚠️ Custom
Tool discovery	✅ Automatic	✅ Automatic	⚠️ Manual	⚠️ Manual
OAuth support	✅ Full	✅ Full	⚠️ Custom	⚠️ Custom

Related Skills

• Multi-Model Routing - MCP servers can integrate model routing logic into tool execution pipelines
• Knowledge Base Injection - Knowledge search tools are exposed through MCP for agent-accessible domain expertise
• Parallel Agent Orchestration - MCP tools enable standardized tool access for parallel subagent dispatch
• Shopping Ads - Merchant Center integration via MCP enables automated product feed management

Keywords

mcp-server, model-context-protocol, cloudflare-workers, tool-definitions, resource-handlers, sse-transport, stdio-transport, authentication, edge-deployment, agent-skills

---

© 2026 googleadsagent.ai™ | Agent Skills™ | MIT License