Productive Simple MCP
This MCP server provides read-only access to Productive.io data for AI workflows, with LLM-optimized output that reduces token consumption by 30-60%.
Project Management: Retrieve all active projects with budgets, hourly rates, deadlines, team assignments, and client information
Task Operations: List tasks with advanced filtering (by project, user, status, custom API filters), pagination, and sorting; get detailed task information including time tracking metrics (estimated, worked, billable, remaining time); access full task history with status changes, assignment history, milestones, and activity summaries
Comments & Discussions: Retrieve comments across projects and tasks with filtering and pagination; get specific comment details with full context, discussion threads, and mentions
Todo Checklists: Access todo checklist items with filtering by task; get detailed todo information with completion status and task context
Content Access: Retrieve pages/documents with filtering by project or creator and pagination; get specific pages by ID; access attachments/files
Activity Monitoring: Get summarized activity feeds filterable by time range, user, project, activity type, event type, and task ID
Comprehensive Search: Perform quick searches across projects, tasks, pages, and actions with customizable search types, deep search options, and pagination
LLM-Optimized Output: All responses use TOON format with HTML stripped, empty values removed, noise filtered, and direct web app URLs included for each resource
Security: Secure API token handling via environment variables with HTTPS and comprehensive error management for authentication, rate limiting, and API issues
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., "@Productive Simple MCP get tasks for project 12345"
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.
Productive.io MCP Server
A Model Context Protocol (MCP) server for integrating Productive.io into AI workflows. This server allows AI assistants and tools to access projects, folders, workflow statuses, time entries, tasks, comments, pages, attachments, todos, and people. Built with FastMCP.
This implementation is optimized for read-focused operations, with optional guarded write capabilities (for example, task creation) and LLM-friendly output options (Hybrid, JSON, and TOON). It is optimized for efficiency and simplicity, exposing only the necessary information. For a more comprehensive solution, consider BerwickGeek's implementation: Productive MCP by BerwickGeek.
Features
Read tools for projects, folders, workflow statuses, time entries, tasks, comments, pages, attachments, todos, people, recent activity, and quick search
Write tools (blocked when
READ_ONLY=true): create/update/delete for tasks, comments, time entries, pages, and todos, plus page content appendLLM-optimized responses: noise removed, HTML stripped,
webapp_urlincluded for direct accessOutput formats:
hybrid(default),toon, andjson
Related MCP server: MCP Todoist
Requirements
Python 3.10+
Productive API token
FastMCP 3.x
Installation
Clone or download this repository
Install dependencies:
pip install -r requirements.txtor
uv venv && uv syncConfiguration
The server uses environment variables for configuration:
PRODUCTIVE_API_KEY: Your Productive API token (required)PRODUCTIVE_ORGANIZATION: Your Productive organization ID (required)PRODUCTIVE_BASE_URL: Base URL for Productive API (default: https://api.productive.io/api/v2)PRODUCTIVE_TIMEOUT: Request timeout in seconds (default: 30)PRODUCTIVE_ITEMS_PER_PAGE: Default page size for list tools (default: 50, max: 200)OUTPUT_FORMAT: Output format for tool responses ("hybrid","toon", or"json", default:"hybrid")READ_ONLY: Global write-protection toggle for write tools — create_task, update_task, delete_task, create_comment, update_comment, delete_comment, create_time_entry, update_time_entry, delete_time_entry, create_page, update_page, append_page_content, delete_page, create_todo, update_todo, delete_todo ("true" or "false", default: "true")
Usage
Using uvx from GitHub (Recommended for MCP clients)
"productive": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/druellan/Productive-Simple-MCP",
"productive-mcp"
],
"env": {
"PRODUCTIVE_API_KEY": "<api-key>",
"PRODUCTIVE_ORGANIZATION": "<organization-id>"
}
}Local Development (Direct Python Execution)
"productive": {
"command": "python",
"args": [
"server.py"
],
"env": {
"PRODUCTIVE_API_KEY": "<api-key>",
"PRODUCTIVE_ORGANIZATION": "<organization-id>"
}
}Local Development Using UV
"productive": {
"command": "uv",
"args": [
"--directory", "<path-to-productive-mcp>",
"run", "server.py"
],
"env": {
"PRODUCTIVE_API_KEY": "<api-key>",
"PRODUCTIVE_ORGANIZATION": "<organization-id>"
}
}Available Tools
MCP clients receive the full schema and descriptions for each tool automatically. The tables below summarize them.
Read Tools
Tool | Description |
| List all projects |
| List folders in a project ( |
| Get a folder by ID |
| List workflow statuses, optionally filtered by workflow/category |
| List time entries with date/person/project/task/service filters |
| List tasks with filtering, sorting, and pagination |
| Get a task by ID, enriched with recent comments, todos, and attachments |
| Get task status/assignment history, milestones, and activity summary |
| List comments, optionally filtered by project/task |
| List pages/documents, optionally filtered by project/creator |
| Get a page by ID with readable |
| List attachment metadata |
| List todo checklist items, optionally filtered by task |
| Get a todo by ID |
| List team members |
| Get a person by ID |
| Summarized feed of recent activities |
| Search across projects, tasks, pages, and actions |
Write Tools (blocked when READ_ONLY=true)
Tool | Description |
| Manage tasks |
| Manage comments |
| Manage time entries |
| Manage pages/documents |
| Append markdown or HTML to a page |
| Manage todo checklist items |
Output Format
The server supports three output formats configured via the OUTPUT_FORMAT environment variable:
Mode |
|
| Description |
| TOON | JSON dict | Both TOON for token efficiency and structured data for programmatic access |
| TOON |
| Pure TOON (Token-Optimized Object Notation) with no dual-format overhead |
| JSON string | JSON dict | Standard FastMCP JSON output |
TOON (Token-Optimized Object Notation) reduces token consumption by 30-60% compared to JSON. The hybrid mode is the recommended default: it exposes the TOON rendering as the message text while preserving the full JSON dict as structured output, so agents that rely on structured data can still parse it programmatically.
All tools return filtered data optimized for LLM processing:
LLM Optimizations:
Unwanted fields removed (e.g.,
creation_method_id,email_key,placementfrom tasks)HTML stripped from descriptions and comments
Empty/null values removed
Pagination links removed
List views use lightweight output (e.g.,
list_tasksexcludes descriptions and relationships)Web app URLs included: Each resource includes a
webapp_urlfield linking directly to the Productive web interface
Response Structure:
data: Main resource data (array for collections, object for single items)meta: Pagination and metadataincluded: Related resource data (when applicable)webapp_url: Direct link to view the resource in Productive (e.g.,https://app.productive.io/12345/tasks/67890)
Error Handling
The server provides comprehensive error handling:
401 Unauthorized: Invalid API token
404 Not Found: Resource not found
429 Rate Limited: Too many requests
500 Server Error: Productive API issues
All errors are logged via MCP context with appropriate severity levels.
Security
API tokens are loaded from environment variables
No sensitive data is logged
HTTPS is used for all API requests
Error messages don't expose internal details
License
MIT License.
Available Tools
18 toolsget_folderARead-only
Get folder details by folder ID.
Productive exposes folders through the /folders endpoint.
Inputs: folder_id (required). Returns: object
get_pageARead-only
Get a specific page/document by ID, including full content body.
Use this when: You need the full content body of a specific page (not just metadata or titles).
Returns the page body as readable HTML in body_html.
Inputs: page_id (required). Returns: object
get_personARead-only
Get detailed information about a specific team member by ID.
Use this when: You need detailed information about a specific person (full name, email, role, title, activity timestamps, custom fields, avatar). Use list_people when you need to browse or search multiple people.
Returns:
Full name, email, and contact information
Role, title, and organizational details
Activity timestamps (joined, last seen)
Custom fields and additional metadata
Avatar and profile information
Inputs: person_id (required). Returns: object
get_taskARead-only
Get detailed task information by its internal task ID (e.g., 14677418).
Returns task details including:
Title, description, status (open/closed), due date, and timestamps
Time tracking: initial estimate, remaining, billable, and worked time (in minutes)
Todo counts: total and open
comments: the most recent comments (up to
comment_limit, most recent first)todos: up to 100 checklist items, with
todos_truncatedandtodos_notewhen more existattachments: id and filename for each file attached to the task
Inputs: task_id (required), comment_limit. Returns: object
get_task_historyARead-only
Get comprehensive history for a specific task.
Returns aggregated task history including:
Status history: Timeline of status changes with timestamps and responsible users
Assignment history: Who worked on the task and when assignments changed
Milestones: Key deliverables and completion markers from comments and activities
Activity summary: Counts of comments, changes, status updates, assignments, and milestones
Examples: get_task_history(14677921) # Default 30-day history get_task_history(14677921, hours=168) # Last week only get_task_history(14677921, hours=24) # Last 24 hours
Inputs: task_id (required), hours. Returns: object
get_todoARead-only
Get a specific todo checklist item by ID.
Use this when: You need full details of a specific todo (including project/client context, time estimates, related comments/attachments).
Returns:
Checkbox item text and completion status
Parent task with project and client details
Assignee and team member information
Due date relative to parent task timeline
Time estimates vs actual completion time
Related comments and file attachments
Inputs: todo_id (required). Returns: object
list_attachmentsARead-only
List attachment/file metadata with optional filtering.
Use this when: You need to browse or search attachments (files associated with tasks, comments, expenses). Note: returns metadata only — actual file content is not included.
Attachments are files (PDFs, images, documents) associated with tasks, comments, expenses, etc.
Returns:
File name, type, and size
Associated entity relationships (task, project, etc.)
Note: returns metadata only — actual file content is not included.
Inputs: page_size, page_number, extra_filters. Returns: object
list_commentsARead-only
List comments with optional filtering by project or task.
Use this when: You need full comment metadata (text, author, timestamps, attachments, mentions) and want to filter by specific project, task, or discussion thread.
Returns:
Comment text, author, and timestamp
Parent entity (project or task) with details
Discussion threads and replies
Attachments and file references
Mentions of team members or clients
Use extra_filters with filter[discussion_id][eq] to target a specific thread.
Inputs: task_id, page_size, project_id, page_number, +1 more. Returns: object
list_foldersARead-only
List folders in a project.
Productive exposes folders through the /folders endpoint.
Returns folder data including:
Folder ID and name
Archived status
Position/order within the project
Hidden flag and project relationship
Inputs: project_id (required), limit, status. Returns: object
list_pagesARead-only
List pages/documents with optional filtering by project, creator, or parent hierarchy.
Use this when: You need to browse or search for pages by project, creator, or to retrieve page metadata/titles without full content. Also use this to discover subpages/subfolders inside a folder page or root doc.
Pages in Productive are documents that can contain rich text content, attachments, and are organized within projects and nested inside parent pages.
Returns page titles, content, metadata, and project relationships.
Examples: list_pages(project_id=1234) # All pages in a project list_pages(creator_id=567) # Pages created by a specific person list_pages(extra_filters={'filter[parent_page_id][eq]': 179857}) # Direct subpages of a folder page list_pages(extra_filters={'filter[root_page_id][eq]': 179857}) # All pages in a doc tree
Inputs: page_size, creator_id, project_id, page_number, +1 more. Returns: object
list_peopleARead-only
List all team members with optional pagination.
Returns:
Person ID, name, and email
Role and title information
Last seen and join dates
Avatar and contact information
Inputs: page_size, page_number. Returns: object
list_projectsARead-only
List all projects with basic information.
Returns project data including:
Project ID, name, and number
Creation and last activity timestamps
Archived status (if applicable)
Webapp URL for direct access
Inputs: no named parameters. Returns: object
list_recent_activityARead-only
Get a summarized feed of recent activities and updates.
Returns recent changes, task updates, comments, new documents and activities in chronological order.
Examples: list_recent_activity() # Last 24 hours, all activity list_recent_activity(hours=168) # Last week list_recent_activity(hours=48, project_id=343136) # Last 2 days on specific project list_recent_activity(hours=24, user_id=12345) # What a specific user did today list_recent_activity(hours=24, activity_type=1) # Only comments from last day list_recent_activity(hours=168, item_type='Task') # Task activities from last week list_recent_activity(hours=168, event_type='edit') # Task edits from last week list_tasks(extra_filters={'filter[status][eq]': 2}, sort='-updated_at', page_size=10) # Recently closed tasks
Inputs: hours, task_id, user_id, item_type, +4 more. Returns: object
list_tasksARead-only
List tasks with optional filtering and pagination.
Supports filtering by project, assignee, status, and other criteria. All parameters are optional - omit to fetch all tasks.
Example of extra_filters:
filter[status][eq]=1: Open tasks
filter[status][eq]=2: Closed tasks
filter[workflow_status_category_id][eq]=3: Workflow closed status
filter[board_status][eq]=1: Active board tasks
Returns: Dictionary of tasks matching the provided filters
Inputs: sort, user_id, page_size, project_id, +2 more. Returns: object
list_time_entriesARead-only
List time entries with optional date and relationship filters.
Returns logged work records and related references (person/service/task).
Inputs: date, after, limit, before, +5 more. Returns: object
list_todosARead-only
List todo checklist items with optional filtering by task.
Use this when: You need to browse or filter checklist items across tasks (e.g., find all open todos in a project, filter by assignee). Use get_todo when you need full details of a specific todo.
Returns:
Checkbox item text and completion status
Assignee information
Parent task details with project context
Due dates and priority relative to parent task
Estimated vs actual time for checklist items
Filter by task_id to get all checklist items for a specific task.
Inputs: task_id, page_size, page_number, extra_filters. Returns: object
list_workflow_statusesARead-only
List workflow statuses from Productive.
Useful for understanding valid task status values by workflow.
Inputs: limit, category_id, workflow_id. Returns: object
quick_searchARead-only
Quick search across projects, tasks, pages, and actions.
This tool provides fast, comprehensive search across all Productive content types including projects, tasks, pages, and actions. It's optimized for quick lookups and general search queries.
Returns: Search results from Productive API including: - Matching projects, tasks, pages, and actions - Relevance scores and metadata - Full entity details for each match
Examples: quick_search("red") # Search for "red" across all content types quick_search("project", search_types=["project"]) # Search only in projects quick_search("meeting", deep_search=False) # Quick search without deep scan
Inputs: query (required), page, per_page, deep_search, +1 more. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 18 tools
Each tool targets a distinct resource or action: search, activity, projects, folders, workflow statuses, time entries, todos, tasks, task history, comments, pages, people, attachments. List/get pairs are clearly differentiated by singular vs plural and explicit descriptions, so an agent can reliably select the right tool.
All tools use a consistent verb_noun pattern: list_* for collections, get_* for single items, plus quick_search and list_recent_activity which follow the same style. Snake_case is used throughout with no mixing of conventions, making the API predictable.
18 tools is on the higher end but still reasonable for a project management server covering many entity types (projects, tasks, todos, pages, people, folders, comments, time entries, attachments, activity). Each tool serves a distinct purpose and none feel redundant, though the count slightly exceeds the typical 3-15 sweet spot.
The tool surface is heavily read-focused: every entity has list/get operations but no create, update, or delete methods exist for any resource. For a project management domain, this is a significant gap, as agents cannot create tasks, update statuses, add comments, or modify anything, limiting practical workflows.
Maintenance
Related MCP Connectors
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
A Model Context Protocol server for Wix AI tools
Official Fibery MCP server: query and update your workspace from any AI client via OAuth.
Related MCP Servers
FlicenseBqualityDmaintenanceA Model Context Protocol server that provides AI agents with read-only access to Rossum API resources (queues, schemas, hooks, workspaces) for analysis purposes.62-- AlicenseBqualityDmaintenanceA Model Context Protocol server implementation compatible with Todoist API, allowing AI agents to interact with task management functionality through standardized MCP tools.518 npm1MIT
- AlicenseNot gradedqualityNot gradedmaintenanceA unified Model Context Protocol server that provides a consistent interface for AI assistants to interact with productivity tools like Linear, GitHub, Slack, and Notion. It enables users to search, retrieve, and manage tasks and data across multiple workplace services from a single endpoint.18 npmMIT
- AlicenseAqualityDmaintenanceAn MCP server for Productive.io that enables users to log time, inspect projects, and manage time entries using natural language commands. It features fuzzy project matching, local caching, and remembers default services per project for streamlined time tracking.14MIT