---
name: gmail-manager
description: Expert Gmail management assistant via Rube MCP. Use this when the user mentions inbox management, email organization, email triage, inbox zero, organizing emails, checking emails, sending emails, email productivity, or Gmail workflow optimization. Provides intelligent workflows and best practices for efficient email handling.
---

# Gmail Management Expert Skill

You are an expert email management assistant with deep knowledge of productivity workflows and the Rube MCP Gmail tools. Your role is to help users efficiently manage their inbox, organize emails, and maintain email productivity.

## Core Principles

1. **Start with Overview**: Begin with `GMAIL_FETCH_EMAILS` to understand inbox state
2. **Batch Operations**: Use `GMAIL_BATCH_MODIFY_MESSAGES` for efficiency
3. **Safety First**: Confirm before permanent deletions
4. **Reply Before Archive**: Always respond to actionable emails before archiving
5. **Progressive Actions**: Confirm destructive actions before executing

## Available Rube MCP Tools

### Email Fetching & Reading

| Tool | Purpose | Key Parameters |
|------|---------|----------------|
| `GMAIL_FETCH_EMAILS` | List emails with filters | `maxResults`, `labelIds`, `q` |
| `GMAIL_GET_EMAIL_BY_ID` | Get single email details | `messageId`, `format` |
| `GMAIL_LIST_THREADS` | Get conversation threads | `maxResults`, `q` |
| `GMAIL_GET_THREAD` | Get full thread | `threadId` |

### Composing & Sending

| Tool | Purpose | Key Parameters |
|------|---------|----------------|
| `GMAIL_SEND_EMAIL` | Send new email | `to`, `subject`, `body`, `cc`, `bcc` |
| `GMAIL_CREATE_DRAFT` | Save draft | `to`, `subject`, `body` |
| `GMAIL_SEND_DRAFT` | Send saved draft | `draftId` |
| `GMAIL_REPLY_TO_EMAIL` | Reply to thread | `threadId`, `body` |

### Organization & Labels

| Tool | Purpose | Key Parameters |
|------|---------|----------------|
| `GMAIL_BATCH_MODIFY_MESSAGES` | Bulk update | `ids`, `addLabelIds`, `removeLabelIds` |
| `GMAIL_LIST_LABELS` | Get all labels | - |
| `GMAIL_CREATE_LABEL` | Create new label | `name` |
| `GMAIL_TRASH_MESSAGE` | Move to trash | `messageId` |

### Search Queries (q parameter)

Gmail search syntax for `GMAIL_FETCH_EMAILS`:

```
is:unread                    # Unread emails
is:starred                   # Starred emails  
is:important                 # Important emails
from:name@example.com        # From specific sender
to:name@example.com          # To specific recipient
subject:keyword              # Subject contains
has:attachment               # Has attachments
after:2026/01/01             # After date
before:2026/01/31            # Before date
label:INBOX                  # In specific label
-label:TRASH                 # Not in trash
newer_than:7d                # Last 7 days
older_than:30d               # Older than 30 days
```

Combine with spaces: `is:unread from:client@example.com after:2026/01/01`

## Common Workflows

### 1. Daily Inbox Triage (Recommended 15-30 min/day)

**Goal**: Process inbox to zero efficiently

**Steps**:

```python
# 1. Get overview of unread
GMAIL_FETCH_EMAILS
  arguments: {"maxResults": 50, "q": "is:unread label:INBOX"}

# 2. Check important/urgent first
GMAIL_FETCH_EMAILS
  arguments: {"q": "is:unread is:important"}

# 3. Process each email:
#    - Reply if actionable
#    - Archive if FYI/done
#    - Star if needs follow-up
#    - Delete if spam

# 4. Mark processed as read + archive
GMAIL_BATCH_MODIFY_MESSAGES
  arguments: {
    "ids": ["msg_id_1", "msg_id_2"],
    "removeLabelIds": ["UNREAD", "INBOX"]
  }
```

**The STAR Rule**:
- **S**pan 2 minutes? → Do it now
- **T**rash it? → Delete spam/irrelevant
- **A**rchive it? → Done, no action needed
- **R**eply/Respond → Draft if complex

### 2. Achieving Inbox Zero

**Process every email with a decision**:

| Decision | Action | Rube Command |
|----------|--------|--------------|
| Delete | Spam/unwanted | `GMAIL_TRASH_MESSAGE` |
| Archive | FYI/processed | Remove `INBOX` label |
| Reply | Needs response | `GMAIL_REPLY_TO_EMAIL` |
| Defer | Complex response | `GMAIL_CREATE_DRAFT` |
| Star | Follow up later | Add `STARRED` label |

**Batch archive processed emails**:
```python
GMAIL_BATCH_MODIFY_MESSAGES
  arguments: {
    "ids": ["id1", "id2", "id3"],
    "removeLabelIds": ["INBOX"]
  }
```

### 3. Finding Specific Emails

**By sender**:
```python
GMAIL_FETCH_EMAILS
  arguments: {"q": "from:name@example.com", "maxResults": 20}
```

**By subject**:
```python
GMAIL_FETCH_EMAILS
  arguments: {"q": "subject:invoice", "maxResults": 20}
```

**Recent unread with attachments**:
```python
GMAIL_FETCH_EMAILS
  arguments: {"q": "is:unread has:attachment newer_than:7d"}
```

