All posts

Central circuit board with radiating arrows and Google Workspace app icons on dark blue background

How TPMs Can Build an MCP Server That Connects to Google Workspace — And Automate Everything

May 26, 202610 min readUpdated Sep 6, 2026

Imagine asking Gemini: "What's blocking the Android launch? Summarize the last 7 days of emails, check the project tracker, and draft a status update to the VP." And it just… does it. No copy-pasting. No tab-switching. No hour-long context-gathering ritual before every weekly review.

That's not a fantasy. That's the Model Context Protocol (MCP) — and it's available right now. This guide shows TPMs exactly how to build an MCP server that connects Gemini (or any MCP-compatible AI) to Google Workspace, and walks through 15+ automation ideas that will change how you operate.

What Is MCP, and Why Should Every TPM Care?

The Model Context Protocol is an open standard created by Anthropic (and adopted by Google, OpenAI, and others) that lets AI models call tools in a structured, secure way. Think of it as a USB standard for AI integrations — instead of every AI having proprietary plugins, MCP gives any compliant AI a consistent way to reach out to external systems.

For TPMs, this matters enormously. Our job is fundamentally about context aggregation — pulling signals from Jira, Docs, Gmail, Slides, Calendar, and Sheets, synthesizing them, and making decisions. MCP lets your AI do that aggregation for you, on demand, in real time.

The TPM's Daily Context Tax

Before you can even start thinking, you spend 90 minutes every morning:

Reading 40+ emails for status signals
Scanning your Calendar for upcoming deadlines and stakeholder meetings
Pulling up the shared Tracker Sheet to check milestones
Checking Drive for the latest PRD or design doc
Writing status summaries from scratch

An MCP server eliminates that tax. You ask one question, and your AI agent does all of the above in seconds.

Architecture: How a TPM-Focused MCP Server Works

Here's the high-level architecture:

┌──────────────────────────────────────┐
│         AI Client (Gemini/Claude)    │
│         "What's blocking launch?"    │
└──────────────────┬───────────────────┘
                   │ MCP Protocol (JSON-RPC over stdio/SSE)
                   ▼
┌──────────────────────────────────────┐
│         Your MCP Server (Node.js)    │
│                                      │
│  Tools:                              │
│  • gmail_search(query, days)         │
│  • calendar_upcoming(days)           │
│  • sheets_read(spreadsheetId, range) │
│  • drive_search(query)               │
│  • docs_get(docId)                   │
│  • gmail_draft(to, subject, body)    │
│  • calendar_create_event(...)        │
│  • sheets_append(spreadsheetId, ...) │
└──────┬──────┬──────┬──────┬──────────┘
       │      │      │      │
    Gmail  Calendar Drive  Sheets
       └──────┴──────┴──────┘
         Google Workspace APIs
         (OAuth 2.0 Service Account)

Getting Started: Setting Up Your MCP Server

Step 1: Project Setup

mkdir tpm-mcp-server && cd tpm-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk googleapis dotenv

Step 2: Google Cloud Setup

Create a project in Google Cloud Console
Enable APIs: Gmail API, Google Calendar API, Google Drive API, Google Sheets API
Create a Service Account and download the JSON key
Share your Google Workspace resources with the service account email (or use domain-wide delegation for full access)
Set the JSON key path in your .env:

# .env
GOOGLE_APPLICATION_CREDENTIALS=./service-account.json
[email protected]

Step 3: Create the MCP Server

// server.js
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { google } from 'googleapis';
import { z } from 'zod';

const auth = new google.auth.GoogleAuth({
  keyFile: process.env.GOOGLE_APPLICATION_CREDENTIALS,
  scopes: [
    'https://www.googleapis.com/auth/gmail.readonly',
    'https://www.googleapis.com/auth/gmail.compose',
    'https://www.googleapis.com/auth/calendar',
    'https://www.googleapis.com/auth/drive.readonly',
    'https://www.googleapis.com/auth/spreadsheets',
  ],
});

const gmail    = google.gmail({ version: 'v1', auth });
const calendar = google.calendar({ version: 'v3', auth });
const drive    = google.drive({ version: 'v3', auth });
const sheets   = google.sheets({ version: 'v4', auth });

const server = new McpServer({ name: 'tpm-gsuite', version: '1.0.0' });

