Drafts MCP Server: Why Developers Are Ditching Manual Note-Taking

Drafts MCP Server: Why Developers Are Ditching Manual Note-Taking

What if your AI assistant could read your mind—or at least your notes—without you lifting a finger? Imagine never again copying meeting minutes between apps, losing track of action items, or manually tagging hundreds of drafts. For macOS developers and power users, this isn't science fiction. It's happening right now, and most people haven't even noticed the revolution quietly unfolding on their desktops.

The painful truth? We've accepted friction as normal. We toggle between Drafts, email, project management tools, and AI chat interfaces like digital janitors, sweeping information from one room to another. But what if your AI could live inside your note-taking workflow? What if Claude, Cursor, or any MCP-compatible assistant could create, search, modify, and act upon your Drafts content as naturally as you breathe?

Enter Drafts MCP Server—the bridge between your brain's external storage and the AI assistants designed to augment it. Built by Greg Pierce of Agile Tortoise (the same mind behind the legendary Drafts app), this Model Context Protocol server transforms passive note repositories into dynamic, AI-manipulable data stores. No more manual drudgery. No more context switching. Just pure, automated information flow.

In this deep dive, I'll expose exactly how this tool works, why it's secretly becoming essential for serious macOS automation enthusiasts, and how you can deploy it in minutes. Whether you're a developer seeking CLI nirvana or an AI power user hungry for deeper integration, this guide will rewire how you think about note-taking forever.

What Is Drafts MCP Server?

Drafts MCP Server is a Model Context Protocol (MCP) implementation that exposes the full power of the Drafts macOS app to AI assistants through AppleScript. Created by Greg Pierce under the Agile Tortoise banner, it represents a critical evolution in how knowledge workers interact with their information repositories.

For the uninitiated, MCP is an open protocol standardized by Anthropic that enables AI systems to securely connect with external data sources and tools. Think of it as USB-C for AI integrations—universal, bidirectional, and transformative. The Drafts MCP Server leverages this protocol to give Claude, Cursor, and other MCP-compatible assistants direct, programmatic access to your Drafts content.

Why is this trending now? Three converging forces: the explosive adoption of Claude Desktop and similar AI-native applications, the standardization of MCP as the de facto integration layer, and Drafts' longstanding dominance as the "where text starts" for serious macOS users. Pierce's timing is surgical—he's connected a mature, beloved app to the emerging AI infrastructure precisely when power users are desperate for deeper automation.

The repository itself is lean but potent: TypeScript-based, npm-distributed, and architecturally clean with separation between the MCP server implementation (index.ts), standalone CLI (cli.ts), Drafts-specific operations (drafts.ts), and AppleScript execution utilities (applescript.ts). This isn't hobbyist code—it's production-ready infrastructure from a developer who understands both the Drafts ecosystem and modern AI integration patterns.

Critically, this is macOS-only—AppleScript is the bridge, and AppleScript lives exclusively in Apple's garden. But for the millions of developers, writers, and knowledge workers who've made Drafts their digital home base, this constraint is irrelevant. The platform they already use just gained superpowers.

Key Features That Justify the Hype

Let's dissect what makes this tool genuinely transformative, not merely convenient.

📝 Complete Draft Lifecycle Management

The server exposes full CRUD operations: create drafts with specified content and tags, read specific drafts by UUID, update existing content, and search across your entire corpus with full-text queries. But it goes deeper—filter by folder (inbox, archive, trash), tag combinations, flagged status, creation dates, and modification windows. This isn't surface-level API access; it's surgical precision over your information architecture.

🏷️ Intelligent Tag Orchestration

Tags in Drafts aren't just labels—they're workflow triggers, organizational schemas, and automation hooks. The MCP server lets AI assistants add tags programmatically, enabling dynamic categorization. Imagine Claude analyzing a draft's content, auto-tagging it with project identifiers, priority levels, or context markers, then triggering Drafts actions based on those tags. The semantic layer becomes executable.

📂 Workspace-Aware Operations

Drafts workspaces are filtered views that power sophisticated information partitioning. The server can list all workspaces, identify the current workspace, open specific workspaces, and retrieve drafts constrained to workspace boundaries. For users with complex setups—separate workspaces for work projects, personal journaling, creative writing, and reference material—this means AI assistants respect your organizational boundaries automatically.

⚡ Programmatic Action Execution

Here's where it gets genuinely exciting. Drafts actions are automation scripts that transform, transmit, or process text. The MCP server can list all available actions and execute any action on any draft. Your AI assistant doesn't just manage content—it triggers entire workflows: sending formatted emails, creating calendar events, posting to APIs, generating PDFs, or executing custom JavaScript^{↗ Bright Coding Blog} transformations.

