The Difference Between MCP, Tools, and Skills in Composio: A Complete Architectural Guide

MCP is the transport protocol that exposes Tools, while Skills are high-level instruction packages that orchestrate those Tools into workflows.

The Composio ecosystem organizes LLM capabilities into three distinct architectural layers that determine how AI agents interact with external services. According to the source code in ComposioHQ/awesome-claude-skills, understanding the difference between MCP, Tools, and Skills in Composio is essential for building robust integrations that leverage the Model Context Protocol effectively.

Understanding MCP, Tools, and Skills in Composio

The repository separates concerns into three distinct layers, each serving a specific purpose in the LLM execution pipeline.

MCP (Model Context Protocol) - The Transport Layer

MCP defines the transport, authentication, and discovery mechanisms for remote functions. Located conceptually at the gateway level, this protocol determines how an LLM communicates with external APIs without hardcoding vendor-specific logic. The mcp-builder/reference/mcp_best_practices.md file documents how MCP servers register capabilities and handle the JSON request-response cycle between the LLM and external services.

Tools - The Executable Primitives

Tools are the individual, executable functions exposed through an MCP server. Each Tool maps to a single atomic operation—such as github.create_issue, slack.send_message, or gmail.send_email. As implemented in the Connect-apps plugin, Tools receive specific parameters (e.g., repo, title, body) and return structured JSON results that the LLM can parse and act upon.

Skills - The Orchestration Layer

Skills represent high-level instruction packages that describe how an LLM should orchestrate a workflow using available Tools. Each Skill contains a SKILL.md file with metadata, step-by-step guidance, and optional scripts or assets. Unlike Tools, which perform single actions, Skills dictate when and how to call multiple Tools in sequence—such as authenticating first, then creating a GitHub issue, then posting a Slack notification.

How MCP, Tools, and Skills Work Together

The relationship between these three layers follows a strict hierarchy. The MCP gateway provides the communication infrastructure, Tools provide the executable capabilities, and Skills provide the behavioral logic that coordinates them.

When an LLM processes a request, it first consults loaded Skills to determine the appropriate workflow. The Skill then instructs the LLM to invoke specific Tools through the MCP protocol. For example, the Connect-apps Skill (documented in connect-apps-plugin/README.md) guides the LLM through authentication steps before allowing access to the underlying GitHub or Slack Tools.

This separation keeps the context window efficient—Skills load only when relevant, while Tools remain available through the persistent MCP connection.

Practical Code Examples

Invoking an MCP Tool Directly

You can interact with Tools directly through the MCP gateway without loading a Skill. The following example demonstrates direct Tool invocation using the Connect-apps CLI interface:

# Install the Connect-apps plugin (once)

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

# Run the setup command to store your Composio API key

/connect-apps:setup

# → Paste your free API key when prompted

# Invoke an MCP tool: create a GitHub issue

/connect-apps:create_issue \
  repo="composiohq/awesome-claude-skills" \
  title="Bug report from LLM" \
  body="The skill loader crashes on empty SKILL.md files."

In this example, create_issue maps to the MCP Tool github.create_issue exposed by the Composio MCP gateway. The Tool executes immediately and returns a JSON response that the LLM processes.

Implementing a Claude Skill

Skills are defined by creating a directory containing a SKILL.md file. The following example from skill-creator/SKILL.md demonstrates the structure:

---
name: Connect-apps
description: "Enable Claude to perform real actions across 1000+ apps via Composio."
---

## When to Use This Skill

- You need the LLM to call external services (email, Slack, GitHub, etc.).

## What This Skill Does

1. **Authenticate** – prompts the user for a Composio API key.
2. **Select an App** – asks the user which integration to use.
3. **Execute the Desired Action** – calls the appropriate MCP tool.
4. **Report Results** – returns a concise human-readable summary.

## Example Prompt

/connect-apps:setup /create_issue repo=… title=… body=…

When this Skill loads, the LLM follows the prescribed workflow, automatically invoking the appropriate MCP Tools at each step. The Skill only activates when the user intent matches its description, keeping the context window focused on relevant instructions.

Key Source Files in ComposioHQ/awesome-claude-skills

File Path	Purpose
README.md	Provides the high-level overview of the three-layer architecture (MCP, Tools, Skills) and their relationships.
mcp-builder/reference/mcp_best_practices.md	Contains detailed guidelines for building robust MCP servers and authenticating Tool calls.
skill-creator/SKILL.md	Template and conventions for authoring Claude Skills with proper metadata and orchestration logic.
connect-apps-plugin/README.md	Documentation for the reference Skill that wraps multiple MCP Tools, demonstrating the Skill-over-Tool pattern.

Summary

• MCP handles transport, authentication, and discovery—enabling the LLM to find and call remote functions.
• Tools are atomic, executable functions exposed through MCP servers that perform single operations like creating issues or sending messages.
• Skills contain SKILL.md files that provide high-level workflow instructions, determining which Tools to call and in what sequence.
• The Connect-apps implementation in ComposioHQ/awesome-claude-skills demonstrates how Skills orchestrate underlying Tools while MCP manages the protocol layer.

Frequently Asked Questions

How does an MCP Tool differ from a Claude Skill?

An MCP Tool is a single executable function that performs one specific action, such as creating a GitHub issue or sending a Slack message. A Claude Skill is a higher-level instruction set that orchestrates multiple Tools into a workflow. While Tools are exposed through the MCP protocol, Skills are loaded from SKILL.md files that tell the LLM when and how to use those Tools.

Can I use MCP Tools without creating a Skill?

Yes. As shown in the connect-apps-plugin examples, you can invoke Tools directly through the MCP gateway using command-line interfaces or API calls. However, Skills provide structured workflows, authentication handling, and context management that make complex multi-step operations more reliable.

Where is the Skill metadata defined?

Skill metadata is defined in the SKILL.md file located at the root of each Skill directory. According to the template in skill-creator/SKILL.md, this file must include YAML frontmatter specifying the name and description, followed by Markdown sections detailing usage instructions, workflow steps, and example prompts.

What file defines best practices for building MCP servers?

The file mcp-builder/reference/mcp_best_practices.md contains the authoritative guidelines for constructing MCP servers, handling authentication flows, and exposing Tools according to the Model Context Protocol specifications implemented in the Composio ecosystem.

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