Plugin Directory
Claude Code plugins extend the base Claude Code CLI with callable tools, persistent memory, browser automation, database access, and more. Most plugins ship as MCP (Model Context Protocol) servers that Claude Code can invoke directly during coding sessions—no manual switching between tools required.
This directory lists the best Claude Code plugins across three categories: Dev Tools, Productivity, and Automation. Each entry includes a description, install command, and source so you can evaluate and adopt quickly.
Dev Tools
6 plugins listed
Productivity
4 plugins listed
Automation
2 plugins listed
Best Claude Plugins
All plugins are MCP-compatible unless noted. Install commands use npx for zero-install execution; substitute npm global install if you prefer pinned versions.
Gives Claude Code structured read/write access to local directories. Useful for project scaffolding, file search, and batch editing outside the current working directory.
Install
npx -y @modelcontextprotocol/server-filesystem <path>github.com/modelcontextprotocol/servers
Connects Claude Code to GitHub repositories, issues, pull requests, and code search. Lets Claude read PR diffs and post review comments without leaving the terminal.
Install
npx -y @modelcontextprotocol/server-githubgithub.com/modelcontextprotocol/servers
Enables browser automation from inside Claude Code. Claude can navigate pages, fill forms, take screenshots, and extract page content during testing or scraping tasks.
Install
npx -y @playwright/mcp@latestgithub.com/microsoft/playwright-mcp
Allows Claude Code to query PostgreSQL databases directly. Useful for schema inspection, data validation, and writing migrations during active development sessions.
Install
npx -y @modelcontextprotocol/server-postgres <connection-string>github.com/modelcontextprotocol/servers
Gives Claude Code access to Brave Search results without a browser. Use it to look up documentation, library versions, or current events during coding tasks.
Install
npx -y @modelcontextprotocol/server-brave-searchgithub.com/modelcontextprotocol/servers
Adds persistent key-value memory to Claude Code sessions. Claude can store project facts, decisions, or context snippets and retrieve them in future sessions.
Install
npx -y @modelcontextprotocol/server-memorygithub.com/modelcontextprotocol/servers
Connects Claude Code to Slack workspaces so it can read channel messages, post updates, and search message history as part of automated workflows.
Install
npx -y @modelcontextprotocol/server-slackgithub.com/modelcontextprotocol/servers
Gives Claude Code lightweight database access for local SQLite files. Good for prototyping, local data exploration, and small-scale tool backends.
Install
npx -y @modelcontextprotocol/server-sqlite --db-path ./data.dbgithub.com/modelcontextprotocol/servers
Connects Claude Code to an Obsidian vault for reading notes, searching linked content, and writing new entries. Good for research and documentation workflows.
Install
npm install obsidian-mcp-tools (see README for vault config)github.com/AgentSkillsHub
Adds structured project mapping to Claude Code. Tracks tasks, dependencies, and progress states in a queryable graph so long-running sessions stay coherent.
Install
npx -y evomap-mcp@latestgithub.com/evomap
Lets Claude Code fetch any URL and return the content as text or structured data. Simple but powerful for reading documentation, changelog pages, or API reference at runtime.
Install
npx -y @modelcontextprotocol/server-fetchgithub.com/modelcontextprotocol/servers
Adds a structured scratchpad tool that encourages Claude to think in explicit steps before responding. Reduces hallucinations on multi-step coding and planning tasks.
Install
npx -y @modelcontextprotocol/server-sequential-thinkinggithub.com/modelcontextprotocol/servers
Installation
Claude Code plugins run as local MCP servers. The four-step process below works for most official and community plugins.
Browse this directory or visit the official Claude Code documentation. Note the install command and any required environment variables.
Run "claude mcp add <server-name> -- npx -y <package>" in your terminal, or add the server entry directly to your Claude Code MCP config file.
Some plugins like GitHub or Slack require API tokens. Pass them as environment variables referenced in the MCP config, never hardcoded in CLAUDE.md.
Start a new Claude Code session and run /tools to confirm the plugin's tools appear in the active tool list. Test with a simple tool call before using in production workflows.
Config example (claude_mcp_config.json)
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/project"]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "$GITHUB_TOKEN" }
}
}
}Concepts
Three extension mechanisms exist in the Claude Code ecosystem. Understanding the boundary prevents configuration confusion.
| Type | How it works | Best for |
|---|---|---|
| MCP Plugin | Runs as a local server, exposes callable tools to Claude during a session | Database queries, browser control, external API calls |
| Skill (.md file) | Markdown instruction set loaded into system context via CLAUDE.md or Skill tool | Workflow enforcement, team standards, repeatable reasoning patterns |
| Extension / Hook | Shell scripts triggered by Claude Code events (pre-tool, post-tool) | Auto-formatting, side-effect capture, audit logging |
Most people searching for "Claude Code plugins" are looking for MCP servers. If you need behavior guidance rather than tool access, skills are the right mechanism. If you need to run code after every file edit, hooks are the right choice.
Execution Brief
Use this page as a rollout checklist, not just reference text.
Tool Mapping Lens
Catalog-oriented pages work best when users can map discovery, evaluation, and rollout in a clear path instead of reading an undifferentiated list.
Use this board for Claude Code Plugins before rollout. Capture inputs, apply one decision rule, execute the checklist, and log outcome.
Input: Objective
Deliver one measurable improvement with claude code plugins
Input: Baseline Window
20-30 minutes
Input: Fallback Window
8-12 minutes
| Decision Trigger | Action | Expected Output |
|---|---|---|
| Input: one workflow objective and release owner are defined | Run preview execution with fixed acceptance criteria. | Go or hold decision backed by repeatable evidence. |
| Input: output quality below baseline or retries increase | Limit scope, isolate root issue, and rerun controlled test. | One confirmed correction path before wider rollout. |
| Input: checks pass for two consecutive replay windows | Promote to broader traffic with fallback path active. | Stable rollout with low operational surprise. |
tool=claude code plugins objective= preview_result=pass|fail primary_metric= next_step=rollout|patch|hold
Claude Code plugins are modular extensions that add callable tools, memory layers, or external service connections to Claude Code sessions. The most common plugin type is an MCP (Model Context Protocol) server—a lightweight local process that Claude Code can query as part of its tool-use loop. When a plugin is registered, its tools appear alongside built-in capabilities like file editing and bash execution, so Claude can use them without manual user handoff.
The plugin model exists because no single AI assistant can embed every API, database connector, and automation surface natively. MCP lets third-party developers expose standardized tool interfaces that Claude Code can discover and call at runtime. This keeps the core CLI lightweight while making the effective capability surface almost unbounded.
Skills are a related but distinct extension type. A skill is a markdown instruction file that shapes how Claude reasons and follows workflow rules—not a runtime tool. The distinction matters when choosing the right extension for a task: use a plugin when you need Claude to call a real API or query a real database; use a skill when you need Claude to follow a process or apply consistent judgment across a project.
Start by identifying the capability gap. If Claude Code cannot reach a resource you need—a database, a browser, a remote API—find the matching MCP server in this directory or in the official Model Context Protocol server index. Avoid installing plugins for capabilities Claude already handles natively to keep the tool list clean.
Register the plugin with the minimum required permissions. Most MCP servers accept a path or connection string as configuration. Pass secrets via environment variables, never inline. After registration, use /tools in a Claude Code session to confirm the new tools appear and do a quick smoke test before relying on them in production workflows.
Maintain a short plugin list. Every active MCP server adds process overhead and a new tool surface for Claude to consider on each turn. Teams that keep fewer than 10 active plugins report cleaner tool selection and fewer irrelevant tool calls. Audit your plugin list monthly and retire servers that no longer map to active workflows.
Treat this page as a decision map. Build a shortlist fast, then run a focused second pass for security, ownership, and operational fit.
When a team keeps one shared selection rubric, tool adoption speeds up because evaluators stop debating criteria every time a new option appears.
Outcome: Migration is correct on the first run because Claude had real schema context rather than relying on stale documentation.
Outcome: Test file reflects actual page behavior rather than guessed selectors, reducing initial failure rate significantly.
Outcome: Onboarding time for new sessions drops and architectural decisions stay consistent across weeks of development.
Claude Code plugins are extensions that add new tools, MCP servers, or behavior customizations to Claude Code. They can range from MCP-compatible API connectors to local filesystem tools and custom workflow scripts, installed via the Claude Code CLI or loaded through CLAUDE.md configuration.
Most Claude Code plugins are installed by adding an MCP server entry to your Claude Code settings or CLAUDE.md file. Some ship as npm packages installable via npx. Run "claude mcp add <server-name>" or follow the plugin's README for the specific install command.
Plugins and extensions are often used interchangeably for Claude Code. Strictly, MCP servers are tool providers registered in Claude's tool-use layer, while skills are behavior-shaping instruction sets stored as markdown files. Both extend Claude Code's capabilities but through different mechanisms.
Safety depends on the plugin's permission scope. Before installing, check what filesystem, network, or secret-handling access the plugin requests. Prefer plugins with clear documentation, open-source repos, and recent maintenance activity. Avoid plugins that request broad permissions without explanation.
The most-used developer plugins include the GitHub MCP server (repository context and PR management), Postgres/SQLite MCP servers (database querying), Playwright MCP (browser testing), and the Filesystem MCP server (structured file access). Each adds a direct tool surface that Claude Code can call during coding tasks.
Yes. Claude Code supports the Model Context Protocol (MCP). You can build a custom MCP server in Node.js, Python, or any language with an MCP SDK. Once built, register it in your Claude Code config and it becomes available as a callable tool.
Local plugins such as the Filesystem MCP server and local database connectors work offline. Cloud-connected plugins like GitHub or Slack MCP servers require network access. Check each plugin's documentation for connectivity requirements.
Send the exact workflow you are solving and we will prioritize a new comparison or rollout guide.