The Model Context Protocol (MCP) is the part of the Claude ecosystem that quietly went from “neat extension mechanism” to “the reason I never close Claude”. Once you’ve wired Claude into the apps you actually live in - your notes, your mind maps, your mailbox, your browser, your entire Google Workspace - going back to a stock chatbot feels like coding without an IDE.

But MCPs are only half the story. Skills - reusable prompt templates that trigger automatically based on context - are the other force multiplier. Combined, they turn Claude Code from a coding assistant into an autonomous productivity platform.

This post is my definitive guide to the MCPs and skills I genuinely use. For each one you’ll find: what it does, why it earned a spot in my setup, a copy-paste install recipe, and real workflows I run with it.

Who is this for? Anyone using Claude Code or Claude Desktop on macOS who wants to go from “I use AI to write code” to “AI is woven into every tool I touch.”

---

How MCP & Skills Work on macOS - A 2-Minute Primer

MCP Servers

MCP servers are small local processes that Claude launches on demand and talks to over stdio. On macOS that almost always means one of three runtimes:

• Node.js (npx) - most common, zero install if you already have Node
• Python (uvx from Astral’s uv) - increasingly the standard for Python servers
• A native binary - rare, but a few servers ship as compiled tools

Claude Desktop reads its MCP configuration from:

~/Library/Application Support/Claude/claude_desktop_config.json

Claude Code reads from ~/.claude.json (or per-project .mcp.json), and you can also add servers interactively with:

claude mcp add <name> -- <command> [args...]

After editing config files you need to fully quit and relaunch Claude Desktop - a window close isn’t enough. For Claude Code, the next session picks up changes automatically.

Skills

Skills are markdown-based prompt templates that live in your ~/.claude/skills/ directory (or are installed via plugins). They trigger automatically when Claude detects a matching context - like a debugging skill activating when you hit an error, or a TDD skill activating when you start implementing a feature.

You invoke skills explicitly with /skill-name or let them fire automatically. They’re the closest thing to “teaching Claude your workflow once and having it follow it forever.”

Prerequisites

If you don’t have the runtimes yet:

# Node (via Homebrew)
brew install node

# uv (for Python-based MCP servers)
brew install uv

That’s it. Onwards.

---

Part 1: The MCP Servers

1. Obsidian MCP - Claude in My Second Brain

Repo: jacksteamdev/obsidian-mcp-tools

What it does: Gives Claude full read/write access to your Obsidian vault - searching notes, reading files, creating new ones, patching sections, executing Templater templates, even fetching the currently active file.

Why I love it: My vault is a decade of thinking compressed into markdown. Hooking Claude into it turned a passive archive into an active research partner. I can ask “what did I conclude about sleep cycles last year?” and get an answer grounded in my own writing, not a generic summary from the internet. Drafting new notes from a conversation is now a single sentence: “save this as a note in /Inbox with tags x, y, z” - done.

It also makes Claude shockingly good at synthesis across notes. Ask it to find tensions between two essays you wrote a year apart and it will actually do it.

Install:

1. In Obsidian, install the Local REST API community plugin and enable it. Copy the API key it generates.
2. Install the MCP Tools for Obsidian plugin (this ships the MCP binary itself). The plugin’s settings page has a one-click “Install MCP Server” button - let it do its thing. The binary will be placed inside your vault at .obsidian/plugins/mcp-tools/bin/mcp-server.
3. Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "obsidian": {
      "command": "/path/to/your/vault/.obsidian/plugins/mcp-tools/bin/mcp-server",
      "env": {
        "OBSIDIAN_API_KEY": "your-local-rest-api-key-here"
      }
    }
  }
}

4. Quit and relaunch Claude Desktop. Ask it “list the files in my vault” to confirm it’s wired up.

Pro tip: Combine this with a Templater template that generates a daily note skeleton, then have Claude execute it each morning with today’s open tasks pulled from your project tracker.

---

2. XMind MCP - Mind Maps as a First-Class Output Format

Repo: apeyroux/mcp-xmind | npm: @41px/mcp-xmind

What it does: Lets Claude read, search, and create .xmind files directly. You can ask it to “turn this brainstorm into a mind map”, “extract the marketing branch from my product strategy map”, or “summarise everything under the ‘Risks’ node”.

