Which integrations are available for this server?

Provides development skills and best practices for building mobile applications with React Native and the Expo ecosystem. Enables ML model training, dataset management, and interaction with the Hugging Face Hub through specialized agent skills. Provides workflow automation patterns and best practices for creating integrations with n8n. Offers development skills for Next.js, including conventions, patterns, and performance optimization guidelines. Provides skills for React development, focusing on performance optimization and engineering best practices. Provides best practices and guidance for managing content and development within the Sanity CMS. Provides skills for code reviews, pull request automation, and bug detection based on Sentry's engineering conventions. Offers best practices and implementation guidance for integrating payment solutions using Stripe. Enables application deployment to Vercel and provides guidelines for UI/UX design and web performance.

How do I use Awesome Agent Skills MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Awesome Agent Skills MCP Server Find a skill for document processing from the Anthropic collection" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Awesome Agent Skills MCP Server

by shadowrootdev

Overview Schema Related Servers Score Discussions

TypeScript

Remote

Awesome Agent Skills MCP Server

Security Audit CodeQL npm version npm downloads License: MIT Node.js Version MCP Compatible GitHub release GitHub stars

A Model Context Protocol (MCP) server that provides access to 100+ curated AI agent skills from the VoltAgent Awesome Agent Skills collection.

Transform your AI assistants into specialized experts with skills from Anthropic, Vercel, Trail of Bits, Hugging Face, Stripe, Expo, and many more leading organizations.

🚀 Quick Start

npx awesome-agent-skills-mcp

That's it! Add to your MCP client config and start using 100+ AI skills.

Related MCP server: skills-master-mcp

Features

100+ Curated Skills - Access skills from top organizations including Anthropic, Vercel, Trail of Bits, Hugging Face, and more
Auto-Sync - Automatically fetches and updates skills from the VoltAgent repository
MCP 2024-11-05 Compliant - Full compatibility with the latest Model Context Protocol specification
Multi-Client Support - Works with Claude, GitHub Copilot, OpenCode, and any MCP-compatible client
Smart Caching - Efficient JSON-based caching for fast startup times
Type-Safe - Built with TypeScript and Zod for runtime validation
Zero Configuration - Works out of the box with sensible defaults

Quick Start

Using npx (Recommended)

npx awesome-agent-skills-mcp

Global Installation

npm install -g awesome-agent-skills-mcp
awesome-agent-skills-mcp

Installation

Prerequisites

Node.js >= 20.0.0
npm or yarn

From npm

npm install awesome-agent-skills-mcp

From Source

git clone https://github.com/shadowrootdev/awesome-agent-skills-mcp.git
cd awesome-agent-skills-mcp
npm install
npm run build

Configuration

VS Code / GitHub Copilot

Create or update .vscode/mcp.json in your project:

{
  "servers": {
    "awesome-agent-skills": {
      "command": "npx",
      "args": ["awesome-agent-skills-mcp"]
    }
  }
}

Or with a local installation:

{
  "servers": {
    "awesome-agent-skills": {
      "command": "node",
      "args": ["/path/to/awesome-agent-skills-mcp/dist/index.js"]
    }
  }
}

Important: After adding the configuration, fully quit VS Code (Cmd+Q / Alt+F4) and reopen it for changes to take effect.

Claude Desktop

Add to your Claude Desktop configuration (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "awesome-agent-skills": {
      "command": "npx",
      "args": ["awesome-agent-skills-mcp"]
    }
  }
}

OpenCode

Add to ~/.config/opencode/opencode.json:

{
  "mcp": {
    "awesome-agent-skills": {
      "type": "local",
      "command": ["npx", "awesome-agent-skills-mcp"],
      "enabled": true
    }
  }
}

Environment Variables

Variable	Default	Description
`SKILLS_REPO_URL`	`https://github.com/VoltAgent/awesome-agent-skills.git`	Skills repository URL
`SKILLS_CACHE_DIR`	`.cache`	Cache directory path
`SKILLS_SYNC_INTERVAL`	`60`	Auto-sync interval in minutes (0 to disable)
`LOG_LEVEL`	`info`	Logging level (debug, info, warn, error)

