TaskPilot AI — From Natural Language to Real Actions

Inspiration

We wanted to explore a practical question: what happens when a conversational assistant can do more than answer questions?

Task management applications often require users to navigate forms, menus, and multiple screens to organize their day. We built TaskPilot AI to make task management more conversational, while ensuring that commands result in real backend operations rather than simulated client-side changes.

Our project combines an interactive Alexa+-style voice and text experience with a self-hosted Model Context Protocol (MCP) server. It demonstrates how conversational interfaces can connect to structured tools, execute actions, and make those operations transparent.

What It Does

TaskPilot AI is a voice-first task management ecosystem that lets users interact with their tasks using natural-language commands.

• Conversational task creation: Create tasks with priorities and due dates using supported voice or text commands.
• Task management: View open and completed tasks and mark tasks as complete.
• Daily planning: Turn a planning request into a structured proposed plan and execute supported task actions.
• Real MCP tool execution: Route supported operations through JSON-RPC 2.0 over Streamable HTTP to a self-hosted MCP server.
• Persistent storage: Store task data in SQLite with Write-Ahead Logging (WAL), rather than relying on temporary frontend state.
• Protocol transparency: Inspect discovered tools, request and response payloads, execution status, and latency through the MCP Protocol Inspector.

The application uses an Alexa+-style simulation for this hackathon. It is a demonstration of conversational interaction with a real backend, not a claim of native Alexa+ integration.

How We Built It

We built the application using Next.js 14, TypeScript, Node.js, the official Model Context Protocol SDK, and SQLite.

The frontend provides the task board, conversational assistant, daily planning workflow, and protocol inspector. Browser speech recognition and text-to-speech enable voice interaction where supported by the browser.

A server-side MCP client initializes a connection to the standalone MCP server, discovers its registered tools, and executes structured tool calls through Streamable HTTP. The server exposes three core tools:

• list_tasks — retrieve tasks by status.
• create_task — create a task with a title, priority, and optional due date.
• complete_task — mark a task as complete, with ambiguity handling when multiple tasks match.

The backend stores task data in SQLite using WAL mode and prepared SQL statements. Both the Next.js application and MCP server run within a unified Render service, with internal communication over loopback networking.

Challenges We Faced

One major challenge was making the application reliable across local development and cloud deployment.

We investigated Next.js runtime chunk conflicts, Linux case-sensitive import paths, and API routes that could cache failed backend health checks during static builds. We addressed these issues through a cleaner production build workflow, corrected imports, and dynamically executed API routes.

We also encountered reliability challenges when separating the frontend and MCP backend across hosting platforms. A unified service architecture reduced cross-service networking dependencies and simplified deployment.

Another important challenge was ensuring that the assistant did not report success when the backend was unavailable or complete the wrong task when a title matched multiple items. We connected the assistant's status to actual backend health checks and implemented explicit ambiguity handling.

What We Learned

This project taught us that building an AI-powered application requires more than connecting a chat interface to a model. Reliable tool execution, protocol correctness, persistent state, input validation, error handling, and observability are equally important.

Implementing MCP helped us understand structured tool discovery and execution through a standardized protocol. Building the protocol inspector also made the underlying interactions easier to inspect and debug.

We learned that deployment architecture is part of the product itself: an application must behave correctly after deployment, not just on a developer's machine.

Accomplishments

• Built and deployed a conversational task management application with a self-hosted MCP backend.
• Implemented real task operations backed by persistent SQLite storage.
• Integrated Streamable HTTP transport and JSON-RPC 2.0 tool execution.
• Created a live protocol inspector for examining MCP interactions.
• Implemented safeguards for ambiguous task matching and backend connectivity.
• Documented 33 passing automated tests across MCP integration, task planning, transport, and data consistency.

What's Next

We plan to expand conversational understanding, introduce recurring tasks and reminders, improve daily planning, strengthen production persistence and recovery, and explore calendar and productivity integrations.

Our longer-term goal is to make TaskPilot AI a dependable conversational workspace where users can delegate routine organization tasks and clearly verify what the system actually did.

Built With

• artificial-intelligence
• json-rpc
• model-context-protocol-(mcp)
• next.js
• node.js
• sqlite
• streamable-http
• typescript
• voice-interface
• web-speech-api