AI Productivity with MCP: How I Automated Gmail, Calendar, Slack, and Projects with Plain English

What This Article Covers

What Is MCP? (The 60-Second Explanation)

Model Context Protocol (MCP) is an open standard, introduced by Anthropic in November 2024, that gives AI models a standardized way to connect to external tools and services. Before MCP, every AI integration was custom-built, fragile, and tool-specific. MCP standardizes the entire interface.

The MCP Architecture (Three Layers)

┌─────────────────────────────────────────────────────────────────┐
│                        YOUR COMMAND                              │
│   "Prioritize my inbox and draft replies for urgent emails"      │
└─────────────────────────┬───────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────────────┐
│                    MCP CLIENT (Claude)                           │
│  • Receives your natural language command                        │
│  • Queries MCP server: "What tools are available?"               │
│  • Decides which tools to call and in what order                 │
│  • Returns structured response                                   │
└─────────────────────────┬───────────────────────────────────────┘
                          │  JSON-RPC 2.0 over stdio/HTTP/SSE
                          ▼
┌─────────────────────────────────────────────────────────────────┐
│                    MCP SERVER                                    │
│  • Exposes tools with JSON Schema definitions                    │
│  • Handles authentication to external services                  │
│  • Executes tool calls (read_emails, create_event, etc.)         │
│  • Returns results back to the client                           │
└────────────────┬────────────────┬───────────────┬───────────────┘
                 │                │               │
                 ▼                ▼               ▼
           ┌─────────┐     ┌──────────┐    ┌──────────┐
           │  Gmail  │     │ Calendar │    │  Slack   │
           │   API   │     │   API    │    │   API    │
           └─────────┘     └──────────┘    └──────────┘

Key insight: MCP uses JSON-RPC 2.0 as its transport protocol. Claude asks the server "list your tools," gets back a manifest of capabilities, then calls specific tools with arguments. This is why it works with any tool that has an API.

Two Ways to Set Up MCP: N8N vs. Zapier

Before building anything, choose your platform based on your technical comfort level.

Connecting Either Server to Claude Desktop

{
  "mcpServers": {
    "zapier": {
      "command": "npx",
      "args": ["-y", "@zapier/mcp-server"],
      "env": {
        "ZAPIER_API_KEY": "your-api-key-here"
      }
    },
    "n8n": {
      "command": "npx",
      "args": ["-y", "n8n-mcp"],
      "env": {
        "N8N_API_URL": "http://localhost:5678",
        "N8N_API_KEY": "your-n8n-api-key"
      }
    }
  }
}

Use Case 1: Email Command Center (Gmail + MCP)

The problem: 50+ emails per day. You spend 45 minutes sorting, prioritizing, and drafting replies—for email that could be summarized in 2 minutes.

The fix: Connect Gmail via MCP. Three plain-English commands replace your entire morning email routine.

N8N Setup (Step-by-Step)

Real-World Commands That Work

Net result: Email management drops from 60 minutes → 5 minutes per day.

Use Case 2: Calendar Command Center (Google Calendar + MCP)

The problem: Scheduling is fragmented. You check availability, create events, set recurrences, and manage attendees across multiple screens. It's 30 minutes of context-switching every morning.

The fix: Three calendar tools plus natural language = complete schedule control.

Three Tools You Need

Commands That Replace Your Calendar App

Net result: Calendar management drops from 30 minutes → 2 minutes per day.

Use Case 3: Slack Intelligence (Slack + MCP via Zapier)

The problem: Slack is a river of information. Hundreds of messages across dozens of channels. Finding what matters—announcements, action items, decisions—takes 45 minutes of manual scrolling.

The fix: Zapier MCP + Slack = instant intelligence from any channel.

Zapier Setup (5 Minutes)

{
  "mcpServers": {
    "zapier-slack": {
      "command": "npx",
      "args": ["-y", "@zapier/mcp-server"],
      "env": {
        "ZAPIER_API_KEY": "your-zapier-api-key"
      }
    }
  }
}

Commands for Slack Overload

Net result: Slack management drops from 45 minutes → 10 minutes per day.

Use Case 4: Data-to-Insights Pipeline (Airtable + MCP via Zapier)

The problem: Weekly reporting is a 4-hour slog. Fetch data from your database, analyze it in Excel, copy numbers into slides, format the deck, send to stakeholders. Every step is manual, error-prone, and mind-numbing.

The fix: A single Claude command triggers the entire pipeline—data fetch, analysis, slide creation, and Slack delivery.

The Three Tools Required

The End-to-End Reporting Command

Create a thorough analysis of our orders table in Airtable for this week.

Then:
1. Identify the top 3 trends in order volume
2. Flag any orders that are delayed beyond 5 days
3. Calculate total revenue vs. last week (percentage change)
4. Create a 3-slide summary presentation
5. Send the summary to #weekly-reports in Slack with the key numbers highlighted

Net result: Weekly reporting drops from 4 hours → 15 minutes.

Use Case 5: Project Management Automation (ClickUp + MCP via Zapier)

The problem: After every meeting you have a transcript full of action items. Someone has to read it, extract tasks, figure out who owns what, and manually create each item in your PM tool. Nobody does this consistently.

The fix: One command reads the transcript, extracts tasks, and creates them—with the right assignees, descriptions, and lists.

ClickUp Setup