Available Skills

The server provides access to 100+ skills from leading organizations:

Anthropic

Document processing, presentation creation, spreadsheet manipulation, PDF handling, algorithmic art, MCP building, and more.

Skill	Description
`docx`	Create, edit, and analyze Word documents
`pptx`	PowerPoint presentation creation and editing
`xlsx`	Spreadsheet manipulation with formulas
`pdf`	PDF processing and form filling
`mcp-builder`	Guide for creating MCP servers
`webapp-testing`	Playwright-based web app testing

Vercel

React and Next.js best practices, deployment, and performance optimization.

Skill	Description
`react-best-practices`	React performance optimization guidelines
`next-best-practices`	Next.js conventions and patterns
`web-design-guidelines`	UI/UX compliance review
`vercel-deploy`	Deploy apps to Vercel

Trail of Bits

Security analysis, smart contract auditing, and code review tools.

Skill	Description
`building-secure-contracts`	Smart contract security toolkit
`semgrep-rule-creator`	Create custom Semgrep rules
`property-based-testing`	Property-based testing guidance
`static-analysis`	Static analysis tooling

Hugging Face

ML model training, dataset management, and Hub operations.

Skill	Description
`hugging-face-cli`	HF Hub CLI operations
`hugging-face-datasets`	Dataset creation and management
`hugging-face-model-trainer`	Model fine-tuning with TRL
`hugging-face-evaluation`	Model evaluation workflows

Sentry

Code review, commit conventions, and PR automation.

Skill	Description
`code-review`	Sentry engineering code review practices
`commit`	Conventional commit messages
`create-pr`	PR creation following Sentry conventions
`find-bugs`	Bug and vulnerability detection

And Many More...

Stripe - Payment integration best practices
Expo - React Native app development
n8n - Workflow automation patterns
Sanity - CMS best practices
Neon - Serverless Postgres
Remotion - Programmatic video creation

MCP Tools

The server exposes four MCP tools:

`list_skills`

List all available skills with optional filtering.

// List all skills
{ }

// Filter by source
{ "source": "repository" }

// Filter by tag
{ "tag": "security" }

`get_skill`

Get detailed information about a specific skill.

{ "skill_id": "react-best-practices" }

`invoke_skill`

Invoke a skill with optional parameters.

{
  "skill_id": "docx",
  "parameters": {
    "document_type": "report"
  }
}

`refresh_skills`

Manually trigger a skills refresh from the repository.

{ }

Usage Examples

In GitHub Copilot Chat

@workspace Use the react-best-practices skill to review my React components

@workspace List all available security-related skills

@workspace Get the stripe-best-practices skill and apply it to my checkout code

In Claude

What skills are available for Next.js development?

Use the code-review skill to analyze my pull request

Development

Setup

git clone https://github.com/shadowrootdev/awesome-agent-skills-mcp.git
cd awesome-agent-skills-mcp
npm install

Build

npm run build

Run Tests

# Run all tests
npm test

# Run tests in watch mode
npm run test:watch

# Run integration tests only
npm run test:integration

Lint & Format

npm run lint
npm run format

Project Structure

awesome-agent-skills-mcp/
├── src/
│   ├── index.ts              # Entry point
│   ├── server.ts             # MCP server implementation
│   ├── config.ts             # Configuration management
│   ├── models/
│   │   ├── skill.ts          # Skill type definitions
│   │   ├── parameter.ts      # Parameter schemas
│   │   ├── registry.ts       # SkillRegistry class
│   │   └── repository.ts     # Repository source model
│   ├── services/
│   │   ├── git-sync.ts       # Git repository sync
│   │   ├── skill-parser.ts   # Skill parsing from README
│   │   └── skill-executor.ts # Skill invocation
│   ├── cache/
│   │   └── cache-manager.ts  # JSON-based caching
│   └── utils/
│       └── logger.ts         # Structured logging
├── tests/
│   ├── unit/                 # Unit tests
│   └── integration/          # Integration tests
├── dist/                     # Compiled output
└── .cache/                   # Runtime cache (gitignored)