// ── TOOL: Search Gmail ──
server.tool('gmail_search',
  { query: z.string(), maxResults: z.number().optional().default(10) },
  async ({ query, maxResults }) => {
    const res = await gmail.users.messages.list({
      userId: process.env.GMAIL_USER,
      q: query, maxResults,
    });
    const messages = await Promise.all(
      (res.data.messages || []).map(async ({ id }) => {
        const msg = await gmail.users.messages.get({
          userId: process.env.GMAIL_USER, id, format: 'metadata',
          metadataHeaders: ['Subject', 'From', 'Date'],
        });
        const h = msg.data.payload.headers;
        return {
          subject: h.find(x => x.name === 'Subject')?.value,
          from:    h.find(x => x.name === 'From')?.value,
          date:    h.find(x => x.name === 'Date')?.value,
          snippet: msg.data.snippet,
        };
      })
    );
    return { content: [{ type: 'text', text: JSON.stringify(messages, null, 2) }] };
  }
);

// ── TOOL: Get Upcoming Calendar Events ──
server.tool('calendar_upcoming',
  { days: z.number().default(7) },
  async ({ days }) => {
    const now  = new Date();
    const end  = new Date(now.getTime() + days * 86400000);
    const res  = await calendar.events.list({
      calendarId: 'primary', timeMin: now.toISOString(),
      timeMax: end.toISOString(), singleEvents: true, orderBy: 'startTime',
    });
    return { content: [{ type: 'text', text: JSON.stringify(res.data.items, null, 2) }] };
  }
);

// ── TOOL: Read Google Sheet ──
server.tool('sheets_read',
  { spreadsheetId: z.string(), range: z.string() },
  async ({ spreadsheetId, range }) => {
    const res = await sheets.spreadsheets.values.get({ spreadsheetId, range });
    return { content: [{ type: 'text', text: JSON.stringify(res.data.values, null, 2) }] };
  }
);

// ── TOOL: Draft Gmail ──
server.tool('gmail_draft',
  { to: z.string(), subject: z.string(), body: z.string() },
  async ({ to, subject, body }) => {
    const raw = Buffer.from(
      `To: ${to}\nSubject: ${subject}\nContent-Type: text/plain\n\n${body}`
    ).toString('base64url');
    await gmail.users.drafts.create({
      userId: process.env.GMAIL_USER,
      requestBody: { message: { raw } },
    });
    return { content: [{ type: 'text', text: 'Draft created successfully.' }] };
  }
);

// ── TOOL: Search Drive ──
server.tool('drive_search',
  { query: z.string(), maxResults: z.number().default(5) },
  async ({ query, maxResults }) => {
    const res = await drive.files.list({
      q: query, pageSize: maxResults,
      fields: 'files(id,name,modifiedTime,webViewLink)',
    });
    return { content: [{ type: 'text', text: JSON.stringify(res.data.files, null, 2) }] };
  }
);

// Start the server
const transport = new StdioServerTransport();
await server.connect(transport);
console.error('TPM MCP Server running on stdio');

15 Automations That Will Change How You Work

Once your MCP server is running and connected to Gemini or Claude Desktop, here are the prompts you can use immediately:

📊 Status & Reporting

"Weekly Status Draft" — "Search my Gmail for emails mentioning [project name] from the last 7 days. Check the milestone tracker in [Sheet ID] for red/yellow items. Draft a weekly status email to [VP name]."
"Blocker Radar" — "Scan Gmail for threads with words 'blocked', 'dependency', 'waiting on', 'need decision' from the last 3 days. Group them by project and format as a priority list."
"Launch Readiness Check" — "Read the launch checklist in [Doc ID] and cross-reference with the last 10 emails mentioning the launch. Identify which checklist items have no recent email activity (potential forgotten tasks)."

📅 Meeting Efficiency

"Pre-Meeting Brief" — "I have a meeting with [name] in 2 hours. Search Gmail for our last 5 email threads. Find any docs they shared in Drive. Summarize key discussion points."
"Auto Agenda Builder" — "Look at my calendar for tomorrow. For each meeting that has no description/agenda, search Gmail for recent context and write a proposed agenda. Create a draft email to all attendees."
"Meeting Load Analysis" — "Get my calendar for next 2 weeks. Calculate how many hours I spend in meetings per day. Identify meeting-free blocks of 2+ hours. Suggest 3 blocks for deep work."
"Recurring Meeting ROI" — "Look at my recurring meetings. For each one, find the last 3 email threads that were sent after the meeting. Assess whether decisions made in the meeting led to action."

📨 Email Triage

"Executive Escalation Filter" — "Search Gmail for emails from [VP/Director names]. Summarize each email in one sentence. Flag any that contain a question directed at me or a request."
"Unresponded Threads" — "Find email threads from the last 5 days where I was the last one to receive a message but haven't replied. Sort by age."
"Stakeholder Health Check" — "List every person in my Calendar for the next 2 weeks. Search Gmail for my last email exchange with each of them. Flag any stakeholder I haven't emailed in over 2 weeks."

