# Complete Data Source Setup Guide for Claude

> Connect every tool your PM agents need, Jira, Slack, Zendesk, Salesforce, GitHub, Google Calendar, Gong, Amplitude, and more, using Claude's MCP protocol. Copy-paste ready configs for Claude Desktop, Claude Code, and Claude Projects.

---

## Overview

This guide walks you through connecting **every data source** referenced across all 18 PM agents in this toolkit. Once connected, your agents can read from Jira, Slack, Zendesk, Salesforce, GitHub, Google Calendar, analytics platforms, and more, all through Claude's native MCP (Model Context Protocol) infrastructure.

**What is MCP?** MCP is Anthropic's open standard that lets Claude connect directly to external tools and data sources. Instead of copy-pasting data into prompts, Claude reads it live. Think of it as giving Claude read access to your work tools.

**Three ways to run agents with Claude:**

| Method | Best For | Scheduling | MCP Support |
|--------|----------|------------|-------------|
| **Claude Desktop** | Interactive use, ad-hoc queries | Manual trigger | Full MCP support via config file |
| **Claude Code** | Developers, CLI workflows, automation | Cron jobs, CI/CD | Full MCP support via config + CLI |
| **Claude Projects** | Team collaboration, shared agents | Manual or API trigger | MCP via project settings |

---

## Part 1: Universal Prerequisites

Before connecting any data source, complete these steps:

### 1.1 Install Claude Desktop (if using Desktop)

1. Download Claude Desktop from https://claude.ai/download
2. Install and sign in with your Anthropic account
3. Verify MCP is available: open Settings (gear icon) then "Developer" tab
4. You should see a "Model Context Protocol" section

### 1.2 Install Claude Code (if using CLI)

```bash
# Install via npm
npm install -g @anthropic-ai/claude-code

# Verify installation
claude --version

# Authenticate
claude auth login
```

### 1.3 Locate Your MCP Config File

**Claude Desktop:**
- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
- Linux: `~/.config/Claude/claude_desktop_config.json`

**Claude Code:**
- Project-level: `.claude/mcp.json` in your project root
- Global: `~/.claude/mcp.json`

If the file doesn't exist, create it with this skeleton:

```json
{
  "mcpServers": {}
}
```

### 1.4 Install Node.js (Required for Most MCP Servers)

Most MCP servers run as Node.js processes. Install Node.js 18+ if you don't have it:

```bash
# Check if installed
node --version

# Install via nvm (recommended)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
nvm install 20
nvm use 20
```

### 1.5 Install uvx (Required for Python-Based MCP Servers)

Some MCP servers (like the PostgreSQL connector) use Python:

```bash
# Install uv (Python package manager)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Verify
uvx --version
```

---

## Part 2: Connect Your Issue Tracker (Jira / YouTrack / Linear)

**Used by:** Daily Focus, PM Issues, Documentation Gaps, Red Flag Detection, Product Ops, Roadmap Tracker, Team Triage, Product Health, Executive Report, Weekly Ops Digest, Engineering Capacity, Product Dashboard, Release Readiness, Release Checker, Customer Commitments

This is your most critical connection. Nearly every agent reads from your issue tracker.

### 2.1 Jira (via Atlassian MCP Server)

**Step 1: Generate an API Token**

1. Go to https://id.atlassian.com/manage-profile/security/api-tokens
2. Click "Create API token"
3. Name it "Claude MCP Access" (or similar)
4. Copy the token immediately, you won't see it again
5. Note your Atlassian email and your Jira instance URL (e.g., `https://yourcompany.atlassian.net`)

**Step 2: Install the Atlassian MCP Server**

```bash
npm install -g @anthropic-ai/mcp-server-atlassian
```

**Step 3: Add to Your MCP Config**

Open your config file and add this inside `"mcpServers"`:

```json
"atlassian": {
  "command": "mcp-server-atlassian",
  "env": {
    "ATLASSIAN_SITE_URL": "https://yourcompany.atlassian.net",
    "ATLASSIAN_USER_EMAIL": "your.email@company.com",
    "ATLASSIAN_API_TOKEN": "your-api-token-here"
  }
}
```

**Step 4: Verify the Connection**

Restart Claude Desktop (or run `claude` in your terminal for Claude Code). Then ask:

```
List all Jira projects I have access to.
```

If Claude returns your projects, the connection is working.