Why I love it: Mind maps are the format I reach for when I’m thinking through anything with more than two layers of structure - product strategy, org design, conference talks, even debugging trees. Until this MCP existed, the loop was: think in Claude -> manually rebuild as XMind. Now Claude just outputs an .xmind file and I open it. The friction collapse is unreasonable.

I also use it the other way around: feed Claude an existing map and ask it to critique the structure, find missing branches, or export a specific subtree as a markdown briefing for someone who doesn’t use XMind.

Install:

# Via the Claude Code CLI
claude mcp add xmind -- npx -y @41px/mcp-xmind

Or for Claude Desktop, add to claude_desktop_config.json:

{
  "mcpServers": {
    "xmind": {
      "command": "npx",
      "args": ["-y", "@41px/mcp-xmind"],
      "env": {
        "XMIND_FILES_DIRECTORY": "/Users/YOUR_USERNAME/Documents/XMind"
      }
    }
  }
}

Set XMIND_FILES_DIRECTORY to wherever you keep your maps - the server scopes its file operations to that folder.

Pro tip: Pair it with the Obsidian MCP and ask Claude to “build an XMind from the headings of every note tagged #strategy in my vault”. Cross-tool composition is where MCP really shines.

---

3. GitHub MCP - The One I Forget I’m Using

Repo: github/github-mcp-server (GitHub’s official server)

What it does: GitHub’s official MCP server. Read and write issues, PRs, branches, file contents, run code search, manage releases, request Copilot reviews - basically the whole gh CLI surface, exposed as MCP tools.

Why I love it: Every “go check what’s happening on PR 412” or “open an issue describing this bug” used to mean a context switch. Now it’s a sentence in the same conversation where I just diagnosed the problem. For maintainers of multiple repos this is the single biggest time saver in my whole MCP stack.

Install:

claude mcp add github -- npx -y @modelcontextprotocol/server-github

You’ll need a GitHub Personal Access Token with repo scope. Either export it as GITHUB_PERSONAL_ACCESS_TOKEN in your shell, or pass it inline:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx..."
      }
    }
  }
}

---

4. Claude Preview MCP - A Real Browser for the Agent

Bundled with Claude Code - ships with the official CLI from Anthropic.

What it does: Spins up a controllable browser/dev-server preview that Claude can actually look at - start servers, click buttons, fill forms, take screenshots, read console logs and network traffic, inspect computed CSS.

Why I love it: This is the MCP that makes Claude Code genuinely capable of frontend work. Instead of editing a component and asking me “can you check if it looks right?”, it edits, reloads, takes a screenshot, sees the broken layout, fixes it, and shows me the working result. The verification loop is closed inside the agent - which is exactly what you want from an autonomous coding session.

Install: Bundled with recent Claude Code releases - check claude mcp list to confirm Claude_Preview is present. If not:

claude mcp add claude-preview -- npx -y @anthropic-ai/claude-preview-mcp

No environment variables needed. Test it by asking Claude to “start a preview server in this project and screenshot the homepage”.

---

5. Firecrawl MCP - The Web, Structured and Searchable

Repo: firecrawl/firecrawl-mcp-server | 6,000+ stars

What it does: Web scraping, site crawling, search, content extraction, deep research, and batch scraping - all exposed as MCP tools. It can read any webpage, crawl an entire domain, extract structured data, and even run a “deep research” mode that autonomously follows links and synthesizes findings.

Why I love it: This is the MCP that gives Claude eyes on the internet beyond simple web search. Need to analyze a competitor’s entire documentation site? Firecrawl crawls it and hands Claude structured markdown. Need to extract pricing tables from 20 vendor pages? Batch scrape. Need to research a topic in depth with real source material? Deep research mode.

The killer feature is cloud browser sessions - Firecrawl can handle JavaScript-rendered pages, login walls (with your credentials), and dynamic content that simple HTTP fetches miss entirely.

Install:

# Get your API key from https://www.firecrawl.dev/app/api-keys (free tier available)
claude mcp add firecrawl-mcp -e FIRECRAWL_API_KEY=fc-YOUR_KEY -- npx -y firecrawl-mcp

Or in claude_desktop_config.json:

{
  "mcpServers": {
    "firecrawl-mcp": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": {
        "FIRECRAWL_API_KEY": "fc-YOUR_API_KEY"
      }
    }
  }
}

Key workflows I run with it:

