domains / agent-tooling / composio-app-connect / connect

connect

Skill card

combined

Both copies describe the same goal (using Composio to take real actions across 1000+ apps) and share the same supported-app categories and examples. However, they disagree on the primary interface and setup: one is a Claude Agent SDK / MCP integration using COMPOSIO_API_KEY and a Python client, while the other is a Codex/terminal workflow using the Composio CLI (composio login, link, execute, run, proxy). Each contains material steps the other lacks, so crowning one would hide a real alternative.

Repositories

Other copies

Combined skill

---
name: connect
description: Connect an agent to any app via Composio. Send emails, create issues, post messages, update databases - take real actions across Gmail, Slack, GitHub, Notion, and 1000+ services.
---

# Connect

Connect your agent to any app using Composio. Stop generating text about what you could do - actually do it.

## When to Use This Skill

Use this skill when you need to:

- **Send that email** instead of drafting it
- **Create that issue** instead of describing it
- **Post that message** instead of suggesting it
- **Update that database** instead of explaining how

## Supported Apps

**1000+ integrations** including:

- **Email:** Gmail, Outlook, SendGrid
- **Chat:** Slack, Discord, Teams, Telegram
- **Dev:** GitHub, GitLab, Jira, Linear
- **Docs:** Notion, Google Docs, Confluence
- **Data:** Sheets, Airtable, PostgreSQL
- **CRM:** HubSpot, Salesforce, Pipedrive
- **Storage:** Drive, Dropbox, S3
- **Social:** Twitter, LinkedIn, Reddit

## Setup

### Option A: Claude Agent SDK / MCP (Python or TypeScript)

1. Get your free API key at [platform.composio.dev](https://platform.composio.dev/?utm_source=Github&utm_content=AwesomeSkills)
2. Set the environment variable:
   ```bash
   export COMPOSIO_API_KEY="your-key"
   ```
3. Install the SDK:
   ```bash
   pip install composio          # Python
   npm install @composio/core    # TypeScript
   ```
4. Create a session and expose the MCP server to your agent:
   ```python
   from composio import Composio
   from claude_agent_sdk.client import ClaudeSDKClient
   from claude_agent_sdk.types import ClaudeAgentOptions
   import os

   composio = Composio(api_key=os.environ["COMPOSIO_API_KEY"])
   session = composio.create(user_id="user_123")

   options = ClaudeAgentOptions(
       system_prompt="You can take actions in external apps.",
       mcp_servers={
           "composio": {
               "type": "http",
               "url": session.mcp.url,
               "headers": {"x-api-key": os.environ["COMPOSIO_API_KEY"]},
           }
       },
   )

   async with ClaudeSDKClient(options) as client:
       await client.query("Send Slack message to #general: Hello!")
   ```

### Option B: Composio CLI (terminal / Codex)

1. Install the CLI:
   ```bash
   curl -fsSL https://composio.dev/install | bash
   ```
2. Log in:
   ```bash
   composio login
   composio whoami
   ```
   This opens a browser for authentication and lets you pick your default org and project. Use `-y` to skip prompts in automated flows.
3. Link the toolkits you need:
   ```bash
   composio link github
   composio link gmail
   composio link slack
   ```
   Each command walks through OAuth once, then the connection persists.

## Core Workflow (CLI)

1. **Know the tool slug?** → `composio execute`
2. **Don't know the slug?** → `composio search`
3. **Need clarification on inputs?** → `composio execute --get-schema` or `--dry-run`
4. **Toolkit not connected?** → `composio link <toolkit>` and retry
5. **Multiple steps needed?** → `composio run` for workflows, `composio proxy` for raw API calls

## Examples

### Send Email (CLI)
```bash
composio execute GMAIL_SEND_EMAIL -d '{
  "recipient_email": "sarah@acme.com",
  "subject": "Shipped!",
  "body": "v2.0 is live, let me know if issues"
}'
```

### Create GitHub Issue (CLI)
```bash
composio execute GITHUB_CREATE_ISSUE -d '{
  "owner": "my-org",
  "repo": "repo",
  "title": "Mobile timeout bug",
  "labels": ["bug"]
}'
```

### Post to Slack (CLI)
```bash
composio execute SLACK_SEND_MESSAGE -d '{
  "channel": "engineering",
  "text": "Deploy complete - v2.4.0 live"
}'
```

### Chain Actions (CLI)
```bash
composio run '
  const issues = await search("github issues labeled bug this week");
  const summary = issues.map(i => `- ${i.title}`).join("\n");
  await execute("SLACK_SEND_MESSAGE", {
    channel: "bugs",
    text: `This week’s bugs:\n${summary}`
  });
'
```

### Raw API Access (CLI)
When no dedicated tool exists, hit the authenticated API directly:
```bash
composio proxy https://gmail.googleapis.com/gmail/v1/users/me/profile \
  --toolkit gmail
```

## How It Works

- **SDK/MCP path:** You ask the agent to do something; the Tool Router finds the right tool (1000+ options); OAuth is handled automatically; the action executes and returns a result.
- **CLI path:** You ask the agent to do something; the agent picks a slug via `composio search` or prior knowledge; the CLI checks the connection and prompts `composio link` if missing; the action executes against the real API and returns JSON to stdout.

## Auth Flow

First time using an app:
```
To send emails, I need Gmail access.
Authorize here: https://...
Say "connected" when done.
```
Connection persists after that.

## Framework Support (SDK/MCP)

| Framework | Install |
|-----------|---------|
| Claude Agent SDK | `pip install composio claude-agent-sdk` |
| OpenAI Agents | `pip install composio openai-agents` |
| Vercel AI | `npm install @composio/core @composio/vercel` |
| LangChain | `pip install composio-langchain` |
| Any MCP Client | Use `session.mcp.url` |

## Configuration (CLI)

**Global flags:**
- `--log-level <all|trace|debug|info|warning|error|fatal|none>`
- `--help` for per-command docs

**Environment variables:**
- `COMPOSIO_API_KEY` - auth credential (set for non-interactive use)
- `COMPOSIO_BASE_URL` - custom API endpoint
- `COMPOSIO_SESSION_DIR` - override artifact storage
- `COMPOSIO_DISABLE_TELEMETRY=true` - opt out of telemetry

## Type-Safe SDK (Optional, CLI)

Generate typed client code when you want to call tools from an app rather than the shell:

```bash
composio generate ts    # TypeScript types
composio generate py    # Python types
```

Flags: `-o <dir>`, `--toolkits <list>`, `--compact`, `--transpiled`, `--type-tools`.

## Troubleshooting

- **Auth required** → Click link, authorize, say "connected" (SDK/MCP) or run `composio login` (CLI)
- **Connection required for <toolkit>** → run `composio link <toolkit>` (CLI)
- **Action failed** → Check permissions in target app
- **Tool not found / Unknown slug** → Be specific: "Slack #general" not "send message"; or use `composio search "<what you want>"` / `composio tools list <toolkit>` (CLI)
- **Bad inputs** → `composio execute <SLUG> --get-schema` then `--dry-run` (CLI)

Full reference: [docs.composio.dev/docs/cli](https://docs.composio.dev/docs/cli)

---

<p align="center">
  <b>Join 20,000+ developers building agents that ship</b>
</p>

<p align="center">
  <a href="https://platform.composio.dev/?utm_source=Github&utm_content=AwesomeSkills">
    <img src="https://img.shields.io/badge/Get_Started_Free-4F46E5?style=for-the-badge" alt="Get Started"/>
  </a>
</p>