Taskade

Automatically generates MCP tool implementations from OpenAPI specifications using the @taskade/mcp-openapi-codegen package. The codegen pipeline parses OpenAPI schemas, validates endpoint definitions, generates TypeScript tool wrappers with proper type safety, and produces runtime-ready code that handles request/response serialization and schema validation. This eliminates manual tool definition boilerplate and keeps tool definitions synchronized with API changes.

Provides a Node.js-based MCP server (@taskade/mcp-server) that can be deployed and invoked through two distinct patterns: command-line execution (where clients spawn the server process per instance) or SSE/HTTP connection (where clients connect to a persistent server via HTTP with Server-Sent Events for bidirectional communication). The server handles MCP protocol serialization, authentication flow management, and routes tool invocations to the Taskade API with proper error handling and response normalization.

Implements a modular server architecture where tool handlers are registered in a central registry, enabling dynamic tool discovery and invocation. The server maintains a mapping of tool names to handler functions, validates incoming tool requests against registered schemas, and routes requests to appropriate handlers. This architecture decouples tool implementations from the MCP protocol layer, allowing new tools to be added by registering handlers without modifying core server code. The handler registry is populated at server startup from generated tool definitions.

Exposes Taskade's public API endpoints (tasks, projects, workflows, AI agents, workspace operations) as discoverable MCP tools that AI clients can invoke. The server translates MCP tool invocations into authenticated HTTP requests to Taskade's API, handles response parsing, normalizes responses to MCP format, and returns structured data about workspace state. This enables AI assistants to read and manipulate Taskade workspaces in real-time without requiring direct API integration by the client.

Organizes the Taskade MCP project as a Lerna-managed monorepo with Yarn workspaces, enabling coordinated development, testing, and publishing of multiple interdependent packages (@taskade/mcp-server and @taskade/mcp-openapi-codegen). The monorepo structure uses shared build scripts, unified dependency management, and changesets-based versioning to keep packages in sync and automate release workflows. This architecture allows the codegen package to generate code that the server package consumes, with both packages versioned and published together.

Provides a configurable response normalization layer that transforms raw Taskade API responses into MCP-compatible formats. The system supports custom normalization handlers that can be defined per endpoint, allowing developers to reshape API responses, extract relevant fields, flatten nested structures, or apply domain-specific transformations before returning data to MCP clients. This abstraction decouples the Taskade API response format from the MCP tool interface, enabling API changes without breaking client integrations.

Implements the Model Context Protocol specification for tool discovery, invocation, and response handling. The server manages JSON-RPC 2.0 serialization, validates incoming tool requests against generated MCP schemas, routes requests to appropriate handlers, and serializes responses back to MCP format. This includes proper error handling with MCP-compliant error responses, request validation, and support for both synchronous and asynchronous tool execution. The protocol layer abstracts away the complexity of MCP communication from the tool implementation logic.

Manages authentication to the Taskade API through environment variables or configuration files, supporting API key-based authentication. The server handles credential injection into API requests, manages authentication state across multiple tool invocations, and provides error handling for authentication failures. Credentials are not exposed to MCP clients; the server acts as a trusted intermediary that authenticates on behalf of the client. This pattern enables secure API access without requiring clients to manage or store Taskade credentials.

Provides a configuration system for the OpenAPI codegen package that allows developers to customize code generation behavior through configuration files or CLI options. Supported options include output directory, target language/framework, response normalization strategy, and tool naming conventions. The codegen reads the configuration, applies it during the code generation process, and produces output tailored to the specified requirements. This enables teams to generate code matching their project structure and coding standards without modifying the codegen source.

Automates the release and publishing workflow using GitHub Actions, changesets, and Lerna. The pipeline detects changes to packages, validates that changesets are present, automatically bumps versions based on changeset types (major/minor/patch), generates changelogs, and publishes updated packages to npm. This workflow ensures consistent versioning across packages, maintains accurate changelogs, and reduces manual release overhead. The changesets system requires contributors to document changes, creating a clear audit trail of what changed and why.

Generates TypeScript type definitions and MCP tool schemas directly from OpenAPI specifications, ensuring that generated tool implementations have full type safety and schema validation. The codegen parses OpenAPI models, generates corresponding TypeScript interfaces, creates MCP tool schemas matching the OpenAPI endpoint definitions, and validates that generated code matches the schema at build time. This approach prevents runtime type mismatches and enables IDE autocompletion for tool parameters and responses.