• “Crawl docs.example.com and summarize every breaking change in v4”
• “Scrape the top 10 results for ‘MCP server best practices’ and synthesize a report”
• “Extract the pricing page from these 5 competitors into a comparison table”

Pro tip: Combine with Obsidian MCP - have Claude research a topic with Firecrawl, then save a structured summary directly into your vault.

---

6. Playwright MCP - Browser Automation That Actually Works

Repo: microsoft/playwright-mcp | 30,500+ stars

What it does: Microsoft’s official MCP server for Playwright browser automation. Lets Claude interact with web pages through structured accessibility snapshots - not screenshots. This makes it fast, lightweight, and deterministic. No vision model overhead.

Why it matters: While Claude Preview is great for dev server verification, Playwright MCP is the tool for general browser automation - filling out forms, navigating multi-step flows, testing web apps, interacting with any website. It uses Playwright’s accessibility tree, which means Claude “sees” the page as structured data (buttons, inputs, links, text) rather than pixels. This is dramatically more reliable and token-efficient than screenshot-based approaches.

Install:

claude mcp add playwright -- npx @playwright/mcp@latest

Or in your config:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

No API keys needed - it runs a local Chromium instance.

Key workflows:

• “Open our staging site and test the entire checkout flow”
• “Fill out this form on the insurance portal with these details”
• “Navigate to Jira, find all tickets assigned to me, and summarize them”

Pro tip: Playwright MCP and Claude Preview MCP complement each other perfectly. Use Preview for dev server verification during coding, Playwright for everything else.

---

7. NotebookLM MCP - Grounded Research With Citations

Repo: jacob-bd/notebooklm-mcp-cli | 3,400+ stars

What it does: Gives Claude programmatic access to Google NotebookLM - creating notebooks, adding sources (URLs, text, Google Drive files), querying with citation-backed answers, and even generating audio podcasts, video summaries, and slide decks from your research.

Why it matters: This is the antidote to hallucination. When you need Claude to answer questions grounded in specific documents - not its training data - NotebookLM is the mechanism. Upload your PDFs, quarterly reports, or research papers to a notebook, then query through Claude with full citation tracking. Every answer points back to a specific passage in a specific source.

The 35+ tools include notebook CRUD, source management, cross-notebook queries, batch operations, and “studio” content generation (those AI-generated podcast conversations NotebookLM is famous for).

Install:

# Install via uv
uv tool install notebooklm-mcp-cli

# One-command setup for Claude Code
nlm setup add claude-code

It also supports Gemini CLI, Cursor, and other MCP clients - run nlm setup to see all options.

Important note: This uses internal Google APIs and requires cookie extraction from your browser for auth. It works with both free and Pro tier accounts. Run nlm auth and follow the prompts.

Key workflows:

• “Create a notebook from these 5 PDFs and tell me the key contradictions between them”
• “Query my ‘Q1 Board Deck’ notebook - what were the revenue projections?”
• “Generate an audio podcast summarizing my research notebook on AI regulation”

---

8. Google Workspace CLI - One CLI for All of Google

Repo: googleworkspace/cli | 24,200+ stars

What it does: A single CLI (gws) for all of Google Workspace - Drive, Gmail, Calendar, Sheets, Docs, Chat, Admin, and more. Built in Rust, it dynamically discovers all API endpoints from Google’s Discovery Service, so it automatically picks up new Google APIs as they’re released. Structured JSON output designed for both humans and AI agents. Ships with 40+ agent skills.

Why I love it: This replaces having to wire up separate MCPs for Gmail, Calendar, Drive, etc. One auth flow, one CLI, every Google service. The JSON-structured output is purpose-built for agent consumption - Claude can parse it cleanly without scraping HTML or navigating web UIs.

Install:

# Via npm
npm install -g @googleworkspace/cli

# Or Homebrew
brew install googleworkspace-cli

# Setup auth (one-time)
gws auth setup     # Configure Google Cloud project
gws auth login     # OAuth flow

For MCP integration, use the community wrapper:

claude mcp add google-workspace -- npx -y google-workspace-mcp

With config:

{
  "mcpServers": {
    "google-workspace": {
      "command": "npx",
      "args": ["-y", "google-workspace-mcp"],
      "env": {
        "GOOGLE_CLIENT_ID": "your-client-id",
        "GOOGLE_CLIENT_SECRET": "your-client-secret",
        "GOOGLE_REFRESH_TOKEN": "your-refresh-token"
      }
    }
  }
}