🔍 Full-Text Search with Context

The search implementation isn't naive string matching—it leverages Drafts' native search capabilities across all workspaces. Combined with the ability to retrieve surrounding context, AI assistants can perform sophisticated information retrieval: "Find all meeting notes from Q1 that mention budget concerns but don't have the 'resolved' tag."

🚩 Status Manipulation

Flag, archive, trash, restore to inbox—these status operations enable workflow state management. An AI assistant can implement entire processing pipelines: flag items requiring review, archive completed work, trash obsolete drafts, all based on content analysis and business rules you define.

🖥️ Dual Interface: MCP Server + Standalone CLI

The package includes both the MCP server for AI integration AND a standalone drafts command-line tool. This dual personality means you get automation through natural language AI interaction AND traditional scripting. The CLI outputs human-readable text by default or JSON with --json for programmatic consumption.

Use Cases That Will Reshape Your Workflow

1. The Autonomous Meeting Pipeline

You finish a video call. Instead of manually processing notes, you tell Claude: "Find my latest meeting notes draft, extract action items, create individual todo drafts tagged by owner and deadline, and run the 'Send Summary' action on the original." The Drafts MCP Server executes this entire chain—search, parse, create, tag, act—while you grab coffee.

2. The Living Weekly Review

Every Friday, your AI assistant performs a structured review: retrieves all drafts from your 'Daily Notes' workspace created in the last 7 days, analyzes content for themes and accomplishments, generates a synthesized 'weekly-review' draft with tagged insights, and archives the processed originals. What took 45 minutes of manual curation becomes a single sentence request.

3. The Context-Aware Writing Assistant

You're drafting a technical proposal. You ask Cursor: "Search my knowledge base for all drafts about authentication patterns, summarize the approaches we've used, and insert relevant excerpts as reference material." The MCP server searches across your entire Drafts corpus, respects workspace boundaries, and returns structured content your AI can weave into your current document.

4. The Inbox Zero Automation

Your Drafts inbox accumulates capture throughout the day. Each evening, Claude processes everything: flags items containing question marks for tomorrow's priority review, archives drafts with 'completed' or 'done' in content, tags reference material by detected topic, and runs appropriate actions on actionable items. You wake to an organized, pre-processed information environment.

5. The Cross-Platform Bridge

Drafts excels at capture, but your team uses Notion, your blog uses Markdown^{↗ Smart Converter} files, your newsletter uses a custom CMS. Using the MCP server's action execution, you create Drafts actions that export to each platform, then instruct your AI: "Find all drafts tagged 'publish-ready', run the appropriate export action for each tag subtype, and archive the originals." Your capture tool becomes your publishing orchestration hub.

Step-by-Step Installation & Setup Guide

Prerequisites

Before installation, confirm your environment:

• macOS (AppleScript dependency—no Windows/Linux support)
• Drafts app v50.0.3 or greater installed and launched at least once
• Node.js 18+ (install via Homebrew if needed)

# Verify Node.js version
node --version

# Install Node via Homebrew if needed
brew install node

Method 1: Zero-Install with npx (Recommended)

The fastest path—no global installation required:

npx @agiletortoise/drafts-mcp-server

This downloads and executes the latest version on demand. Perfect for trying before committing, or for minimal system footprint.

Method 2: Global npm Installation

For frequent use and CLI availability:

npm install -g @agiletortoise/drafts-mcp-server

After global installation, both the MCP server and drafts CLI command are available system-wide.

Method 3: Local Development Build

For contributors, customizers, or those wanting bleeding-edge features:

# Clone the repository
git clone https://github.com/agiletortoise/drafts-mcp-server.git
cd drafts-mcp-server

# Install dependencies and build
npm install
npm run build

# Link for global CLI access during development
npm link

# Or test directly
node dist/index.js

Claude Desktop Configuration (Easiest Path)

The project provides a pre-built .mcpb extension file for drag-and-drop installation:

1. Download drafts-mcp-server.mcpb to your Mac
2. Open Claude Desktop
3. Navigate to Settings > Extensions
4. Drag the .mcpb file from Finder into the Extensions window
5. Follow installation prompts

Claude Desktop Manual Configuration

For npx-based execution, edit ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "drafts": {
      "command": "npx",
      "args": ["@agiletortoise/drafts-mcp-server"]
    }
  }
}

For local development, use absolute paths:

{
  "mcpServers": {
    "drafts": {
      "command": "node",
      "args": ["/absolute/path/to/drafts-mcp-server/dist/index.js"]
    }
  }
}

For globally installed:

{
  "mcpServers": {
    "drafts": {
      "command": "drafts-mcp-server"
    }
  }
}

