Skip to main content
Glama
dotcollective-joel

productive-io-mcp

by dotcollective-joel
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Remote

Productive.io MCP Server

A Model Context Protocol (MCP) server for interacting with Productive.io task management platform.

Features

  • 🔧 Extensible Architecture - Plugin-based tool system for easy extension

  • 📦 Modular Design - Clean separation of concerns with TypeScript

  • 🔒 Type-Safe - Full TypeScript support with strict type checking

  • ⚙️ Configuration Management - Environment-based configuration

  • 🎯 Easy to Extend - Add new tools by creating a single class

Related MCP server: productive-mcp-rb2

Installation

# Install dependencies
pnpm install

# Build the project
npm run build

Configuration

For Claude Desktop

Add the MCP server to your Claude Desktop config file with environment variables:

Location:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

Configuration:

{
  "mcpServers": {
    "productive.io": {
      "command": "node",
      "args": ["/Users/joelkrause/dev/productive-mcp/build/index.js"],
      "env": {
        "PRODUCTIVE_API_TOKEN": "your-api-token-here",
        "PRODUCTIVE_ORGANIZATION_ID": "your-organization-id",
        "PRODUCTIVE_USER_ID": "your-user-id"
      }
    }
  }
}

For Development/Testing

You can also use a .env file (use .env.example as a template):

cp .env.example .env

Required environment variables:

  • PRODUCTIVE_API_TOKEN - Your Productive.io API token

  • PRODUCTIVE_ORGANIZATION_ID - Your organization ID

  • PRODUCTIVE_USER_ID - Your user ID

Available Tools

get_task

Get a single task from Productive.io by URL.

Parameters:

  • url (string) - Productive.io task URL

get_tasks

Get multiple tasks with optional filters.

Parameters:

  • assignee_id (string, optional) - Filter by assignee ID

  • status (number, optional) - Filter by status (1=Open, 2=Closed)

  • project_id (string, optional) - Filter by project ID

Project Structure

src/
├── config/           # Configuration management
│   └── index.ts      # Environment-based config loader
├── services/         # API clients and services
│   └── ProductiveApiClient.ts  # Typed Productive.io API client
├── tools/           # MCP tools (plugins)
│   ├── base/        # Base tool class
│   │   └── BaseTool.ts
│   ├── get-task/    # Individual tool modules
│   │   ├── index.ts    # Tool implementation
│   │   ├── handler.ts  # Business logic (includes URL extraction)
│   │   └── schema.ts   # Zod validation schema
│   ├── get-tasks/
│   │   ├── index.ts
│   │   ├── handler.ts
│   │   └── schema.ts
│   └── index.ts     # Tool registry and auto-registration
├── types/           # TypeScript type definitions
│   ├── config.types.ts
│   ├── productive.types.ts
│   └── tool.types.ts
└── index.ts         # Main entry point

Adding a New Tool

Adding a new tool is simple with the extensible architecture:

1. Create a new tool directory

mkdir -p src/tools/your-tool

2. Create the schema (src/tools/your-tool/schema.ts)

import { z } from "zod";

export const YourToolSchema = z.object({
  param1: z.string().describe("Description of param1"),
  param2: z.number().optional().describe("Optional param2"),
});

export type YourToolInput = z.infer<typeof YourToolSchema>;

3. Create the handler (src/tools/your-tool/handler.ts)

import { ProductiveApiClient } from "../../services/ProductiveApiClient.js";
import { ToolResponse } from "../../types/tool.types.js";

export async function handleYourTool(
  input: YourToolInput,
  apiClient: ProductiveApiClient
): Promise<ToolResponse> {
  try {
    // Your logic here
    const result = await apiClient.someMethod();

    return {
      content: [{ type: "text", text: "Success!" }],
    };
  } catch (error) {
    return {
      content: [
        {
          type: "text",
          text: `Error: ${error instanceof Error ? error.message : "Unknown"}`,
        },
      ],
      isError: true,
    };
  }
}

4. Create the tool class (src/tools/your-tool/index.ts)

import { BaseTool } from "../base/BaseTool.js";
import { ProductiveApiClient } from "../../services/ProductiveApiClient.js";
import { ToolResponse } from "../../types/tool.types.js";
import { YourToolSchema, YourToolInput } from "./schema.js";
import { handleYourTool } from "./handler.js";

export class YourTool extends BaseTool<YourToolInput> {
  readonly name = "your_tool";
  readonly description = "Description of what your tool does";
  readonly schema = YourToolSchema;

  private apiClient: ProductiveApiClient;

  constructor(apiClient?: ProductiveApiClient) {
    super();
    this.apiClient = apiClient || new ProductiveApiClient();
  }

  async execute(input: YourToolInput): Promise<ToolResponse> {
    return handleYourTool(input, this.apiClient);
  }
}

5. Register the tool (src/tools/index.ts)

import { YourTool } from "./your-tool/index.js";

export function getAllTools(): Tool[] {
  return [
    new GetTaskTool(),
    new GetTasksTool(),
    new YourTool(), // Add your tool here
  ];
}

That's it! Your new tool will be automatically registered and available.

Development

# Build the project
npm run build

# Watch mode for development
npm run dev

# Type checking only
npm run typecheck

# Clean build directory
npm run clean

# Clean and rebuild
npm run rebuild

Architecture Benefits

Extensibility

  • Plugin-based: New tools are self-contained modules

  • Auto-registration: Tools are automatically registered from the registry

  • No core changes: Adding tools doesn't require modifying the main server code

Type Safety

  • Full TypeScript: Strict type checking enabled

  • Type inference: Zod schemas provide runtime validation and compile-time types

  • API types: Fully typed Productive.io API responses

Maintainability

  • Separation of concerns: Each tool has its own directory with schema, handler, and implementation

  • Reusable components: BaseTool provides common functionality

  • Clear structure: Easy to navigate and understand

Best Practices

  • Error handling: Consistent error responses across all tools

  • Configuration: Environment-based configuration management

  • Documentation: JSDoc comments throughout the codebase

License

MIT

This server cannot be installed

A
license - permissive license
-
quality - not tested
D
maintenance

How are these scores calculated?

Maintenance

–Maintainers
–Response time
–Release cycle
–Releases (12mo)
Commit activity

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/dotcollective-joel/productive-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server