**Step 5: Test Agent-Relevant Queries**

```
Show me all Critical-priority issues in project PROD that are unresolved.
```

```
List all issues assigned to me with a due date in the next 7 days.
```

**Permissions note:** The API token inherits your Jira permissions. If you can see it in the browser, Claude can see it via MCP. For security, consider creating a dedicated service account with read-only access.

### 2.2 YouTrack

**Step 1: Generate a Permanent Token**

1. In YouTrack, go to your Profile (top-right avatar) then "Account Security"
2. Click "New token..."
3. Scope: `YouTrack` (read access is sufficient)
4. Copy the token

**Step 2: Install the YouTrack MCP Server**

```bash
npm install -g mcp-server-youtrack
```

**Step 3: Add to Your MCP Config**

```json
"youtrack": {
  "command": "mcp-server-youtrack",
  "env": {
    "YOUTRACK_URL": "https://yourcompany.youtrack.cloud",
    "YOUTRACK_TOKEN": "perm:your-token-here"
  }
}
```

**Step 4: Verify**

```
List all open issues in project PROD sorted by priority.
```

### 2.3 Linear

**Step 1: Create an API Key**

1. Go to Linear Settings then "API" then "Personal API keys"
2. Click "Create key"
3. Copy the key

**Step 2: Install the Linear MCP Server**

```bash
npm install -g @anthropic-ai/mcp-server-linear
```

**Step 3: Add to Your MCP Config**

```json
"linear": {
  "command": "mcp-server-linear",
  "env": {
    "LINEAR_API_KEY": "lin_api_your-key-here"
  }
}
```

---

## Part 3: Connect Slack

**Used by:** Daily Focus, PM Issues, Red Flag Detection, Product Ops, Team Triage, Product Health, Executive Report, Weekly Ops Digest, GTM Monitoring, Release Readiness, Customer Commitments

Slack is the second most critical connection. Agents scan channels for escalations, @mentions, blockers, and sentiment.

### 3.1 Create a Slack App (OAuth Method, Recommended)

**Step 1: Create the App**

1. Go to https://api.slack.com/apps
2. Click "Create New App" then "From scratch"
3. Name: "Claude PM Agent" (or your preference)
4. Select your workspace
5. Click "Create App"

**Step 2: Configure OAuth Scopes**

Go to "OAuth & Permissions" in the left sidebar. Under "Bot Token Scopes," add these scopes:

- `channels:history`, Read messages in public channels
- `channels:read`, List public channels
- `groups:history`, Read messages in private channels you're in
- `groups:read`, List private channels
- `im:history`, Read DMs (optional, for DM-based agents)
- `search:read`, Search messages
- `users:read`, Read user profiles (to map names to IDs)
- `chat:write`, Post messages (for agent output delivery)

**Step 3: Install to Workspace**

1. Click "Install to Workspace" at the top of the OAuth page
2. Review permissions and click "Allow"
3. Copy the "Bot User OAuth Token" (starts with `xoxb-`)

**Step 4: Invite the Bot to Channels**

In Slack, go to each channel your agents need to read:
- `#production-incidents`
- `#team-product`
- `#customer-escalations`
- `#roadmap`
- `#general` (or your main channel)

Type `/invite @Claude PM Agent` in each channel.

**Step 5: Install the Slack MCP Server**

```bash
npm install -g @anthropic-ai/mcp-server-slack
```

**Step 6: Add to Your MCP Config**

```json
"slack": {
  "command": "mcp-server-slack",
  "env": {
    "SLACK_BOT_TOKEN": "xoxb-your-bot-token-here",
    "SLACK_TEAM_ID": "T01234567"
  }
}
```

To find your Team ID: in Slack, click your workspace name (top-left) then "Settings & administration" then "Workspace settings." The Team ID is in the URL.

**Step 7: Verify**

```
List the last 10 messages in #production-incidents.
```

```
Search Slack for messages containing "blocked" from the last 24 hours.
```

---

## Part 4: Connect Your Support System (Zendesk / Intercom)

**Used by:** Red Flag Detection, Product Ops, Product Health, Customer Commitments, Documentation Gaps, Weekly Ops Digest

### 4.1 Zendesk

**Step 1: Generate an API Token**

1. In Zendesk Admin Center, go to "Apps and integrations" then "Zendesk API"
2. Enable "Token access" if not already enabled
3. Click "Add API token"
4. Name it "Claude MCP Access"
5. Copy the token