📋 Documentation & Tracking

"Decision Log Auto-fill" — "Search Gmail for emails with words 'decision', 'we decided', 'agreed', 'going with' from the last 30 days. Extract each decision with context. Append them to the decision log spreadsheet [Sheet ID]."
"Risk Registry from Email" — "Scan Gmail for phrases like 'risk', 'concern', 'issue', 'problem', 'worried about' in project-related threads. Extract them with sender and date. Format as a risk registry table."
"OKR Progress from Docs" — "Get the OKR doc from Drive [ID]. For each Key Result, search Gmail and Sheets for evidence of progress. Summarize what's on track, at risk, or behind."

🚀 Launch & Delivery

"Go/No-Go Signal Aggregator" — "Read the go/no-go checklist doc. For each owner, search Gmail for their most recent sign-off or status on their checklist item. Build a dashboard view."
"Post-Mortem Prep" — "An incident happened [date]. Search Gmail for all threads mentioning [incident codename] between [date range]. Extract timeline events, people involved, and impact statements. Draft the timeline section of the post-mortem."

Useful MCP Servers & Resources from the Community

You don't have to build everything from scratch. The MCP ecosystem is growing fast:

modelcontextprotocol/servers — Official reference MCP server implementations (filesystem, GitHub, Slack, Google Maps, and more)
googleapis/google-auth-library-nodejs — Official Node.js Google auth library
Zapier MCP Server — Connect 6,000+ apps via Zapier through MCP
Cal.com MCP — Calendar management via MCP
MCP Inspector — CLI tool to test and debug your MCP server locally: npx @modelcontextprotocol/inspector node server.js
Claude Desktop — Native MCP client, add your server to claude_desktop_config.json
Gemini CLI / ADK — Google's agent development kit supports MCP servers as tools

GitHub Projects to Fork & Extend

github.com/modelcontextprotocol/typescript-sdk — The TypeScript SDK used in this guide
github.com/punkpeye/awesome-mcp-servers — Curated list of 200+ community MCP servers
github.com/google-gemini/cookbook — Gemini API examples including agent/tool patterns
github.com/anthropics/anthropic-cookbook — MCP examples and agent patterns

Connecting to Claude Desktop (5 minutes)

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "tpm-gsuite": {
      "command": "node",
      "args": ["/path/to/your/tpm-mcp-server/server.js"],
      "env": {
        "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/service-account.json",
        "GMAIL_USER": "[email protected]"
      }
    }
  }
}

Restart Claude Desktop. You'll see a 🔌 icon — your server is connected. Now type any of the prompts above and watch it work.

Security Considerations for Enterprise TPMs

Before deploying at Google or any large org:

Scopes: Request the minimum necessary OAuth scopes. Use gmail.readonly instead of gmail.modify unless you need to write
Service Account isolation: Use separate service accounts per MCP server instance
No secrets in code: Use Secret Manager (GCP) or 1Password Secret References
Audit logging: Log every tool call with timestamp, user, and parameters to Cloud Logging
Data residency: If your org has data sovereignty requirements, ensure your MCP server runs in the same region as your GCP project
Review with security team: Domain-wide delegation is powerful — get approval before using it

The Bigger Picture: TPMs as the AI Integration Layer

Here's the insight that changes everything: TPMs already are MCP servers — in human form. We aggregate context from dozens of sources, apply judgment, and produce synthesized outputs (status updates, risk assessments, decisions). MCP just lets us offload the mechanical parts of that to AI.

The TPMs who thrive in the next 5 years won't be the ones who resist AI — they'll be the ones who understand how to wire it into the systems their organizations already use. Building an MCP server is the most leveraged skill a TPM can develop right now.

Your first MCP server might take a weekend. Your second will take an afternoon. By your fifth, you'll be building them for your entire team — and shipping 10× more than the humans still reading emails one by one.

Quick Start Checklist

☐ Enable Gmail, Calendar, Drive, Sheets APIs in Google Cloud Console
☐ Create a service account and download JSON key
☐ npm install @modelcontextprotocol/sdk googleapis
☐ Copy the server.js template above and customize
☐ Test with MCP Inspector: npx @modelcontextprotocol/inspector node server.js
☐ Add to Claude Desktop or Gemini CLI config
☐ Run your first automation: "Summarize my last 7 days of project emails"
☐ Share your MCP server with your team

The tools are free. The APIs are documented. The protocol is open. The only thing between you and 10× productivity is an afternoon of coding. Let's build.

Reactions

Follow along

Get new posts as they publish, in whichever format you read.