Bike MCP Server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Bike MCP Server list my open Bike documents and show me the outline of the first one"
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.
Bike MCP Server
MCP (Model Context Protocol) server for Bike outliner app on macOS.
Features
Reading
bike_list_documents- List all open documentsbike_get_document_outline- Read document structure (supports max_depth)bike_query_rows- Search rows using Bike's outline path syntax
Writing
bike_create_document- Create new documents with optional structurebike_create_rows- Add rows with nested children and positioningbike_update_row- Edit row content and type (batch support)bike_delete_row- Remove rows (batch support)bike_group_rows- Group/move multiple rows under a parent
Related MCP server: MCP Mac Apps Server
Requirements
macOS (uses AppleScript)
Node.js 18+
Bike app installed
Installation
Via Desktop Extension (recommended)
Download
bike-mcp-server.mcpbfrom releasesDouble-click the file to open with Claude Desktop
Click Install
From source
cd bike-mcp-server
npm install
npm run buildUsage with Claude Desktop
Add to your Claude Desktop config file (~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"bike": {
"command": "node",
"args": ["/path/to/bike-mcp-server/dist/index.js"]
}
}
}Then restart Claude Desktop.
Development
# Watch mode for development
npm run dev
# Build
npm run build
# Run directly
npm startHow It Works
The server communicates with Bike via AppleScript, using the osascript command. All operations require Bike to be running with a document open.
The outline structure is returned as human-readable indented text:
My Document (doc:abc123)
- First item [row:row-1]
- Sub-item [row:row-1-1]
- Second item [row:row-2]Example Prompts
Here are some prompts you can use with Claude Desktop:
Explore your outlines: "List my open Bike documents and show me the outline of the first one"
Create structured content: "Create a new Bike document with a project plan that has 3 main phases, each with 2-3 tasks"
Search and transform: "Find all rows containing 'TODO' in my Bike document and convert them to task items"
Testing
No account or authentication required. To test the server:
Open Bike app on macOS
Create or open a document with some sample content
Use Claude Desktop to interact with your outlines
Privacy
This server does not collect, store, or transmit any personal data. All communication happens locally between Claude Desktop and the Bike app via AppleScript. No data leaves your machine.
Support
License
MIT
Available Tools
8 toolsbike_create_documentCreate Bike DocumentA
Creates a new document in Bike, optionally with an outline structure.
Args:
structure (array, optional): Outline structure to populate the document. Each node can have:
name (string): Text content (may contain HTML if html=true)
type (string, optional): Row type (body, heading, task, code, quote, note, unordered, ordered, hr)
children (array, optional): Nested child nodes If not provided, creates an empty document.
html (boolean, optional): If true, name fields may contain HTML formatting: , , , , ,
Returns: Document info: "Untitled (doc:XXX)"
Examples:
Empty doc: bike_create_document({})
With structure: bike_create_document({ structure: [ { name: "Project", type: "heading", children: [ { name: "Task 1", type: "task" }, { name: "Task 2", type: "task" } ]} ] })
With HTML: bike_create_document({ structure: [{ name: "Click <a href="https://example.com">here" }], html: true })
Errors:
"Bike is not running" - Open Bike app first
Inputs: html, structure.
bike_create_rowsCreate Bike RowsA
Creates one or more rows with optional nested structure.
Args:
structure (array, required): Array of rows to create. Each can have:
name (string): Text content (may contain HTML if html=true)
type (string, optional): Row type (body, heading, task, code, quote, note, unordered, ordered, hr)
children (array, optional): Nested child rows
parent_id (string, optional): Parent row ID. If not provided, adds to root.
position (string, optional): Where to insert - 'first', 'last' (default), 'before', 'after'
reference_id (string, optional): Required for 'before'/'after' positioning.
html (boolean, optional): If true, name fields may contain HTML formatting: , , , , ,
Returns: Confirmation: "Created N row(s)"
Examples:
Single row: bike_create_rows({ structure: [{ name: "New item" }] })
With type: bike_create_rows({ structure: [{ name: "Task", type: "task" }] })
Nested: bike_create_rows({ structure: [ { name: "Parent", children: [{ name: "Child" }] } ] })
At position: bike_create_rows({ structure: [{ name: "First!" }], position: "first" })
Before row: bike_create_rows({ structure: [{ name: "Before X" }], position: "before", reference_id: "Kx9" })
With HTML: bike_create_rows({ structure: [{ name: "Click <a href="https://example.com">here" }], html: true })
Errors:
"Bike is not running" - Open Bike app first
"No document is open" - Open a document first
"reference_id is required" - When using before/after without reference_id
Inputs: structure (required), html, position, parent_id, +1 more.
bike_delete_rowDelete Bike RowsADestructive
Deletes one or more rows from the document.
WARNING: This is a destructive operation. Deleted rows and all their children will be permanently removed. This action cannot be undone via the MCP server (though Bike's undo may work if used immediately).
Args:
row_ids (string[], required): Array of row IDs to delete.
Returns: Confirmation with count: "Deleted 3 row(s)"
Examples:
Delete one row: bike_delete_row({ row_ids: ["Kx9"] })
Delete multiple: bike_delete_row({ row_ids: ["Kx9", "Lm2", "Np4"] })
Errors:
"Bike is not running" - Open Bike app first
"No document is open" - Open a document first
Inputs: row_ids (required).
bike_get_document_outlineGet Bike Document OutlineARead-onlyIdempotent
Retrieves the complete outline structure of the currently open Bike document.
Returns a hierarchical tree of rows with their IDs, text content, and children. Bike must be running with a document open for this tool to work.
Args:
max_depth (number, optional): Maximum depth of the outline tree to return. If not specified, returns the complete tree.
Returns: Human-readable indented outline with IDs:
Document Name (doc:root-id)
First item [row:Kx9]
Sub-item 1 [row:Lm2]
Sub-item 2 [row:Np4]
Second item [row:Qr7]
Examples:
Get full outline: bike_get_document_outline({})
Get only 2 levels deep: bike_get_document_outline({ max_depth: 2 })
Errors:
"Bike is not running" - Open Bike app first
"No document is open" - Open a document in Bike first
Inputs: max_depth.
bike_group_rowsGroup RowsA
Groups multiple rows under a new or existing parent row.
Two modes:
Create new group: Provide group_name to create a new parent row and move specified rows into it. By default, the group is created in-place (before the first row being grouped).
Move to existing: Provide parent_id to move rows into an existing row.
Use position ('first'/'last' for root, 'before'/'after' with reference_id) to override placement.
Inputs: row_ids (required), position, parent_id, group_name, +1 more.
bike_list_documentsList Bike DocumentsARead-onlyIdempotent
Lists all open documents in Bike.
Returns a list of all currently open documents with their names and IDs. The active (front) document is marked with an asterisk (*). Bike must be running for this tool to work.
Args: None
Returns: List of documents, one per line (active marked with *):
Active Document (doc:abc123) Other Document (doc:def456)
Examples:
List all open docs: bike_list_documents({})
Errors:
"Bike is not running" - Open Bike app first
"No documents open" - No documents are currently open
Inputs: no named parameters.
bike_query_rowsQuery Bike RowsARead-onlyIdempotent
Search for rows using Bike's outline path syntax.
Outline paths are powerful queries for filtering rows:
/project → Top-level rows containing "project"
//task → All rows of type "task" (anywhere)
//@done → Rows with @done attribute
//heading → All heading rows
/a/b → "b" rows inside "a" rows
/a union /b → Rows matching "a" OR "b"
/a intersect /b → Rows matching "a" AND "b"
Args:
outline_path (string, required): The outline path query.
Returns: Matching rows formatted as:
Row text [row:XXX]
Or scalar result (count, boolean, text) depending on the query.
Examples:
Find all tasks: bike_query_rows({ outline_path: "//task" })
Find headings: bike_query_rows({ outline_path: "//heading" })
Find by text: bike_query_rows({ outline_path: "//project" })
Find with attribute: bike_query_rows({ outline_path: "//@done" })
Errors:
"Bike is not running" - Open Bike app first
"No document is open" - Open a document first
Inputs: outline_path (required).
bike_update_rowUpdate Bike RowsAIdempotent
Updates one or more rows' text content and/or type.
Args:
updates (array, required): Array of row updates. Each update has:
row_id (string, required): ID of the row to update
name (string, optional): New text content (may contain HTML if html=true)
type (string, optional): New row type (body, heading, quote, code, note, unordered, ordered, task, hr)
html (boolean, optional): If true, name contains HTML formatting: , , , , , NOTE: HTML updates recreate the row, so the row ID will change. Children are preserved. If you need the new ID, call bike_get_document_outline after.
Returns: Confirmation: "Updated N row(s)"
Examples:
Single update: bike_update_row({ updates: [{ row_id: "Kx9", name: "New text" }] })
Batch to task: bike_update_row({ updates: [ { row_id: "A1", type: "task" }, { row_id: "B2", type: "task" }, { row_id: "C3", type: "task" } ] })
Mixed: bike_update_row({ updates: [ { row_id: "X", name: "Title", type: "heading" }, { row_id: "Y", type: "task" } ] })
With HTML: bike_update_row({ updates: [ { row_id: "Z", name: "Important task", html: true } ] })
Errors:
"Bike is not running" - Open Bike app first
"No document is open" - Open a document first
"At least one of 'name' or 'type' must be provided" - Per row
Inputs: updates (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 8 tools
Each tool targets a distinct operation: listing documents, retrieving outlines, creating documents, creating rows, grouping rows, updating rows, deleting rows, and querying. Even though create_document and create_rows both create structure, they operate at different levels (document vs. rows within a document), avoiding ambiguity.
All tools follow the pattern 'bike_<verb>_<noun>' using imperative verbs (list, get, create, group, update, delete, query). The naming is uniform and predictable, with only minor plural/singular variation that does not hinder understanding.
With 8 tools, the server is well-scoped for a focused outlining application. Each tool addresses a core functionality without unnecessary bloat, and the count feels natural for the domain.
The tool set covers essential CRUD operations for rows (create, read via outline/query, update, delete) and document lifecycle (create, list). Missing operations like explicit row reordering or document closing are minor and can be worked around via existing tools, making the surface largely complete.
Maintenance
Related MCP Connectors
Streamline your Attio workflows using natural language to search, create, update, and organize com…
Use your Mac, Windows or Linux computer from ChatGPT, Claude or Codex: files, commands, documents.
Manage Superlist tasks and lists in plain language from any MCP-compatible AI agent.
Lets Claude, ChatGPT, and Muse read and update your beckett tasks, notes, calendar, and lists.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables AI agents to interact with macOS applications (Finder, Mail, Contacts, Reminders, Notes, Calendar, TextEdit) using AppleScript. Allows AI assistants to perform tasks like searching contacts, managing files, checking email, and creating reminders through natural language.241MIT
- AlicenseCqualityDmaintenanceEnables control of macOS applications through natural language, allowing users to launch apps, execute AppleScript commands, manage running applications, and open files with voice or text commands.15MIT
- AlicenseAqualityBmaintenanceEnables AI assistants to read and write to OmniFocus database, allowing natural language task management, project creation, and GTD workflows.41MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to create and manipulate Microsoft Office documents (PowerPoint, Word, Excel) on macOS via AppleScript automation.MIT