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

> Understand the Composio architecture MCP Tools and Skills. MCP is the transport protocol exposing Tools. Skills orchestrate Tools into workflows for efficient automation. Learn more.

- Repository: [Composio/awesome-claude-skills](https://github.com/composiohq/awesome-claude-skills)
- Tags: architecture
- Published: 2026-08-30

---

**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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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:

```bash

# 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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) file. The following example from [`skill-creator/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/skill-creator/SKILL.md) demonstrates the structure:

```markdown
---
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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/mcp-builder/reference/mcp_best_practices.md) | Contains detailed guidelines for building robust MCP servers and authenticating Tool calls. |
| [`skill-creator/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/skill-creator/SKILL.md) | Template and conventions for authoring Claude Skills with proper metadata and orchestration logic. |
| [`connect-apps-plugin/README.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) file located at the root of each Skill directory. According to the template in [`skill-creator/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/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.