**Step 2: Install the Zendesk MCP Server**

```bash
npm install -g mcp-server-zendesk
```

**Step 3: Add to Your MCP Config**

```json
"zendesk": {
  "command": "mcp-server-zendesk",
  "env": {
    "ZENDESK_SUBDOMAIN": "yourcompany",
    "ZENDESK_EMAIL": "your.email@company.com",
    "ZENDESK_API_TOKEN": "your-token-here"
  }
}
```

The subdomain is the part before `.zendesk.com` in your URL. For `yourcompany.zendesk.com`, use `yourcompany`.

**Step 4: Verify**

```
Show me all Zendesk tickets created in the last 24 hours with priority "urgent" or "high."
```

### 4.2 Intercom

**Step 1: Create an Access Token**

1. In Intercom, go to Settings then "Developers" then "Developer Hub"
2. Create a new app or select your existing one
3. Go to "Authentication" and copy the Access Token

**Step 2: Install and Configure**

```bash
npm install -g mcp-server-intercom
```

```json
"intercom": {
  "command": "mcp-server-intercom",
  "env": {
    "INTERCOM_ACCESS_TOKEN": "your-access-token-here"
  }
}
```

---

## Part 5: Connect Your CRM (Salesforce / HubSpot)

**Used by:** Customer Commitments, Red Flag Detection, Executive Report, Product Dashboard, Competitive Intel, Market Intel, GTM Monitoring

### 5.1 Salesforce (via Workato MCP or Direct)

Salesforce is the most complex connection because of its OAuth flow. Two options:

**Option A: Workato MCP Server (Recommended for Non-Developers)**

Workato provides a managed MCP gateway that handles Salesforce authentication:

1. Sign up at https://www.workato.com
2. Create a Salesforce connection in Workato
3. Install the Workato MCP server:

```bash
npm install -g @workato/mcp-server
```

```json
"salesforce_via_workato": {
  "command": "mcp-server-workato",
  "env": {
    "WORKATO_API_KEY": "your-workato-api-key",
    "WORKATO_CONNECTION_ID": "your-salesforce-connection-id"
  }
}
```

**Option B: Direct Salesforce Connected App**

1. In Salesforce Setup, search "App Manager"
2. Click "New Connected App"
3. Enable OAuth Settings
4. Callback URL: `http://localhost:3000/callback`
5. OAuth Scopes: select "Access and manage your data (api)" and "Perform requests on your behalf at any time (refresh_token, offline_access)"
6. Save and note the Consumer Key and Consumer Secret

```bash
npm install -g mcp-server-salesforce
```

```json
"salesforce": {
  "command": "mcp-server-salesforce",
  "env": {
    "SF_LOGIN_URL": "https://login.salesforce.com",
    "SF_CLIENT_ID": "your-consumer-key",
    "SF_CLIENT_SECRET": "your-consumer-secret",
    "SF_USERNAME": "your.email@company.com",
    "SF_PASSWORD": "your-password",
    "SF_SECURITY_TOKEN": "your-security-token"
  }
}
```

To find your Security Token: Salesforce then My Settings then Personal then Reset My Security Token. It gets emailed to you.

**Step 4: Verify**

```
List the top 10 opportunities closing this quarter sorted by amount.
```

```
Show me all accounts with a health score below 70.
```

### 5.2 HubSpot

**Step 1: Create a Private App**

1. In HubSpot, go to Settings then "Integrations" then "Private Apps"
2. Click "Create a private app"
3. Name: "Claude PM Agent"
4. Scopes: select `crm.objects.contacts.read`, `crm.objects.deals.read`, `crm.objects.companies.read`
5. Create and copy the access token

**Step 2: Configure**

```bash
npm install -g mcp-server-hubspot
```

```json
"hubspot": {
  "command": "mcp-server-hubspot",
  "env": {
    "HUBSPOT_ACCESS_TOKEN": "pat-na1-your-token-here"
  }
}
```

---

## Part 6: Connect GitHub

**Used by:** Engineering Capacity, Release Readiness, Release Checker, Product Dashboard, Documentation Gaps

### 6.1 Generate a Personal Access Token

1. Go to https://github.com/settings/tokens
2. Click "Generate new token (classic)" or use Fine-grained tokens
3. Scopes needed:
   - `repo` (full repository access, for private repos)
   - `read:org` (read organization data)