API Reference

Skill Object

interface Skill {
  id: string;           // Unique identifier
  name: string;         // Display name
  description: string;  // Short description
  source: 'repository' | 'local';
  sourcePath: string;   // GitHub URL or local path
  content: string;      // Full skill content (markdown)
  parameters: ParameterSchema[];
  metadata: {
    author?: string;
    version?: string;
    tags?: string[];
    requirements?: string[];
    sourceOrg?: string;   // GitHub organization
    sourceRepo?: string;  // GitHub repository
  };
  lastUpdated: Date;
}

Parameter Schema

interface ParameterSchema {
  name: string;
  type: 'string' | 'number' | 'boolean' | 'object' | 'array';
  description: string;
  required: boolean;
  default?: unknown;
  enum?: unknown[];
}

Troubleshooting

Skills Not Loading

Check cache: Delete .cache directory and restart
Verify network: Ensure access to GitHub
Check logs: Set LOG_LEVEL=debug for verbose output

GitHub Copilot Not Seeing Skills

Full restart required: Quit VS Code completely (Cmd+Q) and reopen
Check config path: Ensure .vscode/mcp.json is in the workspace root
Verify server: Run npx awesome-agent-skills-mcp manually to test

Connection Errors

# Test the server manually
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0.0"}}}' | npx awesome-agent-skills-mcp

Credits

This project is built on top of the incredible work by the open-source community:

Data Source

VoltAgent Awesome Agent Skills - A curated collection of AI agent skills maintained by VoltAgent. This MCP server fetches and serves skills from this repository, making them accessible to MCP-compatible AI assistants.

Skill Contributors

Skills in this collection are contributed by leading organizations including:

Anthropic - Document processing, art generation, MCP building
Vercel - React, Next.js, deployment
Trail of Bits - Security analysis, smart contracts
Hugging Face - ML workflows, model training
Sentry - Code review, commit conventions
Expo - React Native development
Stripe - Payment integrations
And many more contributors!

Technologies

Model Context Protocol - The protocol specification
@modelcontextprotocol/sdk - Official TypeScript SDK
Zod - TypeScript-first schema validation
simple-git - Git operations

Contributing

Contributions are welcome! Please read our contributing guidelines before submitting PRs.

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

See our issue templates for reporting bugs, requesting features, or asking questions.

Documentation & Demo

GitHub Pages

You can enable GitHub Pages to host interactive documentation or demos:

Create your documentation (recommended: use /docs folder):
- Create a docs/ directory in your repository root
- Add an index.html file or use a static site generator like VitePress or Docusaurus
- This keeps documentation separate from source code
Enable GitHub Pages:
- Go to your repository Settings → Pages
- Select Source: Deploy from a branch
- Choose Branch: main and folder /docs (recommended) or / if deploying entire repo
- Save and wait for deployment

This is useful for:

Interactive API documentation
Live demos of MCP server capabilities
Tutorial walkthroughs
Skill catalog browser

Note: Using the /docs folder is recommended as it keeps documentation organized and separate from source code. Only use / (root) if you want to deploy the entire repository as a website.

License

This project is licensed under the MIT License - see the LICENSE file for details.

VoltAgent - AI agent framework
Awesome Agent Skills - The source skill collection
MCP Servers - Official MCP server implementations

Available Tools

4 tools

get_skillA

Read-only

Get detailed information and documentation for a specific skill

ParametersJSON Schema

Name	Required	Description	Default
`skill_id`	Yes	Unique identifier of the skill

Output Schema

ParametersJSON Schema

Name	Required	Description
`id`	No
`name`	No
`description`	No
`content`	No
`source`	No
`parameters`	No
`metadata`	No

TDQS