Cursor Configuration

Add to your Cursor MCP settings (project .cursor/mcp.json or global settings):

{
  "mcpServers": {
    "drafts": {
      "command": "npx",
      "args": ["@agiletortoise/drafts-mcp-server"]
    }
  }
}

Claude Code Configuration

Using the CLI tool:

# Production usage
claude mcp add drafts -- npx @agiletortoise/drafts-mcp-server

# Local development
claude mcp add drafts -- node /absolute/path/to/drafts-mcp-server/dist/index.js

Restart Claude Code or start a new session after adding.

Critical: Permission Setup

First run triggers macOS automation permissions:

1. Open System Preferences > Security & Privacy > Privacy > Automation
2. Allow your MCP host (Claude Desktop, Cursor, etc.) to control Drafts
3. Restart the MCP client after granting permissions

Verify AppleScript connectivity manually if issues arise:

osascript -e 'tell application "Drafts" to get name of first workspace'

REAL Code Examples from the Repository

Let's examine actual implementation patterns from the Drafts MCP Server codebase, with detailed explanations of how each operates.

Example 1: CLI Workspace Operations

The standalone CLI provides immediate terminal access to Drafts functionality. Here's how workspace interaction works:

# List all configured workspaces—useful for discovery and scripting
drafts workspace list

# Identify which workspace is currently active in the UI
drafts workspace current

# Programmatically switch the UI to a specific workspace
drafts workspace open "Work"

# Retrieve drafts from a workspace, optionally filtered by folder
drafts workspace drafts "Work" --folder inbox

What's happening here? The CLI parses these commands and translates them into AppleScript executions against the Drafts application. The workspace list command enumerates all workspace objects, extracting their names. workspace current queries the active document's workspace context. workspace open triggers UI manipulation—actually changing what the user sees. The drafts subcommand with --folder applies additional filtering on the returned draft collection. This pattern demonstrates how the CLI serves as both interactive tool and scriptable interface.

Example 2: Advanced Draft Filtering with CLI

The list command supports sophisticated filtering that mirrors the MCP server's capabilities:

# Basic listing with multiple filter dimensions
drafts list --folder inbox --tag work --flagged

# Date-range filtering for temporal queries
drafts list --created-after 2025-01-01 --modified-before 2025-06-30

# Full-text search across all drafts
drafts search "meeting notes"

Deep dive: These commands construct compound predicates. The first example combines folder scope (inbox only), tag membership (must have 'work'), and flagged status (true). The date filters parse ISO-8601 strings and compare against Drafts' internal creation and modification timestamps. The search command leverages Drafts' native full-text index, which handles stemming and relevance ranking. Adding --json to any command transforms output from human-readable tables to machine-parseable structures—critical for piping into jq or other tools.

Example 3: Draft Lifecycle Management via CLI

Complete CRUD operations through the terminal:

# Retrieve the currently selected draft in the UI
drafts current

# Fetch specific draft by UUID—foundational for scripting
drafts get <uuid>

# Create with content, multiple tags, and flagged status
drafts create "Hello world" --tag notes --tag ideas --flagged

# In-place content update
drafts update <uuid> "Updated content"

# UI navigation—open specific draft for manual editing
drafts open <uuid>

Technical explanation: UUID-based operations (get, update, open) use Drafts' persistent identifiers, ensuring script reliability across sessions. The create command demonstrates variadic tag handling—--tag can repeat arbitrarily. The --flagged boolean flag is a toggle parameter. These commands map directly to AppleScript make, set, and get operations, with the CLI handling type coercion and error translation.

Example 4: MCP Server Configuration for Claude Desktop

The JSON configuration that enables AI integration:

{
  "mcpServers": {
    "drafts": {
      "command": "npx",
      "args": ["@agiletortoise/drafts-mcp-server"]
    }
  }
}

Architecture insight: This configuration tells Claude Desktop to launch the MCP server as a subprocess, communicating via stdio using the Model Context Protocol. The npx command ensures automatic version management—Claude will fetch the latest compatible version on each launch. The server exposes its tools (draft operations, search, actions) through JSON-RPC, which Claude translates into function calls it can invoke based on your natural language requests. This is the magic layer: your words become structured API calls to Drafts.

Example 5: Programmatic Action Execution

The most powerful feature—triggering Drafts' automation engine:

# Discover available actions
drafts action list

# Execute named action on specific draft
drafts action run <draft-uuid> "Send to Email"

Power user analysis: Actions in Drafts are JavaScript-based transformations with access to app context, external APIs, and system services. By exposing action execution, the MCP server lets AI assistants trigger arbitrary automation—not just content manipulation, but entire cross-application workflows. The action list command enumerates installed actions by name; action run locates the action by exact name match and executes it with the specified draft as context. This is where Drafts' mature automation ecosystem meets modern AI capabilities.

