connect-mcps

/connect-mcps - MCP Integration & Connection Manager

Connect Model Context Protocol (MCP) servers to your PM OS workspace for real-time data access from your tools.

Quick Start

Tell me which tool to connect (e.g., "connect to PostHog") and I will guide you through setup. Or say "batch" to connect multiple tools at once.

1. Name the tool: "connect to [tool name]"
2. I search for official MCP servers (remote first, then local)
3. I guide you through credentials and authentication
4. I test the connection and discover available tools
5. I update your PM OS skills and pm/CLAUDE.md routing automatically

Example: /catalyst-pm-ops:connect-mcps connect to linear

Output: MCP connected, skills updated, integration log saved to thoughts/shared/pm/reports/

Time: 5-20 minutes per tool depending on setup method

When to Use

• Initial workspace setup - Connect your analytics, project management, and research tools
• Adding new tools - When you start using a new tool that has an MCP server
• After installing MCP servers - Once you've installed an MCP server locally or have access to one

Usage Patterns

Individual Connection (Recommended)

/catalyst-pm-ops:connect-mcps connect to posthog
/catalyst-pm-ops:connect-mcps connect to linear
/catalyst-pm-ops:connect-mcps connect to notion

Batch Connection (Advanced)

/catalyst-pm-ops:connect-mcps batch

Then provide multiple tool names when prompted.

How It Works

When you run /connect-mcps connect to [tool name], I will:

1. Check for official remote MCP server - Search for hosted MCP servers (priority method)
2. If remote server exists - Guide you to use claude mcp add --transport http [tool] [url]
3. If no remote server - Research manual setup (OAuth, API tokens)
4. Guide credential entry - Prompt you for required credentials
5. Test connection - Verify the connection works and discover available tools
6. Map to skills - Automatically determine which PM OS skills benefit from this MCP
7. Update workspace - Add integration instructions to relevant skills and update pm/CLAUDE.md registry
8. Enable intelligent routing - Your natural language queries will automatically route to the right MCP

Priority Order:

• First: Check for official remote MCP server (e.g., Stripe, Linear)
• Second: Local MCP server via NPM/Docker
• Last: Manual OAuth/API token setup

Step-by-Step Workflow

Step 1: Parse Tool Name

When you run /catalyst-pm-ops:connect-mcps connect to posthog:

• Extract tool name: "posthog"
• Normalize and validate the name
• Check if already connected (skip if duplicate)

Step 2: Check for Official Remote MCP Server (Priority #1)

IMPORTANT: Always check for official remote MCP servers FIRST before manual setup.

I'll search the web for:

• "[tool name] official MCP server"
• "[tool name] remote MCP server"
• "[tool name] MCP server documentation 2026"

If I find a remote server URL:

I'll tell you to use the simple method:

claude mcp add --transport http [tool] [url]

Then manage it via /mcp in Claude Code to authenticate.

Example remote MCP servers:

• Stripe: Check Stripe docs for MCP endpoint
• Linear: Check Linear docs for MCP endpoint
• Others: Search "[tool] MCP remote server"

Step 3: Manual Setup (Fallback Only)

Only if no remote server exists, I'll search for:

• "[tool name] MCP integration guide"
• "[tool name] Claude MCP setup"
• "[tool name] API authentication requirements"

From the search results, I extract:

• NPM package name or local server setup
• Required authentication (API keys, OAuth tokens, workspace IDs)
• Configuration parameters needed
• Tool names and capabilities
• Setup instructions and documentation links

Step 4: Guide You Through Connection

I'll present what's needed:

To connect PostHog, I need:
1. PostHog API Key (Settings → API Keys)
2. Project ID (Settings → Projects)

[Link to PostHog documentation]

Then prompt for each credential:

Enter your PostHog API Key: [you paste here]
Enter your Project ID: [you paste here]

Note: Your credentials are handled by the MCP system securely. I don't store them in files.

Step 5: Test Connection & Discover Tools

Once credentials are provided:

• Test the connection to verify it works
• Query the MCP server to discover available tools
• Extract tool names, descriptions, and parameters
• Document capabilities for routing

Example discovered tools for PostHog:

• query_insights - Query product analytics data
• get_funnels - Retrieve funnel analysis
• cohort_analysis - Analyze user cohorts
• event_tracking - Track custom events

Step 6: Intelligent Skill Mapping

Based on the MCP category, I automatically map it to relevant skills:

Analytics MCPs (PostHog) → feature-metrics, impact-sizing, retention-analysis, activation-analysis, feature-results, metrics-framework, experiment-metrics

Project Management MCPs (Linear) → create-tickets, meeting-notes, status-update, prioritize

Research MCPs (Dovetail) → user-interview, user-research-synthesis, interview-guide

Transcription MCPs (Otter.ai, Rev) → meeting-notes, meeting-cleanup, user-interview

Communication MCPs (Slack) → slack-message, status-update, meeting-notes

Documentation MCPs (Notion, Confluence) → decision-doc, status-update, meeting-notes

**Design MCPs → generate-ai-prototype, napkin-sketch, prototype-feedback

Web Search MCPs → competitor-analysis, competitive-intel

Multi-category MCPs are mapped to multiple skill groups.

Step 7: Update Skill Files

For each mapped skill, I will:

1. Read the current SKILL.md file
2. Find the right insertion point (after Prerequisites or How It Works)
3. Add an MCP integration section:

### Using [MCP Name] (If Connected)

[MCP Name] provides [capability description].

**Available Tools:**

- `tool_name` - [purpose]
- `tool_name_2` - [purpose]

**Integration Example:**

Query PostHog for feature metrics

posthog.query_insights({ "event": "feature_used", "feature_name": "checkout", "date_range": "last_14_days" })

Benefits:

• Real-time data instead of manual exports
• Query on-demand without switching tools
• Segment and filter programmatically

Fallback: If PostHog not connected, you can upload exported CSV data to thoughts/shared/pm/metrics/ and I'll analyze that instead.

4. Write the updated SKILL.md back to disk
5. Log the change for the integration summary

### Step 8: Update pm/CLAUDE.md Registry

I update two critical sections in pm/CLAUDE.md:

**A) MCP Registry Table** - Lists all connected MCPs

| MCP | Purpose | Category | Used In | Key Tools |
|-----|---------|----------|---------|-----------|
| PostHog | Product analytics | Analytics | feature-metrics, impact-sizing | query_insights, get_funnels |

**B) Intelligent Query Routing Logic** - Maps query patterns to MCPs

This enables me to automatically understand queries like:
- "Give me metrics on the login feature" → Route to PostHog
- "Show my open tasks" → Route to Linear
- "What did users say about feature X" → Route to Dovetail

### Step 9: Generate Integration Summary

After successful integration, I:
- Save a detailed log to `thoughts/shared/pm/reports/[timestamp]-[tool-name].md`
- Display a summary showing:
  - Tools discovered
  - Skills updated
  - How to use the MCP with natural language queries
- Provide next steps

## MCP Intelligence Gathering

### What I Look For in Documentation

When researching an MCP, I extract:

**1. Setup Requirements**
- NPM package name or server URL
- Authentication method (API key, OAuth, token)
- Required configuration (workspace ID, project ID, etc.)
- Environment variables needed

**2. Tool Catalog**
- Available tools/functions
- Tool purposes and descriptions
- Parameter requirements (required vs optional)
- Retu