4. Copy the token

### 6.2 Install the GitHub MCP Server

```bash
npm install -g @anthropic-ai/mcp-server-github
```

### 6.3 Add to Your MCP Config

```json
"github": {
  "command": "mcp-server-github",
  "env": {
    "GITHUB_TOKEN": "ghp_your-token-here"
  }
}
```

### 6.4 Verify

```
List all open pull requests in the yourcompany/product repo.
```

```
Show me commits merged to main in the last 7 days with their authors.
```

---

## Part 7: Connect Google Calendar

**Used by:** Daily Focus, Team Triage, Executive Report

### 7.1 Create OAuth Credentials

1. Go to https://console.cloud.google.com
2. Create a new project (or select existing)
3. Enable the Google Calendar API: APIs & Services then Library then search "Google Calendar API" then Enable
4. Create credentials: APIs & Services then Credentials then "Create Credentials" then "OAuth client ID"
5. Application type: "Desktop app"
6. Download the JSON credentials file

### 7.2 Install the Google Calendar MCP Server

```bash
npm install -g mcp-server-google-calendar
```

### 7.3 Add to Your MCP Config

```json
"google_calendar": {
  "command": "mcp-server-google-calendar",
  "env": {
    "GOOGLE_CLIENT_ID": "your-client-id.apps.googleusercontent.com",
    "GOOGLE_CLIENT_SECRET": "your-client-secret",
    "GOOGLE_REDIRECT_URI": "http://localhost:3000/callback"
  }
}
```

**First-time authentication:** The first time you use this, a browser window will open asking you to sign in to Google and grant calendar access. After authorizing, it stores a refresh token locally so you won't need to re-authenticate.

### 7.4 Verify

```
Show me all meetings on my calendar for today.
```

```
What meetings do I have this week that involve more than 5 people?
```

---

## Part 8: Connect Confluence (Documentation)

**Used by:** Documentation Gaps, Product Ops, Weekly Ops Digest

If you're using Atlassian, Confluence comes bundled with the same Atlassian MCP server you set up in Part 2.

### 8.1 Verify Confluence Access

If you already configured the Atlassian MCP server, Confluence access is included. Test it:

```
List all Confluence spaces I have access to.
```

```
Search Confluence for pages about "release process" updated in the last 30 days.
```

### 8.2 If Using a Separate Wiki

For Notion, use the Notion MCP server:

```bash
npm install -g @anthropic-ai/mcp-server-notion
```

```json
"notion": {
  "command": "mcp-server-notion",
  "env": {
    "NOTION_API_KEY": "ntn_your-integration-token"
  }
}
```

Create a Notion integration at https://www.notion.so/my-integrations, give it read access, and share the relevant pages/databases with the integration.

---

## Part 9: Connect Analytics (Amplitude / Mixpanel / Custom)

**Used by:** Product Health, Product Dashboard, Executive Report, GTM Monitoring

### 9.1 Amplitude

**Step 1: Get API Credentials**

1. In Amplitude, go to Settings then "Projects" then select your project
2. Note the API Key and Secret Key

**Step 2: Configure via HTTP MCP Server**

Amplitude doesn't have a dedicated MCP server yet. Use the generic HTTP/fetch MCP server:

```bash
npm install -g @anthropic-ai/mcp-server-fetch
```

```json
"amplitude": {
  "command": "mcp-server-fetch",
  "env": {
    "AMPLITUDE_API_KEY": "your-api-key",
    "AMPLITUDE_SECRET_KEY": "your-secret-key"
  }
}
```

Then in your agent prompts, use Claude's fetch capabilities to query the Amplitude Export API:

```
Fetch data from the Amplitude Export API for the last 7 days.
Endpoint: https://amplitude.com/api/2/export
Use the API key and secret for authentication.
```

### 9.2 Mixpanel

**Step 1: Create a Service Account**

1. In Mixpanel, go to Settings then "Service Accounts"
2. Create a new service account with "Analyst" role
3. Copy the username and secret

**Step 2: Configure**

Use the same fetch MCP server approach:

```json
"mixpanel": {
  "command": "mcp-server-fetch",
  "env": {
    "MIXPANEL_PROJECT_ID": "your-project-id",
    "MIXPANEL_SERVICE_ACCOUNT": "your-username",
    "MIXPANEL_SECRET": "your-secret"
  }
}
```