Advanced Usage & Best Practices

Compose Complex Workflows with Natural Language

The real power emerges in multi-step operations. Instead of individual commands, craft prompts that leverage multiple tools:

"Find all drafts in my 'Projects' workspace created this month without the 'reviewed' tag, flag them, add the 'needs-review' tag, and run my 'Generate Summary' action on each."

This single instruction triggers: workspace-scoped search, date filtering, negative tag filtering, batch flagging, batch tagging, and iterated action execution. The AI handles the orchestration; you focus on intent.

Leverage JSON Output for Pipeline Integration

For shell scripting and CI/CD integration, always append --json:

# Extract UUIDs of all flagged inbox items for external processing
drafts --json list --folder inbox --flagged | jq '.[].uuid'

Build Semantic Tagging Systems

Design tag schemas that AI assistants can maintain automatically. Consider: status-* (status-pending, status-blocked), project-* (project-alpha, project-beta), type-* (type-meeting, type-reference). This predictability enables reliable AI-driven organization.

Version Control Your Configuration

Store your Claude Desktop and Cursor MCP configurations in dotfiles repositories. This ensures consistent setup across machines and enables team sharing of automation patterns.

Monitor AppleScript Performance

Complex batch operations through AppleScript can block. For large-scale migrations, process in chunks and add progress logging. The MCP Inspector (npm run inspector) is invaluable for debugging tool execution timing.

Comparison with Alternatives

Why choose Drafts MCP Server? It uniquely combines Drafts' mature text processing ecosystem with modern AI interfaces. Manual AppleScript offers equivalent power but requires programming expertise and can't be invoked conversationally. Shortcuts provides visual automation but lacks AI reasoning and cross-context awareness. Direct Drafts actions are powerful but isolated—only the MCP server bridges them into collaborative AI workflows.

For developers already using Claude, Cursor, or similar tools, this integration eliminates an entire category of context-switching friction. The question isn't whether you can achieve similar results elsewhere—it's whether you want to maintain fragile custom scripts when a standardized protocol handles the complexity.

FAQ

Q: Is Drafts MCP Server free to use?

Yes, the server is MIT-licensed and free. You'll need the Drafts app (free with Pro subscription for advanced features) and a compatible AI assistant.

Q: Can I use this on Windows or Linux?

No. AppleScript is macOS-exclusive, and Drafts is a Mac/iOS app. This is fundamentally a macOS-only solution.

Q: Do I need coding experience to benefit?

Basic installation requires none—just configuration file editing. Advanced usage benefits from familiarity with command-line tools, but natural language AI interaction removes most technical barriers.

Q: How does this compare to Drafts' built-in automation?

Drafts' native actions and URL schemes remain powerful. The MCP server extends this by enabling external AI systems to participate in your automation, not by replacing existing mechanisms.

Q: Is my draft content sent to external servers?

No. The MCP server runs locally on your Mac, communicating with Drafts via AppleScript. Content flows between local applications only—never to the MCP protocol infrastructure or AI model training.

Q: What happens if Drafts isn't running?

AppleScript will attempt to launch Drafts automatically. For best performance, keep Drafts running, especially for batch operations.

Q: Can I contribute to development?

Absolutely. The repository welcomes pull requests. Key contribution areas: additional MCP tools, enhanced error handling, Windows compatibility research (though AppleScript dependency makes this challenging), and documentation improvements.

Conclusion

The Drafts MCP Server represents something rare: a tool that doesn't just add features but fundamentally reimagines how we interact with our information. By embedding AI assistants directly into the note-taking workflows millions already depend upon, Greg Pierce has created a force multiplier for knowledge work.

I've seen countless "integrations" that amount to thin API wrappers. This isn't one of them. The depth of Drafts' AppleScript dictionary, combined with MCP's standardized AI interface, produces genuine capability multiplication. Your AI assistant doesn't just access your notes—it participates in your organizational system, respects your workspace boundaries, triggers your automation workflows, and learns your semantic patterns.

For macOS developers and power users, the question is no longer whether AI integration matters, but whether you'll adopt the open protocols that make it portable and powerful. The Drafts MCP Server is a masterclass in doing exactly that.

Ready to transform your note-taking? Install the Drafts MCP Server today, configure it for your AI assistant of choice, and experience what happens when your second brain gains its own intelligence. Your future self—reviewing automatically synthesized weekly summaries while your AI archives processed drafts—will thank you.

Found this guide valuable? Star the repository on GitHub, share your automation workflows in the Drafts forum, and subscribe for deeper dives into AI-powered developer tooling.