Commands That Eliminate Manual Task Creation

Net result: Project management overhead drops from 60 minutes → 10 minutes per day.

Build Your Own MCP Server (TypeScript)

Ready to go beyond pre-built integrations? Here's how to build a production-ready custom MCP server. This uses the correct @modelcontextprotocol/sdk package (not the incorrect @modelcontextprotocol/server import sometimes shown in early tutorials).

Project Setup

mkdir my-mcp-server && cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx
npx tsc --init

Complete MCP Server (src/server.ts)

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  Tool,
} from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";

// Define your tool schemas with Zod for type safety
const SendEmailSchema = z.object({
  to: z.string().email(),
  subject: z.string().min(1),
  body: z.string().min(1),
  priority: z.enum(["normal", "urgent"]).default("normal"),
});

const GetEmailsSchema = z.object({
  filter: z.string().optional().describe("Search query (e.g., 'from:[email protected]')"),
  maxResults: z.number().int().min(1).max(100).default(20),
  unreadOnly: z.boolean().default(false),
});

// Tool definitions (sent to Claude at handshake)
const TOOLS: Tool[] = [
  {
    name: "send_email",
    description: "Send an email to one or more recipients",
    inputSchema: {
      type: "object",
      properties: {
        to: { type: "string", description: "Recipient email address" },
        subject: { type: "string", description: "Email subject line" },
        body: { type: "string", description: "Email body (plain text or HTML)" },
        priority: { type: "string", enum: ["normal", "urgent"], description: "Email priority" },
      },
      required: ["to", "subject", "body"],
    },
  },
  {
    name: "get_emails",
    description: "Retrieve emails from inbox with optional filtering",
    inputSchema: {
      type: "object",
      properties: {
        filter: { type: "string", description: "Gmail search query" },
        maxResults: { type: "number", description: "Max emails to return (1-100)" },
        unreadOnly: { type: "boolean", description: "Return only unread emails" },
      },
    },
  },
];

// Tool implementations
async function handleSendEmail(args: unknown) {
  const { to, subject, body, priority } = SendEmailSchema.parse(args);

  // In production: call Gmail API here
  // const gmail = google.gmail({ version: 'v1', auth });
  // await gmail.users.messages.send({ ... });

  console.error(`[send_email] Sending to ${to}: "${subject}" (priority: ${priority})`);

  return {
    content: [
      {
        type: "text" as const,
        text: `✅ Email sent successfully to ${to}\nSubject: ${subject}\nPriority: ${priority}`,
      },
    ],
  };
}

async function handleGetEmails(args: unknown) {
  const { filter, maxResults, unreadOnly } = GetEmailsSchema.parse(args);

  // In production: call Gmail API here
  // const response = await gmail.users.messages.list({ q: filter, maxResults });

  const query = [filter, unreadOnly ? "is:unread" : ""].filter(Boolean).join(" ");
  console.error(`[get_emails] Fetching ${maxResults} emails (query: "${query}")`);

  // Mock response for illustration
  return {
    content: [
      {
        type: "text" as const,
        text: JSON.stringify({
          count: maxResults,
          query,
          message: "In production, real Gmail API results would appear here",
        }, null, 2),
      },
    ],
  };
}

// Server initialization
const server = new Server(
  { name: "email-mcp-server", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

// Handle tool list requests (Claude calls this first)
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return { tools: TOOLS };
});

// Handle tool execution requests
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    switch (name) {
      case "send_email":
        return await handleSendEmail(args);
      case "get_emails":
        return await handleGetEmails(args);
      default:
        throw new Error(`Unknown tool: ${name}`);
    }
  } catch (error) {
    const message = error instanceof Error ? error.message : String(error);
    return {
      content: [{ type: "text" as const, text: `❌ Error in ${name}: ${message}` }],
      isError: true,
    };
  }
});

// Start server (communicates over stdio)
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Email MCP server running on stdio");
}

main().catch((err) => {
  console.error("Fatal error:", err);
  process.exit(1);
});

Register With Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "email-server": {
      "command": "npx",
      "args": ["tsx", "/path/to/my-mcp-server/src/server.ts"],
      "env": {
        "GMAIL_CLIENT_ID": "your-client-id",
        "GMAIL_CLIENT_SECRET": "your-client-secret",
        "GMAIL_REFRESH_TOKEN": "your-refresh-token"
      }
    }
  }
}

Adding Authentication

import express from "express";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";

const app = express();

// API key validation middleware
app.use("/mcp", async (req, res, next) => {
  const apiKey = req.headers["x-api-key"];

  if (!apiKey || !isValidApiKey(apiKey as string)) {
    return res.status(401).json({ error: "Invalid or missing API key" });
  }

  next();
});

// MCP endpoint
app.get("/mcp/sse", async (req, res) => {
  const transport = new SSEServerTransport("/mcp/messages", res);
  await server.connect(transport);
});

app.post("/mcp/messages", async (req, res) => {
  // Handle incoming messages
  await transport.handlePostMessage(req, res);
});

function isValidApiKey(key: string): boolean {
  // In production: check against your key store
  return key === process.env.MCP_API_KEY;
}

app.listen(3000);

Security and Privacy: What to Know Before You Connect

What Data MCP Servers Can Access

Performance: Real Time Savings

Common Mistakes (and How to Avoid Them)

Key Takeaways