Key workflows:

• “Check my calendar for tomorrow and draft a prep doc in Google Docs for each meeting”
• “Create a Google Sheet with this quarter’s OKR tracking - columns for objective, key result, owner, status”
• “Search my Drive for all files containing ‘board deck’ modified in the last 30 days”
• “Send a Gmail to the team with a summary of today’s standup notes”

Note: This is a community-driven project, not officially supported by Google. But it’s actively maintained with 24K+ stars and works reliably.

---

9. Marp - Slide Decks from Markdown

Repo: marp-team/marp-cli | 3,380+ stars

What it does: Converts Markdown files into polished slide presentations. Outputs HTML, PDF, and PowerPoint (PPTX). Uses standard Markdown with simple directives for slide breaks, themes, and layout.

Why I love it: AI agents think in markdown. Marp turns that into presentation-ready slide decks without fighting with PowerPoint APIs or complex templating engines. The workflow is dead simple: Claude writes markdown with --- slide separators, runs marp, and you get a PPTX you can present in your next meeting.

Install:

# Global install
npm install -g @marp-team/marp-cli

# Or use npx for one-off conversions
npx @marp-team/marp-cli@latest slides.md --pptx

Usage with Claude Code:

Claude can create a slide deck end-to-end:

# Claude writes slides.md, then converts:
marp slides.md -o presentation.pptx   # PowerPoint
marp slides.md --pdf                   # PDF
marp slides.md -o slides.html          # Interactive HTML
marp -w slides.md                      # Watch mode with live reload

Markdown slide format:

---
marp: true
theme: default
paginate: true
header: 'Company Name'
---

# Quarterly Business Review

Q1 2026 Results

---

## Revenue Growth

- ARR up 34% YoY
- Net retention: 127%
- New logos: 48

![bg right:40%](chart.png)

---

## What's Next

1. Launch self-serve tier
2. Expand to APAC
3. SOC 2 Type II certification

Key workflows:

• “Turn this brainstorm into a 10-slide presentation”
• “Create a pitch deck for our Series B - include our metrics from the spreadsheet”
• “Build a technical architecture overview presentation for the engineering all-hands”

Pro tip: Marp supports custom CSS themes. Create a company-branded theme once, then every AI-generated deck is automatically on-brand. Claude Code also has a built-in anthropic-skills:pptx skill for direct PowerPoint creation if you need more complex layouts.

---

Part 2: The Skills & Frameworks

Skills and frameworks aren’t MCP servers - they’re tools, templates, and approaches that amplify what your agent can do. These are the ones that have fundamentally changed how I work with Claude Code.

10. Agent-Skills (Addy Osmani) - Production-Grade Engineering Workflows

Repo: addyosmani/agent-skills | 10,000+ stars

What it does: A Claude Code plugin that installs 21 production-grade engineering skills and 7 slash commands covering the full software development lifecycle - from spec writing through shipping. Built by Addy Osmani, a Senior Engineering Director at Google who led Chrome’s Developer Experience team.

Why it matters: This is the single most impactful addition to my Claude Code setup this year. Skills are the discipline layer that turns “vibe coding” into actual engineering. Each skill encodes a workflow that senior engineers follow - spec-driven development, TDD, five-axis code review, security hardening, shipping checklists - and the agent loads them on demand via progressive disclosure. Only the skill descriptions sit in context permanently; the full instructions load when relevant.

The killer feature is anti-rationalization: each skill includes a section that rebuts the excuses an agent (or a tired engineer) will invent to skip the process. When Claude considers skipping tests, the TDD skill’s rebuttal section catches it.

If you’re using Obsidian MCP for your knowledge base, this plugin pairs beautifully: the spec-driven-development skill writes specs that you can save directly to your vault, and the documentation-and-adrs skill generates Architecture Decision Records that become part of your permanent knowledge system.

Install:

# In a Claude Code session:
/plugin marketplace add addyosmani/agent-skills
/plugin install agent-skills@addy-agent-skills

Restart Claude Code after installing - skills are discovered at session start.

Troubleshooting: If the commands don’t appear, the marketplace clone likely failed via SSH. Fix with:

git config --global url."https://github.com/".insteadOf "git@github.com:"

The 7 slash commands:

