Task API Server - MCP TypeScript Implementation: Universal Integration for AI Applications

Overview: What is Task API Server - MCP TypeScript Implementation?

The Task API Server - MCP TypeScript Implementation is a comprehensive Model Context Protocol (MCP) reference server designed to facilitate seamless integration with diverse AI applications and external task management APIs. This implementation adopts a dual interface approach, offering both STDIO and HTTP+SSE protocols for varying deployment scenarios. The server supports multiple operational modes, ensuring robustness and adaptability.

🔧 Core Features & MCP Capabilities

Task Management Operations

The server provides an extensive suite of task management functionalities, including listing tasks with custom filters, creating new tasks, updating task details, and deleting completed or outdated tasks. Each operation ensures data integrity through comprehensive validation mechanisms and sophisticated error handling.

Dual Interface Modes

STDIO Protocol: Enables communication via standard input/output, making it ideal for CLI-based applications and AI agents.
HTTP+SSE Protocol: Aversely, this protocol allows web-accessible interactions suitable for browser-based clients and HTTP operations, enhancing the server's reachability and accessibility.

MCP Protocol Implementation

The fully implemented MCP includes resource handling for task data structures, along with tools and error management features. The comprehensive test client ensures thorough validation of API responses, maintaining high standards in client-server communication.

⚙️ MCP Architecture & Protocol Implementation

Server Modes

STDIO Mode: Standardized input/output for CLI inter-operation.
HTTP+SSE Mode: Web-oriented protocol with real-time updates through SSE.

Detailed Capabilities

Task listing with optional filters (status, category, priority).
Task creation and update features.
Deletion of tasks based on their completion status or other conditions.
Comprehensive validation and informative error messages throughout the API.

🚀 Getting Started with Installation

To setup and run this server, you need Node.js 16.x or higher along with npm or pnpm. Follow these steps to get started:

Prerequisites

Node.js installed.
npm or pnpm for package installation.

Steps for Installation

Clone the Repository

git clone https://github.com/yourusername/mcp-template-ts.git
cd mcp-template-ts

Install Dependencies
- Using npm:
```
npm install
```
- Using pnpm:
```
pnpm install
```

Create .env File for Credentials Add the necessary environment variables in a .env file:

TASK_MANAGER_API_BASE_URL=https://your-task-api-url.com/api
TASK_MANAGER_API_KEY=your_api_key_here
TASK_MANAGER_HTTP_PORT=3000

Build the Project Ensure the latest code is compiled by running:
```
npm run build
```
Run the Server in Different Modes
- For STDIO Mode (CLI/AI agents)
```
npm start
```
- For HTTP Mode (web access)
```
npm run start:http
```

By default, the HTTP server runs on port 3000. You can change this by setting TASK_MANAGER_HTTP_PORT in your .env file.

💡 Key Use Cases in AI Workflows

Use Case: Project Management Integration with MCP Client

Suppose an developer wants to integrate a project management tool with multiple AI applications, including Claude Desktop and Continue. The Task API Server - MCP TypeScript Implementation can be used as the central bridge, supporting both STDIO and HTTP modes for versatile connectivity.

Server Setup: Deploy the server in both modes according to the application's requirements.
MCP Client Configuration: Configure the MCP client with appropriate resources like task descriptions and categories, tools for handling these tasks dynamically, and prompts for task status updates.
Real-time Collaboration: Utilize HTTP+SSE mode for real-time updates where multiple users or AI agents can collaborate on project tasks without disrupting workflow.

Use Case: Real-Time Documentation Updates

Another scenario involves a writer collaborating with an AI assistant to automate the documentation process. Here, the Task API Server handles updating task statuses and descriptions in near-real-time as documents are edited.

Server Setup: Deploy the HTTP server for a web interface that can be accessed by both the writer and AI agents.
MCP Client Integration: Use the MCP client to manage tasks based on document completion phases, ensuring all edits and progress updates are recorded accurately.
Real-Time Updates: The task statuses update instantly in the Task API Server, reflecting the current state of the documentation.

🔌 Integration with MCP Clients

STDIO Client

To connect an application using STDIO protocol, follow this TypeScript example:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
import * as path from 'path';

// Create transport
const transport = new StdioClientTransport({
  command: 'node',
  args: [path.resolve('path/to/dist/index.js')]
});

// Initialize client
const client = new Client(
  {
    name: "your-client-name",
    version: "1.0.0"
  },
  {
    capabilities: {
      prompts: {},
      resources: {},
      tools: {}
    }
  }
);

// Connect to server
await client.connect(transport);

// Example operations
const listTasksResult = await client.callTool({
  name: "listTasks",
  arguments: { status: "pending" }
});

