Luna Guardian AI

An AI-powered academic assistant that turns natural-language requests into real actions, creating study plans, managing deadlines, and tracking progress through MCP tools.

Comment

🌙 Luna Guardian AI

From your words to real study plans.

Inspiration

As a university student, I’ve experienced how difficult it can be to balance exams, assignments, and study time.

Sometimes, the biggest challenge isn’t understanding what to study. It’s deciding where to start, what to prioritize, and how to fit everything into a limited schedule.

AI chatbots can suggest study plans, but students still have to manually create tasks, organize their schedules, and track their progress.

I wanted to build something different: an AI assistant that doesn’t just give advice but actually takes action.

That’s how Luna Guardian AI was born.

What It Does

Luna Guardian AI is an intelligent academic productivity assistant that transforms natural-language requests into actionable study plans.

For example, a student can say:

“I have a Java exam tomorrow, two assignments to finish, and only three hours available.”

Luna can:

  • Understand the student’s academic commitments.
  • Create tasks with deadlines, priorities, and estimated durations.
  • Generate a structured study schedule.
  • Save tasks and study sessions in a persistent database.
  • Display upcoming deadlines and daily priorities.
  • Track the actual tools executed by the AI.
  • Retrieve saved information when the application is reopened.

Instead of simply generating a paragraph of advice, Luna performs real operations through MCP tools.

How We Built It

Luna Guardian AI combines a language model, a self-hosted MCP server, and a persistent database.

  1. AI Reasoning with Google Gemini

We integrated Google Gemini to interpret natural-language requests and independently select the appropriate tools.

For example, Gemini can decide to execute create_task followed by create_study_plan to fulfill a student’s request.

  1. Model Context Protocol (MCP)

We implemented a self-hosted MCP server using Streamable HTTP and MCP protocol version 2025-11-25.

The application exposes nine MCP tools for academic task management, study planning, and student context.

The agent executes these tools through real MCP client-server communication.

  1. Persistent Storage

We use PostgreSQL to store academic tasks, study sessions, and agent activity.

Students can refresh the application without losing their saved schedules.

  1. Interactive Dashboard

We developed a responsive web interface featuring:

  • AI assistant conversation.
  • Daily priorities.
  • Weekly study schedule.
  • Upcoming deadlines.
  • Task completion controls.
  • Agent activity history.
  • Browser-based speech controls.

The activity panel provides transparency by showing actual tool calls, execution status, arguments, and results.

  1. Cloud Deployment

The application is deployed on Render and accessible through a public web interface.

The source code is available on GitHub under the MIT license.

Alexa+ Track Integration

Luna Guardian AI was built for the Alexa+ track of the Build, Ship, Shape: Amazon Developer Hackathon.

It demonstrates an Alexa+-style simulated experience backed by a real self-hosted MCP server.

The MCP implementation uses protocol version 2025-11-25 and Streamable HTTP.

The project does not claim an official Alexa+ device or gated Alexa+ service integration.

Instead, it demonstrates how an AI assistant can use MCP tools to perform meaningful academic productivity workflows.

Challenges We Faced

Reliable AI Tool Execution

One of the biggest challenges was moving beyond conversational responses.

We needed Gemini to select appropriate MCP tools, execute them successfully, and accurately report the results.

MCP Protocol Compatibility

Implementing and verifying MCP Streamable HTTP communication required careful testing.

We validated protocol negotiation and tool execution using an official MCP client.

Persistent Data

We needed to ensure that study plans remained available after browser refreshes and application redeployments.

We implemented PostgreSQL persistence and verified it through live tests.

Secure Deployment

The application required authentication and secure API-key management.

We configured private environment variables and verified that protected API endpoints reject unauthenticated requests.

Cloud Infrastructure Constraints

We deployed using free cloud resources, which introduced limitations such as cold starts and restricted database availability.

These constraints helped us learn how to balance reliability, security, and cost.

Accomplishments We’re Proud Of

  • Built a working AI agent that independently selects and executes MCP tools.
  • Implemented MCP protocol 2025-11-25 using Streamable HTTP.
  • Exposed nine discoverable MCP tools.
  • Verified natural-language task creation and study planning on the live deployment.
  • Implemented persistent PostgreSQL storage.
  • Built an auditable activity timeline showing real tool execution.
  • Deployed a publicly accessible application.
  • Passed 12 automated tests.
  • Created a separate open-source MCP study planner toolkit.

What We Learned

This project taught us that building an AI agent requires much more than connecting an LLM to a user interface.

Reliable agents need well-defined tools, structured communication, persistent data, clear error handling, and transparent execution.

We also gained practical experience with MCP, AI function calling, cloud deployment, and end-to-end verification.

What’s Next?

We plan to extend Luna Guardian AI with:

  • Calendar integrations.
  • Automatic deadline reminders.
  • More advanced adaptive scheduling.
  • Improved voice interaction.
  • Multi-user accounts.
  • Additional academic productivity tools.
  • Potential future integration with supported Alexa+ experiences.

Our long-term vision is to create an AI academic companion that helps students spend less time organizing their work and more time learning.

Open Source Contribution

Alongside Luna Guardian AI, we developed the Luna MCP Study Planner Toolkit, a separate MIT-licensed Python project.

It provides reusable components for developers building academic scheduling functionality into MCP-powered applications.

The toolkit includes documentation, automated tests, and MCP registration helpers.

Conclusion

Luna Guardian AI demonstrates how AI assistants can move beyond conversations and start completing real tasks.

By combining Gemini, MCP, and persistent storage, we built an academic productivity assistant that transforms student requests into organized, actionable study plans.

Built With

Share this project:

Updates

Submission history