get-claudia 1.55.12 → 1.55.14

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 1.55.14 (2026-03-16)
+
+- **LaunchAgent no longer bakes in --project-dir** -- The standalone background daemon now starts without a `--project-dir` argument. This forces a plist content change for all existing installs, which triggers an automatic LaunchAgent reload on next `claudia setup`, picking up the current Python daemon code. Previously, the plist could be identical across updates, leaving old daemon code running indefinitely even after `pip install --upgrade`.
+- **Cleanup of orphaned empty hash databases** -- On each startup, if the database is already unified and empty hash-named DB files exist (created by stale old-code daemon processes), they are silently removed. Prevents phantom databases from accumulating in `~/.claudia/memory/`.
+- **Root cause:** After the v1.55 consolidation, users whose LaunchAgent was running old pre-unified-DB code would see scheduled jobs (consolidation, backups, decay) operating against an empty `6af67351bcfa.db` while all real memories lived in `claudia.db`. Health check showed `schema_version: 0` and `-1` counts.
+
+## 1.55.13 (2026-03-16)
+
+- **Gmail & Calendar MCPs as standard options** -- The standalone `gmail` (`@gongrzhe/server-gmail-autoauth-mcp`) and `google-calendar` (`@gongrzhe/server-calendar-autoauth-mcp`) servers are now first-class options alongside workspace-mcp. Two paths for Google integration: Option A (lightweight, focused, fewer tools) and Option B (all-in-one workspace-mcp with Drive, Docs, Sheets, etc.). Both can coexist.
+- **Auto-detect Gmail/Calendar credentials** -- The installer now checks `~/.gmail-mcp/` and `~/.calendar-mcp/` for existing OAuth credentials. If found, it automatically adds `gmail` and `google-calendar` entries to `.mcp.json`. No manual config needed.
+- **Installer no longer removes standalone MCPs** -- Running `npx get-claudia google` (workspace-mcp setup) no longer deletes existing `gmail` or `google-calendar` entries. Both integration paths coexist safely.
+- **Completion message shows Google MCPs** -- The installer now lists detected Gmail and Calendar servers in the MCP config summary line.
+- **Updated docs** -- CLAUDE.md and .mcp.json.example files document both Google integration paths with setup instructions for each.
+
 ## 1.55.12 (2026-03-15)
 
 - **Feedback skill** -- New `/feedback` command lets users share bugs, ideas, or suggestions. Claudia collects system context (version, OS, memory count, daemon health), builds a pre-filled GitHub Discussion URL, and opens it in the browser. The user reviews and submits. No data is sent without their knowledge.

package/bin/google-setup.js