A3.9/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate readOnlyHint=true, confirming a safe read operation. The description adds no further behavioral traits (e.g., auth needs, rate limits), but does not contradict annotations. With annotations present, the bar is lower, and the description is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, front-loaded sentence that conveys the tool's purpose without fluff. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple get-by-ID tool with one parameter and an output schema (not shown), the description covers the essentials. No gaps given the tool's minimal complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%. The description adds no additional meaning beyond what the schema provides for the sole parameter 'skill_id' (unique identifier). Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('get') and the resource ('detailed information and documentation for a specific skill'). It distinguishes from sibling tools (invoke_skill, list_skills, refresh_skills) by focusing on retrieval of detailed info for one skill.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit when-to-use or when-not-to-use guidance. The description implies usage for retrieving details of a specific skill, but does not mention alternatives or exclusions, leaving the agent to infer from sibling tool names.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

invoke_skillB

Invoke a skill with parameters to get formatted instructions

ParametersJSON Schema

Name	Required	Description	Default
`skill_id`	Yes	Unique identifier of the skill to invoke
`parameters`	No	Parameters to pass to the skill

Output Schema

ParametersJSON Schema

Name	Required	Description
`success`	No
`content`	No
`error`	No
`executionTime`	No

TDQS

B3.3/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations indicating it is not read-only, the description adds minimal behavioral context. It does not explain side effects, state changes, or any constraints (e.g., rate limits, required permissions).

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no unnecessary words, front-loading the key action and resource. Every part earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema, the description does not need to explain return values. However, it lacks context on error conditions, parameter validation, and prerequisites, making it minimally complete for a simple invocation tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage for both parameters. The description adds no additional meaning beyond what the schema provides, so it meets the baseline but does not enhance understanding.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'invoke' and resource 'skill', and specifies the outcome 'get formatted instructions'. This distinguishes it from siblings like 'get_skill' and 'list_skills'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or typical use cases, leaving the agent to infer context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_skillsA

Read-only

List all available agent skills that can be invoked

ParametersJSON Schema

Name	Required	Description	Default
`filter`	No	Optional filter to search skills by name or description
`source`	No	Filter by skill source	all

Output Schema

ParametersJSON Schema

Name	Required	Description
`skills`	No
`total`	No
`lastSync`	No

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint true. Description adds no extra behavioral context beyond stating it lists skills, which is expected from a read operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, no wasted words, appropriate for a simple list tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Sufficient for a read-only list operation with output schema present. Minimal but not missing critical information, though it could mention filtering or sorting behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has 100% coverage, describing both parameters fully. The description adds no additional meaning beyond what the schema provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists all available agent skills, using a specific verb and resource. It naturally distinguishes from siblings like get_skill, invoke_skill, and refresh_skills.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives. Usage is implied by the purpose but not elaborated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

refresh_skillsA

Idempotent

Refresh skills cache from the repository

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`success`	No
`skillsUpdated`	No
`skillsAdded`	No
`skillsRemoved`	No
`message`	No

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate idempotence and non-destructiveness. The description adds that it refreshes cache, but doesn't elaborate on side effects or what exactly happens. With annotations covering safety, the description adds minimal extra transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very concise at 4 words. While it could include more context (e.g., what 'repository' refers to), it is not verbose and front-loads the purpose. Slightly under-specified but not overly long.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no parameters and an output schema, the description is minimal. It does not mention prerequisites, error conditions, or what the refresh entails. For a cache refresh tool, more context about the repository and potential impacts would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so the description does not need to explain param meanings. The description's mention of 'skills cache' aligns with the lack of parameters. Baseline for 0 params is 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Refresh') and the target ('skills cache from the repository'). It distinguishes from sibling tools which are about getting, invoking, or listing skills, not cache management.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide explicit guidance on when to use this tool vs alternatives. It implies it is for cache refresh but lacks context on prerequisites or scenarios where it should be avoided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4/5.0

Disambiguation5/5