### 9.3 Direct Database Access (Recommended for Power Users)

For the most flexible analytics access, connect Claude directly to your data warehouse:

```bash
pip install mcp-server-postgres
```

```json
"analytics_db": {
  "command": "uvx",
  "args": ["mcp-server-postgres"],
  "env": {
    "DATABASE_URL": "postgresql://readonly_user:password@your-db-host:5432/analytics"
  }
}
```

**Critical: Use a read-only database user.** Create one:

```sql
CREATE ROLE claude_readonly WITH LOGIN PASSWORD 'secure-password';
GRANT CONNECT ON DATABASE analytics TO claude_readonly;
GRANT USAGE ON SCHEMA public TO claude_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO claude_readonly;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO claude_readonly;
```

---

## Part 10: Connect Gong (Call Intelligence)

**Used by:** Customer Commitments, Competitive Intel, Market Intel

### 10.1 Get API Credentials

1. In Gong, go to Company Settings then "API" (requires admin access)
2. Create a new API key pair
3. Copy the Access Key and Access Key Secret

### 10.2 Configure

```bash
npm install -g mcp-server-gong
```

```json
"gong": {
  "command": "mcp-server-gong",
  "env": {
    "GONG_ACCESS_KEY": "your-access-key",
    "GONG_ACCESS_KEY_SECRET": "your-secret"
  }
}
```

### 10.3 Verify

```
List the last 10 recorded calls from this week.
```

```
Search Gong transcripts for mentions of "competitor" or "switching" in the last 30 days.
```

---

## Part 11: Connect PagerDuty / Incident Management

**Used by:** Red Flag Detection, Product Health, Release Readiness

### 11.1 Get API Key

1. In PagerDuty, go to User Settings then "API Access" tab
2. Create a new API key (read-only is sufficient)

### 11.2 Configure

```bash
npm install -g mcp-server-pagerduty
```

```json
"pagerduty": {
  "command": "mcp-server-pagerduty",
  "env": {
    "PAGERDUTY_API_KEY": "your-api-key-here"
  }
}
```

---

## Part 12: Connect Sentry / Error Tracking

**Used by:** Product Health, Release Checker, Red Flag Detection

### 12.1 Get Auth Token

1. In Sentry, go to Settings then "Auth Tokens"
2. Create a new token with `project:read` and `event:read` scopes

### 12.2 Configure

```bash
npm install -g mcp-server-sentry
```

```json
"sentry": {
  "command": "mcp-server-sentry",
  "env": {
    "SENTRY_AUTH_TOKEN": "sntrys_your-token-here",
    "SENTRY_ORG": "your-org-slug"
  }
}
```

---

## Part 13: Your Complete MCP Config File

Here is a full example config with all connections. Remove any you don't need:

```json
{
  "mcpServers": {
    "atlassian": {
      "command": "mcp-server-atlassian",
      "env": {
        "ATLASSIAN_SITE_URL": "https://yourcompany.atlassian.net",
        "ATLASSIAN_USER_EMAIL": "you@company.com",
        "ATLASSIAN_API_TOKEN": "your-token"
      }
    },
    "slack": {
      "command": "mcp-server-slack",
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-token",
        "SLACK_TEAM_ID": "T01234567"
      }
    },
    "github": {
      "command": "mcp-server-github",
      "env": {
        "GITHUB_TOKEN": "ghp_your-token"
      }
    },
    "zendesk": {
      "command": "mcp-server-zendesk",
      "env": {
        "ZENDESK_SUBDOMAIN": "yourcompany",
        "ZENDESK_EMAIL": "you@company.com",
        "ZENDESK_API_TOKEN": "your-token"
      }
    },
    "salesforce": {
      "command": "mcp-server-salesforce",
      "env": {
        "SF_LOGIN_URL": "https://login.salesforce.com",
        "SF_CLIENT_ID": "your-consumer-key",
        "SF_CLIENT_SECRET": "your-consumer-secret",
        "SF_USERNAME": "you@company.com",
        "SF_PASSWORD": "your-password",
        "SF_SECURITY_TOKEN": "your-security-token"
      }
    },
    "google_calendar": {
      "command": "mcp-server-google-calendar",
      "env": {
        "GOOGLE_CLIENT_ID": "your-client-id.apps.googleusercontent.com",
        "GOOGLE_CLIENT_SECRET": "your-client-secret",
        "GOOGLE_REDIRECT_URI": "http://localhost:3000/callback"
      }
    },
    "gong": {
      "command": "mcp-server-gong",
      "env": {
        "GONG_ACCESS_KEY": "your-access-key",
        "GONG_ACCESS_KEY_SECRET": "your-secret"
      }
    },
    "pagerduty": {
      "command": "mcp-server-pagerduty",
      "env": {
        "PAGERDUTY_API_KEY": "your-api-key"
      }
    },
    "sentry": {
      "command": "mcp-server-sentry",
      "env": {
        "SENTRY_AUTH_TOKEN": "sntrys_your-token",
        "SENTRY_ORG": "your-org-slug"
      }
    },
    "analytics_db": {
      "command": "uvx",
      "args": ["mcp-server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://readonly_user:password@db-host:5432/analytics"
      }
    }
  }
}
```