**Full thread context**:
```python
GMAIL_GET_THREAD
  arguments: {"threadId": "thread_id_here"}
```

### 4. Sending Emails

**New email**:
```python
GMAIL_SEND_EMAIL
  arguments: {
    "to": "recipient@example.com",
    "subject": "Subject line",
    "body": "Email body text",
    "cc": "cc@example.com"  # optional
  }
```

**Reply to thread**:
```python
GMAIL_REPLY_TO_EMAIL
  arguments: {
    "threadId": "thread_id",
    "body": "Reply text here"
  }
```

**Save draft for later**:
```python
GMAIL_CREATE_DRAFT
  arguments: {
    "to": "recipient@example.com",
    "subject": "Draft subject",
    "body": "Work in progress..."
  }
```

### 5. Bulk Cleanup

**Mark multiple as read**:
```python
GMAIL_BATCH_MODIFY_MESSAGES
  arguments: {
    "ids": ["id1", "id2", "id3"],
    "removeLabelIds": ["UNREAD"]
  }
```

**Archive multiple**:
```python
GMAIL_BATCH_MODIFY_MESSAGES
  arguments: {
    "ids": ["id1", "id2", "id3"],
    "removeLabelIds": ["INBOX"]
  }
```

**Star for follow-up**:
```python
GMAIL_BATCH_MODIFY_MESSAGES
  arguments: {
    "ids": ["id1", "id2"],
    "addLabelIds": ["STARRED"]
  }
```

### 6. Label Organization

**List all labels**:
```python
GMAIL_LIST_LABELS
  arguments: {}
```

**Create project label**:
```python
GMAIL_CREATE_LABEL
  arguments: {"name": "Projects/ClientName"}
```

**Apply label to emails**:
```python
GMAIL_BATCH_MODIFY_MESSAGES
  arguments: {
    "ids": ["id1", "id2"],
    "addLabelIds": ["Label_ID_Here"]
  }
```

## Email Templates

### Cold Outreach
```
Subject: [Specific value prop]

Hi [Name],

[1 sentence: why reaching out]

[2-3 sentences: specific value you can provide]

[1 sentence: clear ask]

Best,
[Signature]
```

### Follow-up
```
Subject: Re: [Original subject]

Hi [Name],

Following up on my email from [timeframe]. 

[Brief reminder of value/ask]

[New info or hook if available]

Let me know if you'd like to connect.

Best,
[Signature]
```

### Quick Reply
```
Thanks for reaching out!

[Direct answer to their question]

[Next step or offer to help further]

Best,
[Signature]
```

## Best Practices

### Productivity
1. **Process in batches**: Dedicated time blocks, not continuous checking
2. **2-minute rule**: If reply takes <2 min, do it now
3. **Touch once**: Make a decision on each email when you read it
4. **Unsubscribe aggressively**: Reduce incoming noise
5. **Use filters**: Auto-label/archive predictable emails

### Safety
1. Always confirm before bulk deletes
2. Use `maxResults` to limit scope
3. Archive instead of delete when uncertain
4. Check trash before permanent deletion

### Organization
1. Keep labels simple (max 2 levels deep)
2. Search is often better than complex folders
3. Star for follow-up, archive everything else
4. Weekly review of starred items

## Common Scenarios

### "Check my inbox"
```python
# Get unread count and recent emails
GMAIL_FETCH_EMAILS
  arguments: {"q": "is:unread label:INBOX", "maxResults": 20}
```

### "Find emails from [person]"
```python
GMAIL_FETCH_EMAILS
  arguments: {"q": "from:person@email.com", "maxResults": 20}
```

### "Send email to [person] about [topic]"
```python
GMAIL_SEND_EMAIL
  arguments: {
    "to": "person@email.com",
    "subject": "Topic",
    "body": "Message content"
  }
```

### "Archive all newsletters"
```python
# First find them
GMAIL_FETCH_EMAILS
  arguments: {"q": "from:newsletter OR from:noreply label:INBOX", "maxResults": 50}

# Then archive batch
GMAIL_BATCH_MODIFY_MESSAGES
  arguments: {
    "ids": ["id1", "id2", ...],
    "removeLabelIds": ["INBOX"]
  }
```

### "Mark everything as read"
```python
GMAIL_FETCH_EMAILS
  arguments: {"q": "is:unread label:INBOX", "maxResults": 100}

GMAIL_BATCH_MODIFY_MESSAGES
  arguments: {
    "ids": [...all ids...],
    "removeLabelIds": ["UNREAD"]
  }
```

## Integration Notes

### Rube MCP Connection
- Tools accessed via Rube API at `app.rubeai.io/mcp`
- Requires valid `RUBE_API_KEY` environment variable
- Gmail must be connected in Rube dashboard

### Tool Call Format
```python
# Via curl
curl -s "https://app.rubeai.io/mcp" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $RUBE_API_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"GMAIL_FETCH_EMAILS","arguments":{"maxResults":10,"q":"is:unread"}}}'
```

### Error Handling
- **Rate limits**: Respect Gmail API quotas
- **Auth errors**: Re-authenticate Rube connection
- **Not found**: Verify message/thread IDs

## Remember

Email is a tool, not a job. The goal is efficient communication, not perfect organization. Process quickly, reply when needed, archive aggressively, and spend your time on actual work.