Each tool has a clear and distinct purpose: listing, getting details, invoking, and refreshing skills. No overlap in functionality.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern with underscores (list_skills, get_skill, invoke_skill, refresh_skills), making them predictable.

Tool Count5/5

Four tools is well-scoped for a skill management server, covering essential operations without unnecessary bloat.

Completeness5/5

The tool set covers the full lifecycle for the domain: discover (list), inspect (get), execute (invoke), and update cache (refresh). No obvious gaps.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

Need Help?

Reddit Discussion

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Skilder
ai.skilder
One place to build, share, and govern the skills and tools your AI agents use at work.
Developer Tools CI/CD & DevOps
1
AI Skill Store A
io.github.garasegae
Agent-first skill marketplace with USK open standard for Claude, Cursor, Gemini, Codex CLI.
AI & Machine Learning Agent Orchestration Developer Tools
1824
agentpmt
com.agentpmt
AI agent marketplace for automated employees, workflows, skills, and tool orchestration.
Agent Orchestration Autonomous Agents App Automation
2
MidOS - MCP Community Library A
io.github.MidOSresearch
Curated knowledge API for AI agents - skill packs, semantic search, validated patterns.
Knowledge & Memory RAG Systems Search
28

Related MCP Servers

Worksona MCP Serverofficial
Agent Orchestration Developer Tools Autonomous Agents
worksona
A
license
Not graded
quality
D
maintenance
Integrates 100+ specialized AI agents with Claude Desktop, providing automated agent discovery, multi-agent coordination, and ready-to-use task templates for complex development and business workflows. Enables users to leverage enterprise-level AI capabilities through actionable resources and intelligent agent matching.
Updated a year ago (2025-10-08 14:48 UTC)
17
MIT
skills-master-mcp
Developer Tools Coding Agents Autonomous Agents
adarc8
A
license
A
quality
D
maintenance
Connects AI coding agents to the SkillsMP marketplace, allowing users to search, read, and install over 8,000 community-made skills. It enables agents to gain new capabilities either through on-the-spot instruction or permanent installation without requiring an API key.
Updated 7 months ago (2026-02-16 23:50 UTC)
5
22
10
MIT
Code Whisperer MCP
Developer Tools Autonomous Agents Agent Orchestration
Invictus-Labs
A
license
A
quality
D
maintenance
Provides access to a library of 18 specialized skills, project templates, and prompt patterns for Claude Code. It enables automated workflows for feature development, security audits, and system maintenance through multi-agent collaboration.
Updated 3 months ago (2026-06-15 13:45 UTC)
6
13
MIT
cort4ex-mcp
0xChampi
-
license
Not graded
quality
Not graded
maintenance
Provides access to 224 battle-tested skills plus multi-agent orchestration, exposed as tools for Claude or Codex.
Updated 3 months ago (2026-06-08 18:27 UTC)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/shadowrootdev/awesome-agent-skills-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Awesome Agent Skills MCP Server

🚀 Quick Start

Table of Contents

Features

Quick Start

Using npx (Recommended)

Global Installation

Installation

Prerequisites

From npm

From Source

Configuration

VS Code / GitHub Copilot

Claude Desktop

OpenCode

Environment Variables

Available Skills

Anthropic

Vercel

Trail of Bits

Hugging Face

Sentry

And Many More...

MCP Tools

list_skills

get_skill

invoke_skill

refresh_skills

Usage Examples

In GitHub Copilot Chat

In Claude

Development

Setup

Build

Run Tests

Lint & Format

Project Structure

API Reference

Skill Object

Parameter Schema

Troubleshooting

Skills Not Loading

GitHub Copilot Not Seeing Skills

Connection Errors

Credits

Data Source

Skill Contributors

Technologies

Contributing

Documentation & Demo

GitHub Pages

License

Related Projects

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Worksona MCP Serverofficial

Latest Blog Posts

MCP directory API

`list_skills`

`get_skill`

`invoke_skill`

`refresh_skills`