---

## Part 14: Scheduling Your Agents

Once your data sources are connected, you need to schedule agents to run automatically.

### 14.1 Claude Code (Recommended for Automation)

Use cron jobs to trigger Claude Code with specific agent prompts:

```bash
# Edit your crontab
crontab -e

# Daily Focus Agent, every weekday at 7:00 AM
0 7 * * 1-5 cd ~/pm-agents && claude -p "Run the Daily Focus Agent. Read my calendar, scan Slack for unresponded threads and escalations, check Jira for critical blockers, and produce my morning focus report. Post to #daily-focus in Slack." --allowedTools mcp__atlassian,mcp__slack,mcp__google_calendar 2>&1 >> ~/pm-agents/logs/daily-focus.log

# Red Flag Detection, every weekday at 9:00 AM
0 9 * * 1-5 cd ~/pm-agents && claude -p "Run the Red Flag Detection Agent. Scan Zendesk for critical tickets, PagerDuty for active incidents, Jira for unassigned critical issues, Slack for escalation signals, and Salesforce for at-risk accounts. Classify by severity and post to #red-flags." --allowedTools mcp__atlassian,mcp__slack,mcp__zendesk,mcp__salesforce,mcp__pagerduty 2>&1 >> ~/pm-agents/logs/red-flags.log

# Executive Report, every Monday at 7:00 AM
0 7 * * 1 cd ~/pm-agents && claude -p "Run the Executive Report Agent. Compile this week's key metrics, roadmap progress, customer health, and strategic updates. Format as a C-level brief and email to the leadership distribution list." --allowedTools mcp__atlassian,mcp__slack,mcp__salesforce,mcp__analytics_db 2>&1 >> ~/pm-agents/logs/executive-report.log
```

### 14.2 Claude Desktop (Manual or Scheduled via OS)

For Claude Desktop, you trigger agents manually by pasting the agent prompt into a conversation that has the right MCP servers configured.

To semi-automate: use macOS Shortcuts or Windows Task Scheduler to open Claude Desktop and run a specific Project at a scheduled time.

### 14.3 Agent Prompt Files

Store each agent's prompt in a dedicated file:

```
~/pm-agents/
  prompts/
    daily-focus.md
    red-flag-detection.md
    pm-issues.md
    documentation-gaps.md
    gtm-monitoring.md
    product-ops.md
    roadmap-tracker.md
    team-triage.md
    product-health.md
    executive-report.md
    weekly-ops-digest.md
    engineering-capacity.md
    product-dashboard.md
    release-readiness.md
    release-checker.md
    customer-commitments.md
    competitive-intel.md
    market-intel.md
  logs/
  outputs/
```

Then reference them in cron:

```bash
0 7 * * 1-5 cd ~/pm-agents && claude -p "$(cat prompts/daily-focus.md)" 2>&1 >> logs/daily-focus.log
```

---

## Part 15: Security Best Practices

### 15.1 Use Read-Only Access Everywhere

Every API token, database credential, and OAuth scope should be **read-only** unless the agent explicitly needs write access (e.g., posting to Slack). Principle of least privilege.

### 15.2 Use Environment Variables, Not Hardcoded Tokens

Never put tokens directly in scripts. Use environment variables:

```bash
# Add to ~/.bashrc or ~/.zshrc
export ATLASSIAN_API_TOKEN="your-token"
export SLACK_BOT_TOKEN="xoxb-your-token"
export GITHUB_TOKEN="ghp_your-token"
```

Then reference in your MCP config:

