DocsMission ControlIntegrations

Integrations

Connect CapiBot to the tools you already use. This guide covers setting up Composio for 1000+ app integrations and GitHub for repository management.

Composio Integration

Composio provides unified access to 1000+ apps including Notion, Linear, Jira, Slack, Gmail, Airtable, and many more.

Getting Your Composio API Key

Step 1: Sign Up for Composio

  1. Go to composio.dev
  2. Click "Get Started" or "Sign Up"
  3. Create an account with your email or GitHub
  4. Verify your email address

Step 2: Get Your API Key

  1. Log into your Composio dashboard
  2. Navigate to Settings → API Keys (or Developer → API Keys)
  3. Click "Create New API Key"
  4. Give it a name: CapiBot Integration
  5. Copy the API key (starts with composio_)

Step 3: Add API Key to CapiBot

  1. Open Mission Control (http://localhost:3002)
  2. Go to Settings → Integrations
  3. Find the Composio section
  4. Paste your API key in the field: 
    Composio API Key: composio_xxxxxxxxxxxxxxxx
  5. Click "Save" or "Connect"
  6. You should see: ✅ Connected

Connecting Apps via Composio

Once your Composio API key is added, you can connect individual apps.

Integrations Panel Screenshot: Integrations panel showing connected apps and the Composio marketplace

Step 1: Browse Available Apps

  1. In Mission Control, go to Integrations → Composio
  2. Browse or search for apps (Notion, Linear, Slack, etc.)
  3. Apps are organized by category (Project Management, Communication, CRM, etc.)

Step 2: Connect an App

  1. Find the app you want (e.g., Notion)
  2. Click "Connect"
  3. You'll be redirected to the app's OAuth authorization page
  4. Sign in to your app account (if not already signed in)
  5. Review the permissions requested
  6. Click "Authorize" or "Allow"
  7. You'll be redirected back to Mission Control
  8. The app now shows: ✅ Connected

Step 3: Configure App Access Some apps let you configure what CapiBot can access:

For Notion:

  • Select which pages/databases to share
  • Choose access level (read-only or read-write)
  • Click "Allow access"

For Slack:

  • Choose which workspace to connect
  • Select channels the bot can access
  • Grant permissions (send messages, read messages, etc.)

For Linear:

  • Choose which teams to connect
  • Set issue access permissions
  • Configure webhook settings

Using Composio-Connected Apps

Once connected, agents can use these apps through the Composio skill.

Example: Creating a Notion Page

You: Create a Notion page called "Project Ideas" with our
     meeting notes

Agent: [Uses composio skill]
       1. Checks Notion is connected ✅
       2. Finds "create page" action
       3. Creates page with your notes

       ✅ Created "Project Ideas" page in Notion
       View it: https://notion.so/...

Example: Sending a Slack Message

You: Send a message to the #engineering channel that the
     deployment is complete

Agent: [Uses composio skill]
       ✅ Message sent to #engineering:
       "Deployment complete! 🚀"

Managing Composio Connections

View Connected Apps:

  1. Go to Integrations → Composio
  2. See all connected apps with status
  3. Green checkmark = Connected and working
  4. Red X = Connection issue

Reconnect an App: If an app shows an error:

  1. Click the "Reconnect" button
  2. Re-authorize the app
  3. Update permissions if needed

Disconnect an App:

  1. Find the app in the list
  2. Click "Disconnect"
  3. Confirm: "This will remove access to [App]"
  4. CapiBot will no longer be able to use this app

Common Composio Issues

"No apps connected"

  • You haven't connected any apps yet
  • Go to Composio tab and click "Connect" on desired apps

"App connection expired"

  • OAuth tokens expire after some time
  • Click "Reconnect" to refresh the connection

"Permission denied"

  • The app is connected but lacks required permissions
  • Disconnect and reconnect with broader permissions
  • Or check app settings in Composio dashboard

"Rate limit exceeded"

  • Too many API calls in a short time
  • Wait a few minutes and try again
  • Consider upgrading your Composio plan

GitHub Integration

Connect GitHub to sync issues, pull requests, and repository activity with CapiBot tasks.

Getting Your GitHub Personal Access Token

Step 1: Go to GitHub Settings

  1. Log into your GitHub account
  2. Click your profile picture (top right)
  3. Select Settings
  4. Scroll down and click Developer settings (left sidebar)

Step 2: Create a Personal Access Token

  1. Click Personal access tokens → Tokens (classic)
  2. Click "Generate new token" → "Generate new token (classic)"
  3. You may need to re-enter your password
  4. Give your token a name: CapiBot Integration
  5. Set expiration (recommended: 90 days)
  6. Select scopes (permissions):

Required Scopes:

☑️ repo            (Full control of private repositories)
   ☑️ repo:status   (Access commit status)
   ☑️ repo_deployment  (Access deployment status)
   ☑️ public_repo   (Access public repositories)
   ☑️ repo:invite   (Access repository invitations)
☑️ admin:repo_hook  (Full control of repository hooks)

Optional Scopes (for more features):

☑️ read:org        (Read org and team membership)
☑️ read:user       (Read user profile data)
☑️ read:project    (Read project boards)
  1. Scroll down and click "Generate token"
  2. Important: Copy the token immediately!
    • It starts with ghp_
    • GitHub will only show it once
    • Store it securely

Step 3: Add Token to CapiBot

  1. Open Mission Control (http://localhost:3002)
  2. Go to Settings → Integrations → GitHub
  3. Paste your token: 
    GitHub Personal Access Token: ghp_xxxxxxxxxxxxxxxx
  4. Click "Connect"
  5. You should see: ✅ Connected

Setting Up GitHub Sync

Once connected, configure what to sync.

Step 1: Select Repositories

  1. Go to Integrations → GitHub Sync
  2. You'll see a list of repositories you have access to
  3. Check the boxes next to repositories you want to sync
  4. Click "Save Selection"

Step 2: Configure Sync Settings

Sync Mode: [Import issues as tasks ▼]
  • Import issues as tasks
  • Two-way sync (tasks ↔ issues)
  • Read-only (monitor only)

Filters:
  ☑️ Open issues only
  ☐ Include pull requests
  ☑️ Specific labels: [bug, feature, urgent]
  ☐ All labels

Auto-Assign Rules:
  When: Issue labeled "frontend"
  Assign to: @Pixel (Designer)

  When: Issue labeled "backend"
  Assign to: @Nova (Engineer)

  When: Issue labeled "bug"
  Priority: High

Step 3: Test the Sync

  1. Create a test issue in one of your connected repositories
  2. Add a label that matches your filter (e.g., "bug")
  3. Wait 30-60 seconds
  4. Check Tasks panel in Mission Control
  5. You should see the issue imported as a task

How GitHub Sync Works

Real-Time Sync:

GitHub Issue Created
        ↓
GitHub sends webhook to CapiBot
        ↓
CapiBot receives webhook
        ↓
Task T-123 created from issue
        ↓
Assigned based on label rules
        ↓
Agent gets notified
        ↓
Agent works on task
        ↓
Task completed in CapiBot
        ↓
GitHub issue closed (if two-way sync)

Sync History: View all synced items:

Recent Imports

✅ #234 "Fix login bug" → T-123 (Nova)
   Synced: 2 min ago | Label: bug

✅ #235 "Add dark mode" → T-124 (Pixel)
   Synced: 5 min ago | Label: feature

⚠️ #236 "Update docs" → Skipped
   Reason: No matching label filter

Managing GitHub Sync

Pause/Resume:

  • Temporarily stop syncing without disconnecting
  • Useful during maintenance
  • Go to GitHub Sync → Click "Pause"

Selective Sync: Only sync specific issues:

Labels to sync: [bug, feature, urgent]
Ignore: [wontfix, duplicate, question]

Bulk Import: Import all existing issues:

Import all open issues?
Repository: my-org/my-project
Issues found: 47

☑️ Yes, import all 47 issues
☐ Assign to default agent: @Nova
☐ Set priority based on labels

Common GitHub Issues

"Authentication failed"

  • Token may have expired
  • Generate a new token
  • Token may lack required scopes
  • Check scopes and regenerate

"Repository not found"

  • You may not have access to that repository
  • Check repository permissions
  • Try a repository you own or are a collaborator on

"Webhook delivery failed"

  • CapiBot may not be publicly accessible
  • Check webhook URL in GitHub settings
  • Ensure CapiBot is running and accessible

"Issues not syncing"

  • Check label filters match your issues
  • Verify sync is enabled (not paused)
  • Check sync history for errors

API Keys Management

Centralized management of all integration keys.

Access: Settings → API Keys

Viewing API Keys

┌─────────────────────────────────────────────────────────┐
│ API Keys Management                                     │
├─────────────────────────────────────────────────────────┤
│                                                         │
│ Integration API Keys                                    │
│                                                         │
│ Composio API Key                                        │
│ Status: ✅ Active                                      │
│ Last used: 5 min ago                                   │
│ [View Key] [Regenerate] [Delete]                       │
│                                                         │
├─────────────────────────────────────────────────────────┤
│                                                         │
│ GitHub Personal Access Token                            │
│ Status: ✅ Active                                      │
│ Scopes: repo, admin:repo_hook                          │
│ Expires: Dec 15, 2024                                  │
│ [View Key] [Regenerate] [Delete]                       │
│                                                         │
└─────────────────────────────────────────────────────────┘

Adding New API Keys

Step 1: Click "Add New Key"

Step 2: Select Integration Type

  • Composio
  • GitHub
  • Serper (Web Search)
  • Groq (Voice Transcription)
  • Custom

Step 3: Enter Key Details

Integration: Composio
Name: My Composio Key
Key: composio_xxxxxxxxxxxxxxxx

Step 4: Save and Test

  • Click "Save"
  • Click "Test Connection" to verify
  • Should show: ✅ Connection successful

Rotating Keys

When to Rotate:

  • Every 90 days (best practice)
  • If you suspect compromise
  • When an employee leaves
  • After security incidents

How to Rotate:

  1. Generate new key in external service
  2. Go to Settings → API Keys
  3. Find the old key
  4. Click "Regenerate"
  5. Paste new key
  6. Click "Save"
  7. Old key becomes invalid immediately

Security Best Practices

For Composio:

  • Use a dedicated Composio account for CapiBot
  • Don't use your personal Composio account
  • Review connected apps regularly
  • Remove unused app connections

For GitHub:

  • Use fine-grained tokens when possible
  • Limit token expiration to 90 days
  • Only grant minimum required permissions
  • Don't commit tokens to repositories
  • Use environment variables in production

General:

  • Never share API keys in messages
  • Don't include keys in screenshots
  • Rotate keys regularly
  • Monitor usage for anomalies
  • Revoke keys immediately if compromised

Integration Health Monitoring

Check the status of all your integrations in one place.

Access: Settings → Integration Health

┌─────────────────────────────────────────────────────────┐
│ Integration Health                                      │
├─────────────────────────────────────────────────────────┤
│                                                         │
│ ✅ Composio                                             │
│    API: Connected                                       │
│    Apps: 5 connected (Notion, Linear, Slack, ...)      │
│    Last check: Just now                                │
│                                                         │
│ ✅ GitHub                                               │
│    Token: Valid (expires in 45 days)                   │
│    Webhooks: 3 active                                  │
│    Repositories: 5 synced                              │
│    Last sync: 2 min ago                                │
│                                                         │
│ ⚠️  Slack                                               │
│    Connection: Active                                  │
│    Warning: Rate limit (87% used)                      │
│    Action: Monitor usage                               │
│                                                         │
│ ❌ Linear                                               │
│    Connection: Expired                                 │
│    Error: Token revoked                                │
│    Action: Reconnect required                          │
│    [Reconnect Now]                                     │
│                                                         │
└─────────────────────────────────────────────────────────┘

Troubleshooting Integration Issues

Connection Shows "Disconnected"

  1. Check API key is valid
  2. Verify key has required permissions
  3. Test connection manually
  4. Re-enter key if needed

"Rate Limit Exceeded"

  1. Wait for rate limit reset
  2. Reduce sync frequency
  3. Upgrade service plan
  4. Contact support if persistent

"Webhook Delivery Failed"

  1. Check CapiBot is publicly accessible
  2. Verify webhook URL is correct
  3. Check firewall settings
  4. Review webhook logs

"Sync Delayed"

  1. Check integration health
  2. Verify sync is enabled
  3. Look for error messages
  4. Try manual sync trigger

Integration Patterns

Pattern 1: GitHub + CapiBot Development Workflow

GitHub Issue Created → CapiBot Task Created
        ↓                        ↓
   Labeled "bug"          Assigned to @Nova
        ↓                        ↓
   Nova fixes bug         Task completed
        ↓                        ↓
   PR created             Deliverable attached
        ↓                        ↓
   PR merged              Task closed
        ↓                        ↓
   GitHub issue closed ←── Task done

Pattern 2: Composio Knowledge Management

Agent researches topic
        ↓
Findings saved to Notion (via Composio)
        ↓
Organized in company knowledge base
        ↓
Other agents reference Notion docs
        ↓
Knowledge grows over time

Pattern 3: Multi-Tool Automation

Cron job triggers daily
        ↓
Agent checks GitHub issues (via GitHub)
        ↓
Creates summary in Notion (via Composio)
        ↓
Sends Slack notification (via Composio)
        ↓
Team sees daily update

Best Practices

Getting Started

  1. Start with One Integration — Don't connect everything at once
  2. Test Thoroughly — Verify each integration works before relying on it
  3. Document Your Setup — Note which keys are used where
  4. Monitor Usage — Check integration health regularly

Security

  1. Use Dedicated Accounts — Don't use personal accounts for integrations
  2. Minimum Permissions — Only grant required access
  3. Regular Rotation — Rotate keys every 90 days
  4. Monitor Logs — Watch for unusual activity

Maintenance

  1. Health Checks — Review integration status weekly
  2. Update Apps — Keep connected apps current
  3. Clean Up — Remove unused integrations
  4. Backup Keys — Store securely offline

Next Steps