How to Deploy a Claude Skill to Composio: A Step-by-Step Guide

Deploying a Claude skill to Composio requires creating a SKILL.md definition file, installing the Connect-Apps plugin, and authenticating with your Composio API key to enable external tool calls.

This guide walks through the complete deployment workflow using the ComposioHQ/awesome-claude-skills repository. You will learn how to structure your skill, wire it to Composio's tool catalog, and load it into Claude-Code for production use.

Understanding the Three-Layer Architecture

The Composio ecosystem organizes deployment into three distinct layers that work together to connect Claude with external APIs:

Layer	Purpose	Location in Repository
Skill definition	Human-readable instructions (SKILL.md) plus optional scripts/templates that tell Claude what to do	Any <skill-name>/SKILL.md (e.g., [connect/SKILL.md](https://github.com/ComposioHQ/awesome-claude-skills/blob/master/connect/SKILL.md))
MCP server (optional)	A lightweight HTTP service that exposes external APIs as tools that Claude can call; Composio's Rube MCP handles auth, rate-limiting, and schema discovery	mcp-builder/ – see [mcp_best_practices.md](https://github.com/ComposioHQ/awesome-claude-skills/blob/master/mcp-builder/reference/mcp_best_practices.md)
Connect-Apps Plugin	The glue that loads your skill into Claude, wires tool calls to Composio's catalog, and manages API key exchange	[connect-apps-plugin/README.md](https://github.com/ComposioHQ/awesome-claude-skills/blob/master/connect-apps-plugin/README.md)

Step-by-Step Deployment Guide

Create the Skill Definition

Start by creating a dedicated folder for your skill with a mandatory SKILL.md file:

my-skill/
├─ SKILL.md          # mandatory – YAML front-matter + markdown instructions

├─ scripts/          # optional – helper scripts the skill can invoke

└─ resources/        # optional – reference files, templates, etc.

The SKILL.md must begin with a YAML front-matter block containing the name and description fields. Claude reads this metadata at session start to keep token usage low, while the full markdown body loads on demand.

---
name: my-deploy-skill
description: Deploys a web app to a chosen platform and notifies the team.
---

# My Deploy Skill

## When to Use

- Deploy a new version of a web service
- Notify a channel after a successful deployment

## Instructions

1. Call the appropriate Composio tool based on the user's target platform.
2. Pass the Git commit SHA and any build flags.
3. If the deployment succeeds, notify the team via Slack.

Wire the Skill to Composio Tools

To perform external actions (e.g., "send an email" or "deploy to Vercel"), reference a Composio tool slug directly in your markdown instructions. For example, inside SKILL.md:

## Instructions

1. Use the `gmail_send_message` tool to send the email.
2. Pass the following payload:
   ```json
   {
     "to": "{{ user.email }}",
     "subject": "Your deployment report",
     "body": "{{ deployment_summary }}"
   }

Composio's **Rube Tool Router** looks up the proper tool definition at runtime. This pattern is demonstrated in the `connect` skill at line 86 in [[`connect/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/connect/SKILL.md)](https://github.com/ComposioHQ/awesome-claude-skills/blob/master/connect/SKILL.md), where the router maps natural language intents to specific tool calls.

If your skill requires a custom API not present in the Composio catalog, you can build a lightweight MCP server using Python or Node. The MCP best-practice guide in [`mcp-builder/reference/mcp_best_practices.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/mcp-builder/reference/mcp_best_practices.md) explains how to expose your server as a tool and support remote deployments.

### Install the Connect-Apps Plugin

The Connect-Apps plugin enables Claude to recognize your skill and access the Composio tool catalog. Install it by specifying the plugin directory when launching Claude:

```bash
claude --plugin-dir ./connect-apps-plugin

This plugin acts as the integration layer between Claude-Code and Composio's external services.

Authenticate with Composio

Once the plugin is loaded, run the setup command inside Claude (or Claude-Code) to store your API credentials:

/connect-apps:setup

Claude will prompt you for a Composio API key. You can generate a free key at the Composio dashboard (https://platform.composio.dev). The key is stored in the COMPOSIO_API_KEY environment variable, which the connect skill reads on line 101 of its source code to authenticate API calls.

Load the Skill into Claude

Copy your skill folder into Claude-Code's skill directory to make it available:

mkdir -p ~/.config/claude-code/skills/
cp -r my-skill ~/.config/claude-code/skills/

Verify the metadata is readable:

head ~/.config/claude-code/skills/my-skill/SKILL.md

Restart Claude-Code to auto-load the skill. The engine will parse the SKILL.md and register any referenced tool slugs.

Test the Deployment

Trigger your skill with a natural language prompt:

Deploy the latest version of my webapp to Vercel and notify the #engineering channel.

Claude will execute the following sequence:

1. Resolve the deployment intent and map it to the vercel_create_deployment tool via Composio
2. Perform the deployment using your stored API key
3. Post a message to Slack using slack_post_message

A successful execution produces a confirmation similar to the log line in connect/SKILL.md: "Deploy complete – v2.4.0 live".

Building Custom MCP Servers

When you need functionality beyond the standard Composio catalog, implement a custom MCP server. Here is a minimal Python example using Flask:

# server.py – tiny Flask MCP endpoint

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.post("/tools/custom_deploy")
def custom_deploy():
    payload = request.json
    # …perform deployment logic…

    return jsonify({"status": "ok", "url": "https://example.com/app"})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

Register this endpoint with Composio using the tool slug custom_deploy. The mcp_best_practices.md reference file details the required OpenAPI schema and deployment options for both local and cloud hosting.

Sharing and Publishing Skills

To make your skill reusable by team members or the community:

• Package the skill: Zip the folder (zip -r my-skill.zip my-skill/) and upload it to the Claude Skills Marketplace
• Team distribution: Use the built-in skill-share skill (defined in skill-share/SKILL.md) to automatically post the packaged skill to a Slack channel for team visibility

Summary

• Skill structure: Every deployment starts with a SKILL.md file containing YAML front-matter (name, description) and markdown instructions
• Tool integration: Reference Composio tool slugs (e.g., gmail_send_message, vercel_create_deployment) in your instructions; the Rube Tool Router handles resolution at runtime
• Plugin requirement: Install the Connect-Apps plugin (claude --plugin-dir ./connect-apps-plugin) to bridge Claude and Composio
• Authentication: Run /connect-apps:setup to store your COMPOSIO_API_KEY environment variable
• Installation path: Place skills in ~/.config/claude-code/skills/ for Claude-Code to auto-load them
• Extensibility: Build custom MCP servers for unsupported APIs, following the patterns in mcp-builder/reference/mcp_best_practices.md

Frequently Asked Questions

What is the minimum file structure required to deploy a Claude skill?

You need a single SKILL.md file inside a named folder. The file must contain YAML front-matter with name and description fields, followed by markdown instructions. Optional scripts/ and resources/ subdirectories can hold helper files and templates referenced by the skill.

How does the Connect-Apps plugin work?

The Connect-Apps plugin acts as a bridge between Claude-Code and Composio's service catalog. It loads skills from the filesystem, parses their tool references, and handles API authentication using the COMPOSIO_API_KEY environment variable. According to the repository's connect-apps-plugin/README.md, this enables Claude to execute real-world actions like deploying code or sending messages.

Can I use custom APIs that are not in the Composio catalog?

Yes. You can build a custom MCP (Model Context Protocol) server using Python or Node.js to expose your API as a tool. The mcp-builder/reference/mcp_best_practices.md file provides templates for local and cloud deployments. Once deployed, register the tool slug with Composio and reference it in your SKILL.md instructions.

Where does Claude-Code look for installed skills?

Claude-Code loads skills from the ~/.config/claude-code/skills/ directory on your local machine. Each subfolder should contain a SKILL.md file. After copying your skill folder to this location, restart Claude-Code to load the new skill definition and make its tools available.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}