```json
"env": {
  "ATLASSIAN_API_TOKEN": "${ATLASSIAN_API_TOKEN}"
}
```

### 15.3 Rotate Tokens Quarterly

Set a calendar reminder to rotate all API tokens every 90 days. Update your environment variables and MCP config accordingly.

### 15.4 Audit Agent Activity

Review your agent logs weekly. Check:
- Are agents accessing only the data sources they need?
- Are there unexpected API calls?
- Are error rates normal?

### 15.5 Network Security

If your data sources are behind a VPN or firewall, ensure the machine running Claude Code has appropriate network access. Claude Desktop runs locally on your machine, so it inherits your network access.

---

## Part 16: Troubleshooting

### "MCP server failed to start"

1. Check that the MCP server package is installed: `npm list -g | grep mcp`
2. Verify Node.js version: `node --version` (need 18+)
3. Check your config JSON syntax: use a JSON validator
4. Look at Claude Desktop logs: Help menu then "View Logs"

### "Authentication failed"

1. Verify your token hasn't expired
2. Check that the token has the required scopes
3. For Salesforce: verify your security token is appended to your password
4. For Slack: ensure the bot is invited to the channels it needs to read

### "No data returned"

1. Verify the data exists in the source tool (manually check)
2. Check API rate limits, most tools limit to 100-1000 requests/hour
3. For Jira/YouTrack: ensure you're querying the correct project key
4. For Slack: ensure the bot has been invited to the target channels

### "Agent hallucinating data"

1. This is normal, Claude sometimes fabricates data when the real data is ambiguous
2. Always include "Only report data you can directly verify from the connected tools" in your agent prompts
3. Add a "Sources" section requirement to your prompts so Claude cites where each data point came from
4. Cross-reference critical findings manually for the first 2 weeks

---

## Part 17: Data Source Matrix, Which Agents Need What

| Agent | Jira | Slack | Zendesk | Salesforce | GitHub | Calendar | Gong | Analytics | PagerDuty | Sentry |
|-------|------|-------|---------|------------|--------|----------|------|-----------|-----------|--------|
| Daily Focus | yes | yes |, |, |, | yes |, |, |, |, |
| PM Issues | yes | yes |, |, |, |, |, |, |, |, |
| Documentation Gaps | yes |, | yes |, | yes |, |, |, |, |, |
| GTM Monitoring | yes | yes |, | yes |, |, |, | yes |, |, |
| Red Flag Detection | yes | yes | yes | yes |, |, |, |, | yes |, |
| Product Ops | yes | yes | yes | yes |, |, |, | yes |, |, |
| Roadmap Tracker | yes | yes |, | yes |, |, |, |, |, |, |
| Team Triage | yes | yes |, |, |, | yes |, |, |, |, |
| Product Health | yes | yes | yes |, |, |, |, | yes | yes | yes |
| Executive Report | yes | yes |, | yes |, | yes |, | yes |, |, |
| Weekly Ops Digest | yes | yes | yes |, |, |, |, | yes |, |, |
| Engineering Capacity | yes |, |, |, | yes |, |, |, |, |, |
| Product Dashboard | yes |, | yes | yes | yes |, |, | yes |, |, |
| Release Readiness | yes | yes |, |, | yes |, |, |, | yes |, |
| Release Checker | yes |, |, |, | yes |, |, | yes |, | yes |
| Customer Commitments | yes | yes |, | yes |, |, | yes |, |, |, |
| Competitive Intel |, | yes |, | yes |, |, | yes |, |, |, |
| Market Intel |, | yes |, |, |, |, | yes | yes |, |, |

---

## Quick Start: The Minimum Viable Setup

If you want to start with the smallest possible footprint and expand later:

**Connect these 3 first:**
1. **Jira/YouTrack** (15 of 18 agents need it)
2. **Slack** (14 of 18 agents need it)
3. **Zendesk** (6 agents, but critical for red flag detection)

**Deploy these 3 agents first:**
1. Daily Focus Agent (7 AM)
2. Red Flag Detection Agent (9 AM)
3. Product Health Agent (4 PM)

**Then expand:**
- Week 2: Add Salesforce + GitHub
- Week 3: Add Google Calendar + Analytics DB
- Week 4: Add Gong + PagerDuty + Sentry
- Month 2: Deploy all 18 agents

This progressive approach lets you validate each connection before adding complexity.