/agent-skills:spec           → write a structured specification (saves to SPEC.md)
/agent-skills:plan           → break the spec into small, verifiable tasks
/agent-skills:build          → implement the next task incrementally (thin vertical slices)
/agent-skills:test           → TDD workflow; for bugs, uses the "Prove-It" pattern (failing test first)
/agent-skills:review         → five-axis code review (correctness, readability, architecture, security, performance)
/agent-skills:code-simplify  → simplify code for clarity without changing behavior
/agent-skills:ship           → pre-launch checklist (quality, security, performance, accessibility, infra, docs)

Key workflows:

• Start any non-trivial feature with /agent-skills:spec → /agent-skills:plan → /agent-skills:build
• Before every merge: /agent-skills:review catches issues across five axes
• Overnight agent runs with /agent-skills:ship ensure nothing deploys without the full checklist

Pro tip: Skills compose with MCPs. A skill that says “before responding to any architecture question, check my Obsidian vault” uses the Obsidian MCP. The documentation-and-adrs skill can save ADRs directly to your vault. Skills are the glue that connects your MCPs into workflows.

Deep dive: Want to understand how progressive disclosure works, why anti-rationalization matters, and how skills compare to GitHub’s Spec Kit? Read the full breakdown in my Skills Framework - From Vibe Coding to Production-Grade Agentic Engineering article.

---

11. awesome-design-md (VoltAgent) - Pixel-Perfect AI-Generated UIs

Repo: VoltAgent/awesome-design-md | 39,100+ stars

What it does: A curated collection of DESIGN.md files that capture the design systems of popular products - Claude, Linear, Supabase, Cursor, Stripe, Vercel, Raycast, and 50+ more. Drop one into your project root and tell Claude “build me a page that looks like this” - it generates pixel-perfect UI because it has the exact design tokens, spacing, colors, and component patterns.

Why it matters: This solves the biggest problem with AI-generated UIs: they look generic. Without a design spec, Claude produces competent but unremarkable interfaces. With a DESIGN.md, it produces UIs that look like they were built by the design team at Linear or Stripe.

The concept is simple but powerful: DESIGN.md is to visual design what CLAUDE.md is to engineering standards. It’s a markdown file that AI agents read natively, containing everything needed to reproduce a design system - color tokens, typography scales, spacing rhythms, component patterns, even micro-interactions.

Install:

No install needed. Browse the collection at getdesign.md or the GitHub repo, download the DESIGN.md for the aesthetic you want, and drop it in your project root.

# Example: grab the Linear design system
curl -o DESIGN.md https://raw.githubusercontent.com/VoltAgent/awesome-design-md/main/designs/linear.md

What’s inside a DESIGN.md:

## Color Tokens
--bg-primary: #0A0A0B
--accent: #5E6AD2
--text-primary: #EDEDEF

## Typography
Font: Inter, -apple-system, sans-serif
H1: 24px / 700 / -0.02em

## Components
### Button
- Primary: bg-accent, text-white, rounded-md, px-3 py-1.5
- Hover: brightness(1.1)
- Active: scale(0.98)
...

Key workflows:

• “Use the Linear design system and build me a project dashboard”
• “I want this landing page to look like Stripe - apply their DESIGN.md”
• “Generate an admin panel using the Supabase design language”

---

12. Autoresearch (Karpathy) - Autonomous ML Experimentation

Repo: karpathy/autoresearch | 69,600+ stars

What it does: Andrej Karpathy’s autonomous AI research framework. Give an AI agent a small LLM training setup, point it at program.md (the instructions), and let it experiment overnight - modifying architecture, training for 5 minutes, evaluating, keeping or discarding changes, repeating. You wake up to a log of experiments and a measurably better model.

Why it matters: This is the concept of “overnight agent factory” made real. It’s not about the specific ML task - it’s a paradigm for autonomous experimentation loops. The agent runs unsupervised, makes decisions, evaluates results, and iterates. The program.md is essentially a skill file that guides the agent’s behavior across hundreds of experiments.

Install:

git clone https://github.com/karpathy/autoresearch
cd autoresearch

# Install uv if you don't have it
curl -LsSf https://astral.sh/uv/install.sh | sh

# Setup
uv sync
uv run prepare.py   # One-time data prep (~2 min)
uv run train.py     # Manual test run (~5 min)

