Lexa - Workspace Dashboard
A glance at Tasks and Reminders
Create task by manually entering details
List of all Tasks
Add Shopping list items by manually entering details and also mark items as purchased
Create Reminders by manually entering details
Ask Lexa - AI chat assistant for managing household tasks, shopping lists and reminders.
Chat assistant asking for confirmation of the new item
Ask Lexa showing the Shopping Items List

Inspiration

Managing a household involves many small responsibilities—remembering tasks, keeping track of groceries, and staying on top of reminders. These responsibilities often end up scattered across notes, conversations and separate lists. Even simple changes can require navigating multiple screens and updating records manually.

We wanted to explore a more natural way to manage these everyday responsibilities: what if you could simply tell an AI assistant what you need, and it could help turn your words into actions?

That idea led to Lexa — Your AI Household Assistant. Inspired by the Alexa+ track and the possibilities of conversational AI, we set out to build an assistant that goes beyond answering questions and can interact with real application data through the Model Context Protocol (MCP).

What it does

Lexa brings household tasks, shopping lists, and reminders together in one web application, with a conversational assistant called Ask Lexa.

Task management: Create and track tasks with descriptions, priorities, due dates, and statuses.
Shopping list management: Add shopping items with quantities and track whether they have been purchased.
Reminders: Create scheduled reminders and mark them as completed.
Natural-language interaction: Ask questions about saved household data without manually searching through records.
AI-assisted updates: Ask Lexa to modify an existing task, shopping item or reminder. The assistant identifies the target and prepares a preview of the proposed changes.
User-controlled actions: Review and confirm proposed creations or updates, or cancel them before any database change occurs.
MCP-powered operations: Use 12 registered MCP tools to list, create, update and delete tasks, shopping items, and reminders.

Lexa uses actual application services and persistent MongoDB Atlas data rather than relying on fictional records in the conversation. Its conversational creation and update flows include confirmation safeguards, while deletion tools are available through MCP but are not exposed as conversational actions in the current interface.

How we built it

We built Lexa as a full-stack web application with a local AI runtime and a self-hosted MCP server.

Frontend: React 19, Vite 6, JavaScript, JSX, and CSS power the dashboard, task management, shopping list, reminders, and Ask Lexa interface.

Backend: Node.js and Express 5 provide the application APIs and connect the frontend, AI assistant, and database.

Database: MongoDB Atlas, accessed through Mongoose models and existing backend services, stores tasks, shopping items, and reminders persistently.

AI integration: We use Ollama with the qwen2.5:3b model through its local chat API. This lets us experiment with natural-language interaction without depending on a paid hosted AI API for the model calls.

MCP integration: We implemented a self-hosted MCP server in TypeScript using the official @modelcontextprotocol/sdk, Zod input validation, and Streamable HTTP transport. The server exposes 12 tools at /mcp on port 3001. Each tool connects to the existing backend services, keeping database operations and business logic in one place.

Confirmation workflow: When a user requests a supported creation or update, the backend prepares a pending action and the interface presents a preview. The user must explicitly confirm before the operation is executed. Pending actions expire after five minutes and are consumed upon confirmation. For updates, Lexa also checks that the record still exists and has not changed since the preview was created.

We also built an AI–MCP testing harness that discovers tools from the live MCP server, passes their schemas to the local model, validates tool arguments, handles multi-step tool calls, and verifies persisted changes by reading the records again.

Challenges we ran into

1. Connecting an AI model to real application functionality

Getting a model to generate a response was only the beginning. We needed it to select the appropriate tool, provide valid arguments, and use the actual results returned by the backend.

We addressed this by exposing MCP tools through the official SDK and building a tool-calling loop that returns tool results to the model for subsequent reasoning.

2. Handling all 12 MCP tools reliably

Our initial testing harness used a hard-coded allowlist that exposed only some of the registered tools. It also stopped after a single model response, making multi-step operations unreliable.

We changed the harness to discover tools dynamically through client.listTools(), validate arguments against the live schemas, and support a bounded multi-round tool loop.

3. Updating the correct record

A natural-language request such as “change the milk quantity to two” must be matched to a real database record. Record names can be ambiguous, and MongoDB document IDs cannot safely be guessed.

We made Lexa retrieve existing records before preparing updates, use the correct entity-specific IDs, and request clarification when a target cannot be matched uniquely.

4. Preventing unintended changes

An AI-generated tool call should not automatically authorize a database mutation. We also needed to account for records changing between a preview and confirmation.

We implemented explicit confirmation for supported creations and updates, expiring single-use action IDs, and checks for stale update previews. Delete tools remain available through MCP but are deliberately not exposed in the conversational interface.

5. Keeping the integration practical and affordable

We wanted to experiment with AI integration without introducing unexpected hosted-model charges. Using Ollama allowed us to run the selected model locally while connecting it to our existing backend and MongoDB Atlas database.

Accomplishments that we're proud of

Built a working full-stack household coordination application rather than stopping at a concept or static prototype.
Implemented a self-hosted MCP server using the official TypeScript SDK and Streamable HTTP transport.
Registered 12 tools covering listing, creation, updating, and deletion across three data categories.
Connected natural-language AI interactions to real application services and persistent database records.
Implemented a review-and-confirm workflow for conversational creations and updates, including cancellation, expiry, and stale-record checks.
Built a testing harness capable of discovering MCP tools dynamically and exercising multi-step AI tool interactions.
Kept the AI integration local, avoiding dependence on a paid hosted model API for inference.

We are particularly proud of treating reliability and user control as part of the product design, not as features to add after the AI integration works.

What we learned

Building Lexa taught us that connecting AI to real software requires much more than prompting a model. Tool discovery, input validation, record identification, error handling, state management and verification all play important roles in making an assistant useful.

We gained practical experience with the Model Context Protocol, Streamable HTTP transport, the official TypeScript SDK, local LLM integration through Ollama and multi-step tool-calling workflows.

We also learned the importance of separating an AI's proposal from an authorized action. Confirmation flows, expiring action IDs, and checks for stale data helped us think more carefully about trust and predictable behavior.

Most importantly, we learned to approach AI integration as an engineering problem: build incrementally, test against real data, investigate failures and verify that the intended changes actually persist.

What's next for Lexa - Your AI Household Assistant

Lexa is currently a local-first prototype with a working web interface, backend, local AI integration and self-hosted MCP server. Our next steps are focused on making it more complete, robust and accessible.

Alexa+ integration: Investigate and implement the appropriate Alexa developer configuration and integration needed to connect Lexa's MCP capabilities to an actual Alexa+ experience.
Deployment: Host the application and MCP server in an environment accessible for demonstration and testing.
Automated testing: Add integration tests covering the complete AI, MCP, backend, database, and browser workflows.
More robust conversations: Improve clarification, date and time interpretation, error recovery, and handling of ambiguous requests.
Persistent action management: Replace in-memory pending confirmations with a durable mechanism suitable for a deployed application.
Authentication and household access: Introduce authentication and appropriate authorization for households with multiple users.
Expanded household workflows: Explore additional integrations and capabilities that make everyday coordination more seamless.

Our long-term vision is for Lexa to evolve from a household management web app into a dependable conversational assistant that helps people coordinate everyday life through natural interactions—while keeping important actions transparent and under the user's control.