// Clean up
await client.close();

HTTP Client Example

For browser-based clients, use the following JavaScript snippet:

<!DOCTYPE html>
<html>
<head>
  <title>Task Manager</title>
  <script type="module">
    import { Client } from 'https://cdn.jsdelivr.net/npm/@modelcontextprotocol/sdk/dist/esm/client/index.js';
    import { SSEClientTransport } from 'https://cdn.jsdelivr.net/npm/@modelcontextprotocol/sdk/dist/esm/client/sse.js';

    document.addEventListener('DOMContentLoaded', async () => {
      // Create transport
      const transport = new SSEClientTransport('http://localhost:3000/mcp');
      
      // Initialize client
      const client = new Client(
        {
          name: "browser-client",
          version: "1.0.0"
        },
        {
          capabilities: {
            prompts: {},
            resources: {},
            tools: {}
          }
        }
      );

      // Connect to server
      await client.connect(transport);
      
      // Perform operation
      const result = await client.callTool({
        name: 'listTasks',
        arguments: { status: "pending" }
      });

      console.log(result);
    });
  </script>
</head>
<body>
</body>
</html>

This example demonstrates calling the listTasks tool with a specific argument—here, 'pending' tasks. Ensure to customize paths and other details as required.

2 Mermaid Diagrams

MCP Protocol Flow

graph TD
    A[AI Application] -->|MCP Client| B[MCP Server]
    B --> C[Data Source/Tool]
    style A fill:#e1f5fe
    style C fill:#f3e5f5

Data Architecture

graph TD
  subgraph "Data Flow"
    A[Task] -->|Stored| D[Storage Layer]
    B[Client] -->|Reads/Updates| E[MCP API Layer]
    F["Database or External API"] -->|Access Point from MCP Server|
    D --> F
    style A fill:#e8f5e8
  end

2 Realistic AI Workflow Use Cases

Case 1: Project Management and Team Collaboration

In this use case, the server is deployed within a company's project management ecosystem. Multiple developers and reviewers collaborate on a large-scale software development project using various AI tools and platforms. The Task API Server acts as the central integration point:

Developers contribute through CLI interactions (STDIO mode), updating tasks and statuses.
Reviewers inspect completed or pending tasks in real-time via web interfaces, providing feedback directly into the workflow.

Case 2: Real-Time Document Editing

For a publishing house, the server is integrated with an AI-driven content creation platform. Authors and editors use this system for collaborative document writing:

Authors input text changes using STDIO clients.
Editors monitor documents in real-time via web interfaces, applying their feedback instantaneously.

MCP Configuration Code Sample

Configuration of multiple servers or different modes might look like:

{
  "mcpServers": {
    "serverOne": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-stdio"],
      "env": {
        "API_KEY": "your-api-key-one"
      }
    },
    "serverTwo": {
      "command": "node",
      "args": ["./dist/index.js"],
      "env": {
        "API_KEY": "your-api-key-two",
        "MODE": "HTTP"
      }
    }
  }
}

This JSON snippet configures two separate servers—one for STDIO and another for HTTP mode—with distinct API keys.

FAQ

Q: How do I integrate this server with Claude Desktop?

A: Configure the .env file with API_KEY required by Claude Desktop. Then run the server in STDIO mode, which is compatible out of the box.

Q: Is there a demo setup available for quick testing purposes?

A: No official setup exists; however, you can clone the repository and follow the steps outlined above to create your own test environment quickly.

Q: Can this server handle large-scale deployments with multiple concurrent users?

A: Yes, but performance depends on how well the server is optimized. Consider scaling strategies such as load balancing if deploying to high-traffic environments.

Q: Are there specific versions of MCP clients that are not supported by your implementation?

A: The compatibility matrix indicates full support for Claude Desktop and Continue, while Cursor may lack some features like prompts or resources.

Q: What happens when an error occurs during task creation or update?

A: Detailed error handling and logging mechanisms are in place. Information messages are provided to both clients and servers for debugging purposes.

👨‍💻 Development & Contribution Guidelines

For developers looking to enhance this implementation, please refer to the project's CONTRIBUTING.md file for guidelines on setting up your development environment, submitting bug reports, and feature requests.

🌐 MCP Ecosystem & Resources

The Task API Server - MCP TypeScript Implementation is part of a broader ecosystem supporting various AI tools. Explore other resources such as forums, documentation, and community projects to expand your understanding and capabilities in building intelligent applications through MCP integration.

This comprehensive documentation aims to assist developers in effectively integrating this server with their AI application ecosystems, emphasizing real-world applicability and technical depth.

Task API Server - MCP TypeScript Implementation