Requires: NVIDIA GPU (tested on H100, community forks exist for macOS/MLX), Python 3.10+.

Usage with Claude Code:

cd autoresearch
# Open Claude Code and say:
"Have a look at program.md and let's kick off a new experiment!"

The agent reads program.md (which describes the experimental protocol), modifies train.py (model architecture, hyperparameters, training loop), trains for a fixed 5-minute budget, evaluates val_bpb, records results, and repeats. Expect ~12 experiments per hour, ~100 overnight.

The broader lesson: Even if you don’t train neural networks, the pattern - agent + program.md + evaluation loop + autonomous iteration - applies to any domain where you can define success metrics: performance optimization, configuration tuning, A/B test generation, even content creation.

---

13. RAG-Anything (HKUDS) - Multimodal RAG That Actually Gets Tables

Repo: HKUDS/RAG-Anything | 15,500+ stars

What it does: An all-in-one multimodal RAG framework built on LightRAG. Unlike traditional RAG that only handles text, RAG-Anything processes text, images, tables, equations, charts, and multimedia in a single unified pipeline. It builds a knowledge graph from all content types and retrieves across modalities.

Why it matters: If you’ve ever tried to RAG over a PDF with tables and gotten garbage back, you know the pain. Traditional RAG pipelines lose tables, misread charts, and ignore images entirely. RAG-Anything preserves the structure of complex documents - academic papers with equations, financial reports with data tables, technical docs with architecture diagrams - and reasons over all of it.

Install:

pip install raganything
# or
uv pip install raganything

Usage:

from raganything import RAGAnything

rag = RAGAnything(working_dir="./my_knowledge_base")

# Ingest a complex document
await rag.insert("quarterly_report.pdf")

# Query with multimodal understanding
result = await rag.query(
    "What was the revenue trend shown in the Q3 chart, "
    "and how does it compare to the projections in Table 4?"
)

Key use cases:

• Academic research papers with equations and figures
• Financial reports with charts, tables, and commentary
• Technical documentation with architecture diagrams
• Any PDF-heavy workflow where text-only RAG isn’t enough

Pro tip: Combine with Firecrawl MCP - crawl a documentation site, pipe the content through RAG-Anything for structured indexing, then query it through Claude. Your own private, multimodal knowledge base from any website.

---

14. MarkItDown (Microsoft) - Any Document to Markdown in One Call

Repo: microsoft/markitdown | 45,000+ stars

What it does: A Python utility and MCP server from Microsoft that converts virtually any document format to clean Markdown - PDF, Word, Excel, PowerPoint, HTML, images (via OCR), audio (via transcription), CSV, JSON, XML, EPUB, and even ZIP archives. It preserves structure: headings, lists, tables, and code blocks come through intact.

Why I love it: This is the universal adapter for getting documents into Claude’s native format. Got a 200-page PDF spec from a client? A competitor’s PowerPoint deck? A spreadsheet of vendor pricing? MarkItDown converts it to structured Markdown that Claude can reason over directly - no copy-paste, no manual reformatting, no lost tables.

It’s especially powerful paired with Obsidian MCP: convert any document to Markdown and drop it straight into your vault as a permanent, searchable note. Research papers, meeting slides, board decks - they all become part of your knowledge base in one step.

Install:

# MCP server for Claude Code
claude mcp add markitdown -- uvx markitdown-mcp

# Or as a standalone CLI
uv tool install markitdown

The MCP server exposes a convert_to_markdown tool that accepts file://, http://, and https:// URIs - so Claude can convert both local files and web pages.

Usage in Claude Code:

Once the MCP is added, Claude gains a convert_to_markdown tool it can call automatically. You just reference a file or URL in your prompt and Claude handles the rest:

You: "Read this spec and summarize the auth requirements"
     [drag-and-drop contract.pdf into the conversation, or reference a path]