@@ -69,20 +69,27 @@ export function buildApiEnableUrl(projectNumber, tier) {
 }
 
 /**
- * Detect old Google MCP server entries in .mcp.json.
- * Returns { hasOldGmail, hasOldCalendar, hasWorkspace }.
+ * Detect Google MCP server entries in .mcp.json.
+ * Returns { hasGmail, hasCalendar, hasWorkspace }.
+ *
+ * gmail and google-calendar are valid standalone options (lightweight, focused),
+ * not legacy entries. They can coexist with google_workspace.
  */
 export function detectOldGoogleMcp(targetPath) {
   const mcpPath = join(targetPath, '.mcp.json');
-  const result = { hasOldGmail: false, hasOldCalendar: false, hasWorkspace: false };
+  const result = { hasGmail: false, hasCalendar: false, hasWorkspace: false,
+    // Keep backward-compat aliases for callers that check the old property names
+    get hasOldGmail() { return this.hasGmail; },
+    get hasOldCalendar() { return this.hasCalendar; },
+  };
 
   if (!existsSync(mcpPath)) return result;
 
   try {
     const config = JSON.parse(readFileSync(mcpPath, 'utf-8'));
     const servers = config.mcpServers || {};
-    result.hasOldGmail = !!servers.gmail;
-    result.hasOldCalendar = !!servers['google-calendar'];
+    result.hasGmail = !!servers.gmail;
+    result.hasCalendar = !!servers['google-calendar'];
     result.hasWorkspace = !!servers.google_workspace;
   } catch {
     // Malformed JSON
@@ -93,7 +100,7 @@ export function detectOldGoogleMcp(targetPath) {
 
 /**
  * Add or update the google_workspace entry in .mcp.json.
- * Removes old gmail and google-calendar entries if present.
+ * Keeps existing gmail and google-calendar entries (they are valid standalone options).
  * Creates .mcp.json if it doesn't exist.
  */
 export function setupGoogleWorkspace(targetPath, clientId, clientSecret, tier) {
@@ -113,9 +120,8 @@ export function setupGoogleWorkspace(targetPath, clientId, clientSecret, tier) {
 
   if (!config.mcpServers) config.mcpServers = {};
 
-  // Remove old entries
-  delete config.mcpServers.gmail;
-  delete config.mcpServers['google-calendar'];
+  // Note: gmail and google-calendar entries are kept if present.
+  // They are valid standalone options that can coexist with google_workspace.
 
   // Add/update google_workspace
   config.mcpServers.google_workspace = {

package/bin/index.js

@@ -962,6 +962,9 @@ async function main() {
       ensureDaemonMcpConfig(targetPath, venvPython);
     }
 
+    // Auto-detect and add Gmail/Calendar MCP entries if credentials exist
+    const googleMcpResult = ensureGoogleMcpEntries(targetPath);
+
     // Run preflight check to verify daemon can actually start
     if (daemonOk && existsSync(venvPython)) {
       renderer.update('daemon', 'active', 'running preflight...');
@@ -1001,7 +1004,7 @@ async function main() {
 
     // Register LaunchAgent for standalone daemon (macOS only)
     if (daemonOk && process.platform === 'darwin') {
-      await ensureLaunchAgent(venvPython, targetPath);
+      await ensureLaunchAgent(venvPython);
     }
 
     // MCP Config step: verify .mcp.json is correct and check stdio server count
@@ -1013,9 +1016,15 @@ async function main() {
       renderer.update('mcp', 'active', 'checking .mcp.json...');
       const mcpCheckResult = checkMcpConfig(targetPath);
       if (mcpCheckResult.hasDaemon && mcpCheckResult.stdioCount >= 1) {
-        const serverDetail = mcpCheckResult.stdioCount === 1
-          ? 'claudia-memory configured'
-          : `claudia-memory + ${mcpCheckResult.stdioCount - 1} other server${mcpCheckResult.stdioCount > 2 ? 's' : ''}`;
+        // Build detail string showing what's configured
+        const extras = [];
+        if (mcpCheckResult.stdioServers.includes('gmail')) extras.push('gmail');
+        if (mcpCheckResult.stdioServers.includes('google-calendar')) extras.push('calendar');
+        const otherCount = mcpCheckResult.stdioCount - 1 - extras.length;
+        const parts = ['claudia-memory'];
+        if (extras.length > 0) parts.push(extras.join(', '));
+        if (otherCount > 0) parts.push(`+${otherCount} more`);
+        const serverDetail = parts.join(' + ');
         renderer.update('mcp', 'done', serverDetail);
         if (!supportsInPlace) renderer.appendLine('mcp', 'done', serverDetail);
       } else if (mcpCheckResult.hasDaemon && mcpCheckResult.stdioCount === 0) {
@@ -1474,6 +1483,71 @@ function ensureDaemonMcpConfig(targetPath, venvPythonPath) {
   writeFileSync(mcpPath, JSON.stringify(config, null, 2) + '\n');
 }
 
+/**
+ * Ensure gmail and google-calendar MCP entries exist in .mcp.json
+ * if the user has credentials at ~/.gmail-mcp/ and ~/.calendar-mcp/.
+ * Does not overwrite existing entries. Only adds if credentials are found.
+ * Returns { addedGmail, addedCalendar } indicating what was added.
+ */
+function ensureGoogleMcpEntries(targetPath) {
+  const mcpPath = join(targetPath, '.mcp.json');
+  const result = { addedGmail: false, addedCalendar: false };
+
+  let config;
+  if (existsSync(mcpPath)) {
+    try {
+      config = JSON.parse(readFileSync(mcpPath, 'utf-8'));
+    } catch {
+      return result; // Malformed JSON -- don't touch
+    }
+  } else {
+    return result; // No .mcp.json yet (ensureDaemonMcpConfig creates it first)
+  }
+
+  if (!config.mcpServers) config.mcpServers = {};
+
+  const home = homedir();
+  let changed = false;
+
+  // Gmail: add if credentials exist and entry doesn't
+  const gmailOauthPath = join(home, '.gmail-mcp', 'gcp-oauth.keys.json');
+  const gmailCredsPath = join(home, '.gmail-mcp', 'credentials.json');
+  if (!config.mcpServers.gmail && existsSync(gmailOauthPath) && existsSync(gmailCredsPath)) {
+    config.mcpServers.gmail = {
+      command: 'npx',
+      args: ['-y', '@gongrzhe/server-gmail-autoauth-mcp@latest'],
+      env: {
+        GMAIL_OAUTH_PATH: gmailOauthPath,
+        GMAIL_CREDENTIALS_PATH: gmailCredsPath,
+      },
+    };
+    result.addedGmail = true;
+    changed = true;
+  }
+
+  // Google Calendar: add if credentials exist and entry doesn't
+  const calOauthPath = join(home, '.calendar-mcp', 'gcp-oauth.keys.json');
+  const calCredsPath = join(home, '.calendar-mcp', 'credentials.json');
+  if (!config.mcpServers['google-calendar'] && existsSync(calOauthPath) && existsSync(calCredsPath)) {
+    config.mcpServers['google-calendar'] = {
+      command: 'npx',
+      args: ['-y', '@gongrzhe/server-calendar-autoauth-mcp@latest'],
+      env: {
+        CALENDAR_OAUTH_PATH: calOauthPath,
+        CALENDAR_CREDENTIALS_PATH: calCredsPath,
+      },
+    };
+    result.addedCalendar = true;
+    changed = true;
+  }
+
+  if (changed) {
+    writeFileSync(mcpPath, JSON.stringify(config, null, 2) + '\n');
+  }
+
+  return result;
+}
+
 /**
  * Check .mcp.json configuration and return status.
  * Returns { hasDaemon, stdioCount, stdioServers }.
@@ -1501,7 +1575,7 @@ function checkMcpConfig(targetPath) {
  * The standalone daemon runs 24/7 for scheduled jobs (consolidation, decay, vault sync).
  * This is separate from the MCP daemon that Claude Code spawns per-session.
  */
-async function ensureLaunchAgent(venvPythonPath, projectDir) {
+async function ensureLaunchAgent(venvPythonPath) {
   const plistDir = join(homedir(), 'Library', 'LaunchAgents');
   const plistPath = join(plistDir, 'com.claudia.memory.plist');
 
@@ -1517,8 +1591,6 @@ async function ensureLaunchAgent(venvPythonPath, projectDir) {
         <string>-m</string>
         <string>claudia_memory</string>
         <string>--standalone</string>
-        <string>--project-dir</string>
-        <string>${projectDir}</string>
     </array>
     <key>WorkingDirectory</key>
     <string>${join(homedir(), '.claudia', 'daemon')}</string>
@@ -1713,9 +1785,9 @@ async function runGoogleSetup() {
   // Detect existing state
   const state = detectOldGoogleMcp(targetPath);
 
-  if (state.hasOldGmail || state.hasOldCalendar) {
-    console.log(` ${colors.yellow}→${colors.reset} Found old Gmail/Calendar MCP servers. These will be replaced.`);
-    console.log(`   ${colors.dim}Same GCP credentials work with the new server.${colors.reset}`);
+  if (state.hasGmail || state.hasCalendar) {
+    console.log(` ${colors.yellow}→${colors.reset} Found standalone Gmail/Calendar MCP servers. These will be kept.`);
+    console.log(`   ${colors.dim}Both options work side by side. Workspace MCP adds Drive, Docs, Sheets, and more.${colors.reset}`);
     console.log('');
   }
 
@@ -1761,8 +1833,8 @@ async function runGoogleSetup() {
   console.log('');
   console.log(` ${colors.cyan}✓${colors.reset} Google Workspace MCP configured (${colors.bold}${tier}${colors.reset} tier)`);
 
-  if (state.hasOldGmail || state.hasOldCalendar) {
-    console.log(` ${colors.cyan}✓${colors.reset} Old Gmail/Calendar entries removed`);
+  if (state.hasGmail || state.hasCalendar) {
+    console.log(` ${colors.cyan}✓${colors.reset} Standalone Gmail/Calendar MCP servers kept alongside Workspace`);
   }
 
   // Build one-click API enablement URL

package/memory-daemon/claudia_memory/__main__.py

@@ -195,7 +195,16 @@ def _auto_consolidate() -> None:
                 fetch=True,
             )
             if rows and rows[0]["value"] == "true":
-                logger.debug("Database already unified, skipping consolidation")
+                # Unified. Clean up any empty hash DBs that stale daemon instances may have
+                # created (old standalone daemons running pre-unified-DB code create a fresh
+                # empty hash DB on startup if the original was deleted by consolidation).
+                all_hash_dbs = scan_hash_databases(memory_dir)
+                empty_dbs = [d for d in all_hash_dbs if not d["has_data"]]
+                if empty_dbs:
+                    logger.info(
+                        f"Removing {len(empty_dbs)} empty hash DB(s) left by stale standalone daemon"
+                    )
+                    cleanup_old_databases(memory_dir, empty_dbs)
                 return
         except Exception:
             pass  # _meta table might not exist yet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.55.12",
+  "version": "1.55.14",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/.mcp.json.example

@@ -6,6 +6,24 @@
       "_description": "Claudia memory system with vector search",
       "_setup": "Auto-configured by the installer (npx get-claudia). The installer creates a Python venv at ~/.claudia/daemon/venv/ and sets the correct command path in .mcp.json automatically."
     },
+    "gmail": {
+      "command": "npx",
+      "args": ["-y", "@gongrzhe/server-gmail-autoauth-mcp@latest"],
+      "env": {
+        "GMAIL_OAUTH_PATH": "",
+        "GMAIL_CREDENTIALS_PATH": ""
+      },
+      "_setup": "Lightweight Gmail-only MCP. Requires Google Cloud OAuth credentials. Run: npx @gongrzhe/server-gmail-autoauth-mcp auth"
+    },
+    "google-calendar": {
+      "command": "npx",
+      "args": ["-y", "@gongrzhe/server-calendar-autoauth-mcp@latest"],
+      "env": {
+        "CALENDAR_OAUTH_PATH": "",
+        "CALENDAR_CREDENTIALS_PATH": ""
+      },
+      "_setup": "Lightweight Calendar-only MCP. Requires Google Cloud OAuth credentials. Run: npx @gongrzhe/server-calendar-autoauth-mcp auth"
+    },
     "google_workspace": {
       "command": "uvx",
       "args": ["workspace-mcp", "--tool-tier", "core"],
@@ -13,7 +31,7 @@
         "GOOGLE_OAUTH_CLIENT_ID": "",
         "GOOGLE_OAUTH_CLIENT_SECRET": ""
       },
-      "_setup": "Google Workspace MCP: Gmail, Calendar, Drive, Docs, Sheets, Tasks, and more in one server. Requires Google Cloud OAuth credentials. See Google Integration Setup in CLAUDE.md. Tool tiers: core (43 tools), extended (83), complete (111). Start with core.",
+      "_setup": "All-in-one Google Workspace MCP: Gmail, Calendar, Drive, Docs, Sheets, Tasks, and more. Alternative to the standalone gmail + google-calendar servers above. Requires Google Cloud OAuth credentials. See Google Integration Setup in CLAUDE.md.",
       "_tiers": {
         "core": "Gmail, Calendar, Drive, Contacts (43 tools, recommended default)",
         "extended": "Adds Docs, Sheets, Tasks, Chat (83 tools)",
@@ -33,7 +51,8 @@
 
   "_notes": {
     "memory": "Claudia's memory is powered by the claudia-memory daemon (Python MCP server). It provides ~33 tools for semantic search, pattern detection, and relationship tracking. The installer (npx get-claudia) automatically sets up the daemon in a Python venv at ~/.claudia/daemon/venv/ and configures .mcp.json.",
-    "google_workspace": "Google Workspace uses the workspace-mcp server (taylorwilsdon/google_workspace_mcp). One server covers Gmail, Calendar, Drive, Docs, Sheets, Tasks, and more. Tool tiers control context usage. See Google Integration Setup in CLAUDE.md.",
+    "google_options": "Two paths for Google integration: (A) gmail + google-calendar (lightweight, focused, fewer tools) or (B) google_workspace via workspace-mcp (all-in-one, more tools). Both can coexist. See Google Integration Setup in CLAUDE.md.",
+    "google_workspace": "Google Workspace uses the workspace-mcp server (taylorwilsdon/google_workspace_mcp). One server covers Gmail, Calendar, Drive, Docs, Sheets, Tasks, and more. Tool tiers control context usage.",
     "rube": "Rube (by Composio) connects 500+ apps through one HTTP MCP connection. Each user creates their own free Rube account at rube.app. See the Rube section in CLAUDE.md for setup and troubleshooting.",
     "security": "Each user authenticates with their own accounts and credentials. OAuth tokens are stored locally on your machine, never shared.",
     "not_included": {

package/template-v2/CLAUDE.md

@@ -319,9 +319,20 @@ I adapt to whatever tools are available. When you ask me to do something that ne
 
 **Obsidian vault:** My memory syncs to an Obsidian vault at `~/.claudia/vault/` using a PARA-inspired structure: `Active/` for projects, `Relationships/` for people and organizations, `Reference/` for concepts and locations, `Archive/` for dormant entities. Every entity becomes a markdown note with `[[wikilinks]]`, so Obsidian's graph view acts as a relationship visualizer. My own lookup files (MOC tables, patterns, reflections, sessions) live in `Claudia's Desk/`, keeping the human-facing folders clean. The vault syncs on-demand via `claudia vault sync`. SQLite remains the source of truth; the vault is a read projection.
 
-**Google Workspace (MCP):** Google Workspace is provided by the workspace-mcp server ([taylorwilsdon/google_workspace_mcp](https://github.com/taylorwilsdon/google_workspace_mcp)). One server covers Gmail, Calendar, Drive, Docs, Sheets, Tasks, Contacts, and more. Tool tiers control how many tools are exposed: `--tool-tier core` (43 tools, default), `--tool-tier extended` (83 tools), or `--tool-tier complete` (111 tools). When connected, I have access to Gmail, Calendar, Drive, Docs, Sheets, Tasks, and more. I use these tools naturally when you ask me to check email, send messages, look at your calendar, search Drive, or work with documents.
+**Google Integration:** Two paths are available for connecting Google services:
 
-If the MCP tools aren't responding or you see authentication errors, the user needs to set up their Google Cloud credentials. See the **Google Integration Setup** section below.
+**Option A: Gmail + Calendar MCPs** (lightweight, focused)
+- Two separate servers: `gmail` (`@gongrzhe/server-gmail-autoauth-mcp`) and `google-calendar` (`@gongrzhe/server-calendar-autoauth-mcp`)
+- Fewer tools, lower context usage
+- Auth: `npx @gongrzhe/server-gmail-autoauth-mcp auth` and `npx @gongrzhe/server-calendar-autoauth-mcp auth`
+- Credentials stored at `~/.gmail-mcp/` and `~/.calendar-mcp/`
+
+**Option B: Google Workspace MCP** (all-in-one)
+- One server (`google_workspace` via [workspace-mcp](https://github.com/taylorwilsdon/google_workspace_mcp)) covers Gmail, Calendar, Drive, Docs, Sheets, Tasks, Contacts, and more
+- Tool tiers: `--tool-tier core` (43 tools, default), `--tool-tier extended` (83 tools), `--tool-tier complete` (111 tools)
+- Auth: `npx get-claudia google` for guided setup
+
+Both options can coexist in `.mcp.json`. When both are present, I use whichever tools are available. If the MCP tools aren't responding or you see authentication errors, the user needs to set up their Google Cloud credentials. See the **Google Integration Setup** section below.
 
 **Rube (500+ Apps):** Rube (by Composio) is an optional MCP aggregator that connects Claudia to hundreds of apps through a single server. Each user creates their own free Rube account, connects the apps they want via one-click OAuth, and Claudia gets access to all of them through one MCP connection.
 
@@ -346,7 +357,7 @@ If a user asks about connecting apps, integrations, or any of the services liste
 | **Calendar** | Google Calendar, Outlook Calendar, Calendly |
 | **And 500+ more** | Browse the full list at [rube.app](https://rube.app) |
 
-**External integrations** (Google Workspace, Rube, Brave Search) are optional add-ons that extend what I can see and do. I work fully without them. The core value is relationships and context.
+**External integrations** (Gmail, Calendar, Google Workspace, Rube, Brave Search) are optional add-ons that extend what I can see and do. I work fully without them. The core value is relationships and context.
 
 ### Rube Setup (Guide Users Through This)
 
@@ -401,13 +412,40 @@ The MCP tools from Rube will have names like `SLACK_SEND_MESSAGE`, `NOTION_CREAT
 | Rate limited | Rube has usage limits on the free tier. The user may need to upgrade at rube.app/pricing. |
 | Want to disconnect an app | Go to Rube dashboard and disconnect the app there. No Claudia config changes needed. |
 
-**Rube vs. workspace-mcp:** Rube works alongside (not instead of) the workspace-mcp server. Workspace-mcp gives a direct connection with no intermediary but requires Google Cloud setup. Rube gives one setup for everything but routes data through Composio servers. Both can coexist. If a user has both workspace-mcp and Rube's Google apps connected, prefer the direct workspace-mcp tools.
+**Rube vs. direct Google MCPs:** Rube works alongside (not instead of) the direct Google MCP servers (gmail, google-calendar, or workspace-mcp). Direct servers give a connection with no intermediary but require Google Cloud setup. Rube gives one setup for everything but routes data through Composio servers. All can coexist. If a user has both direct Google MCPs and Rube's Google apps connected, prefer the direct MCP tools.
 
 ### Google Integration Setup
 
-**Recommended:** Run `npx get-claudia google` for a guided setup that generates a one-click API enablement URL.
+Both Google integration paths require a Google Cloud project with OAuth credentials. The same GCP project works for either option.
 
-The workspace-mcp server requires your own Google Cloud credentials. Each user sets this up once:
+**Option A: Gmail + Calendar MCPs (lightweight)**
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com/)
+2. Create a new project (or select an existing one)
+3. Enable the **Gmail API** and **Google Calendar API** in APIs & Services > Library
+4. Create OAuth credentials (APIs & Services > Credentials > OAuth client ID, Desktop app type)
+5. Download the OAuth JSON file as `gcp-oauth.keys.json`
+6. Authenticate each service:
+   ```
+   npx @gongrzhe/server-gmail-autoauth-mcp auth
+   npx @gongrzhe/server-calendar-autoauth-mcp auth
+   ```
+   Each opens your browser for Google sign-in. Tokens stored at `~/.gmail-mcp/` and `~/.calendar-mcp/`.
+7. Set the paths in `.mcp.json`:
+   ```json
+   "gmail": {
+     "env": {
+       "GMAIL_OAUTH_PATH": "~/.gmail-mcp/gcp-oauth.keys.json",
+       "GMAIL_CREDENTIALS_PATH": "~/.gmail-mcp/credentials.json"
+     }
+   }
+   ```
+   (Same pattern for `google-calendar` with `~/.calendar-mcp/` paths.)
+8. Restart Claude Code.
+
+**Option B: Google Workspace MCP (all-in-one)**
+
+**Recommended:** Run `npx get-claudia google` for a guided setup that generates a one-click API enablement URL.
 
 1. Go to [Google Cloud Console](https://console.cloud.google.com/)
 2. Create a new project (or select an existing one)
@@ -443,7 +481,7 @@ The workspace-mcp server requires your own Google Cloud credentials. Each user s
 7. Restart Claude Code. On first run, the server opens your browser for Google sign-in. Tokens are stored locally for future sessions.
 8. **Re-authentication after enabling new APIs:** If you enable additional APIs after your initial sign-in, you must re-authenticate. Delete `~/.workspace-mcp/token.json` and restart Claude Code to trigger a new sign-in with the updated scopes.
 
-**Migrating from the old setup:** If you previously used separate Gmail and Calendar MCP servers, the same GCP project works. Just enable any additional APIs in your existing project, copy over the Client ID and Client Secret into `GOOGLE_OAUTH_CLIENT_ID` and `GOOGLE_OAUTH_CLIENT_SECRET`, and update `.mcp.json` to use the `google_workspace` server entry instead of the old individual entries.
+**Using both:** Option A and Option B can coexist. If you already have the standalone Gmail/Calendar MCPs and want to add Drive, Docs, etc., just add the `google_workspace` entry alongside them.
 
 ---