Voxara

An AI-powered work assistant that turns natural conversations into intelligent, actionable workflows.

Comment

About Voxara

Inspiration

We interact with software through buttons, menus, and forms every day, even when the action we want is simple.

We wanted to explore a different approach: what if managing everyday work could feel like having a conversation with an intelligent assistant?

That idea led to Voxara, an AI-powered work assistant designed around natural language and agentic workflows. Instead of navigating through multiple screens to manage tasks, users can simply tell Voxara what they want to accomplish, and the AI can use tools to take action.

For example:

"What do I need to work on today?"

or:

"Create a high-priority task to deploy the backend tomorrow."

The goal is not just to build another chatbot, but to create an assistant that can understand intent, access useful information, and perform actions on the user's behalf.

How We Built It

The core of Voxara is an MCP (Model Context Protocol) server exposed through Streamable HTTP.

Our initial architecture is:

User
  ↓
AI Agent / Alexa+ Simulation
  ↓
MCP over Streamable HTTP
  ↓
Voxara MCP Server
  ↓
Application Services
  ↓
PostgreSQL

The MCP server exposes capabilities as tools that an AI agent can discover and call.

Our first tools include:

  • get_tasks — retrieves the user's current tasks
  • create_task — creates a new task
  • complete_task — marks a task as completed

For example, an AI agent can translate a natural-language request such as:

"Complete my authentication bug task."

into an MCP tool call:

complete_task(
    userId="user123",
    taskId=1
)

The server then performs the corresponding operation.

We are using Node.js and JavaScript for the MCP server and PostgreSQL for persistent application data. The project is designed around the Alexa+ simulated-experience path, allowing us to demonstrate the agentic interaction without requiring a physical Alexa+ device.

What We Learned

Building Voxara taught us that MCP is more than another API format.

A traditional application might have a frontend that directly calls endpoints such as:

GET /tasks
POST /tasks
PATCH /tasks/:id

With MCP, we can expose these capabilities in a way that an AI agent can understand and decide when to use.

We learned how to:

  • Build an MCP server using the JavaScript SDK.
  • Expose tools with structured input schemas.
  • Use Streamable HTTP to communicate with an MCP server.
  • Build an MCP client and discover available tools.
  • Call MCP tools programmatically.
  • Design tools around actions rather than simply returning information.
  • Think about authorization and user-specific access when designing agent tools.
  • Separate the AI reasoning layer from the underlying application logic.

One of the biggest lessons was that a good MCP tool needs a clear purpose and well-defined inputs and outputs. The quality of the tools directly affects how effectively an agent can use the application.

Challenges

One of our biggest challenges was understanding the difference between a normal HTTP API and an MCP server.

Initially, it was easy to think of MCP as simply another REST API. However, MCP introduces a layer where an AI agent can discover available capabilities and decide which tool to invoke.

We also had to work with the newer Streamable HTTP transport rather than relying on older MCP examples based on SSE.

Another challenge was making the system stateful. Our first prototype stored tasks in memory:

const tasks = [];

This worked for testing MCP interactions, but restarting the server would erase everything.

We therefore moved toward a proper persistence layer with PostgreSQL:

MCP Tool
   ↓
Database Operation
   ↓
PostgreSQL
   ↓
Persistent State

This helped us understand an important principle of agentic applications: the AI should control the workflow, while the application remains responsible for reliable data and business operations.

What's Next

We plan to expand Voxara beyond basic task management into a broader work assistant.

Future capabilities include:

  • Intelligent task prioritization
  • Daily work summaries
  • Calendar-aware planning
  • Reminders
  • Multi-step workflows
  • Context-aware recommendations
  • Additional MCP tools and integrations

Ultimately, we want Voxara to demonstrate how natural conversation can become an interface for real software actions, rather than simply another way to ask questions.

Built With

Share this project:

Updates

Submission history