Claude: [calls convert_to_markdown with file:///Users/you/Downloads/contract.pdf]
        → receives structured Markdown with headings, tables, and lists intact
        → summarizes the auth section with page references

It also works with URLs - ask Claude to “convert https://example.com/pricing to Markdown” and it fetches and converts the page in one step. For batch operations, Claude can loop over a directory:

You: "Convert every .docx in ./legacy-docs/ to Markdown and save them to ./docs/"

Claude: [calls convert_to_markdown for each file, writes output via standard file tools]

No special syntax needed - the MCP tool is available like any other tool in Claude’s toolkit. Just describe what you want in natural language.

Key workflows:

• “Convert this PDF contract to Markdown and highlight all payment terms”
• “Grab the slide deck from this URL, convert it, and save the key points to my Obsidian vault”
• “Convert all the .docx files in this folder to Markdown for our documentation migration”

Pro tip: Chain it with RAG-Anything - use MarkItDown to convert documents to Markdown for ingestion, then RAG-Anything for multimodal knowledge graph indexing. Together they handle any document format at any scale.

---

15. Codex CLI (OpenAI) - Know Your Alternatives

Repo: openai/codex | 74,200+ stars

What it does: OpenAI’s open-source coding agent - the direct competitor to Claude Code. Runs locally in your terminal, reads your codebase, proposes edits, runs commands in a sandbox, and iterates. Written in Rust. Supports ChatGPT Plus/Pro/Enterprise auth or API keys.

Why it’s on this list: Not because I’ve switched - Claude Code remains my primary agent - but because knowing the landscape makes you better at using any tool. Codex CLI introduced some interesting patterns: fully sandboxed execution by default, a desktop app via codex app, and tight integration with ChatGPT accounts (no separate API key needed).

Install:

npm install -g @openai/codex
# or
brew install --cask codex

When to reach for it:

• When you want a second opinion on a complex refactor (different model, different approach)
• When you’re evaluating OpenAI models against Claude for specific coding tasks
• When a project is already deep in the OpenAI ecosystem

Honest take: The quality gap between Claude Code and Codex CLI depends heavily on the task. For greenfield code generation they’re closer than you’d think. For complex multi-file refactoring with full codebase understanding, Claude Code still has a meaningful edge in my experience. But competition is good - it keeps both tools improving fast.

---

Part 3: Putting It All Together

Use Cases - How I Combine These Tools in My Workflows

Here’s how these tools compose in practice:

Workflow	What I’m Doing	Tools Used
Conceptual work	Specs, planning, architecture brainstorms	Obsidian MCP + XMind MCP + Agent-Skills (/agent-skills:spec, /agent-skills:plan)
Research	Deep-dive on a topic	Firecrawl MCP + NotebookLM MCP + MarkItDown + Obsidian MCP
Development	Feature implementation	Claude Code + Claude Preview + Playwright MCP + GitHub MCP + Agent-Skills
Design	Lift up UI design quality	awesome-design-md + Claude Preview MCP
Presentation	Build a deck from research	Marp + Obsidian MCP
Reviews	PR review, quality gates, shipping	GitHub MCP + Agent-Skills (/agent-skills:review, /agent-skills:ship)

The Installation Cheat Sheet

For the impatient - here’s every MCP server as a one-liner for Claude Code:

# Core productivity
claude mcp add obsidian -- /path/to/vault/.obsidian/plugins/mcp-tools/bin/mcp-server
claude mcp add xmind -- npx -y @41px/mcp-xmind
claude mcp add github -- npx -y @modelcontextprotocol/server-github

# Web & research
claude mcp add firecrawl-mcp -e FIRECRAWL_API_KEY=fc-YOUR_KEY -- npx -y firecrawl-mcp
claude mcp add playwright -- npx @playwright/mcp@latest

# Google ecosystem
claude mcp add google-workspace -- npx -y google-workspace-mcp

# Document conversion
claude mcp add markitdown -- uvx markitdown-mcp

# Presentations
npm install -g @marp-team/marp-cli

# NotebookLM
uv tool install notebooklm-mcp-cli && nlm setup add claude-code

# Agent-Skills plugin (run inside Claude Code session)
# /plugin marketplace add addyosmani/agent-skills
# /plugin install agent-skills@addy-agent-skills

# RAG
pip install raganything

The Meta-Lesson

The real power of MCPs and skills isn’t any individual tool - it’s the composition. Each MCP gives Claude access to one more system. Each skill teaches it one more workflow. Combined, they create an agent that doesn’t just write code - it researches, plans, builds, documents, presents, and communicates across every tool in your stack.

The bar I hold every tool to is simple: if I uninstalled it tomorrow, would I notice within a week? Everything in this article passes that test.

---

Have an MCP or skill I should be trying? Tell me on LinkedIn - I’m always looking for the next one that earns a permanent spot.