Project Info

Mentra

Inspiration

A college degree and job security become more loosely correlated every year. One thing that still differentiates workers in all fields is hands on skills, and these can only be learned by doing. Many AI services have tried and failed to personalize learning, by either failing to innovate past chatbots, or simply lacking the long-term context to teach a long-term skill. Meet Mentra.

What it does

Mentra introduces a new approach to learning, where you are learn by doing, directly within your software environment; no context switching necessary. An agentic lesson planner curates lessons, with specificity down to each click. The user is then guided through the curriculum by a translucent text overlay placed on their screen—an agentic mentor challenging and guiding on them through hands-on experience.

How we built it

When discussing on the best way to build Mentra, phrases like AI agents, long context, and AI workflows were brought up then and again. The core problem we wanted to solve with Mentra was to reduce the context switching a user has to make when they have software in one screen, and a lesson in another. By solving this, we also open the door to providing instant feedback relevant to the context at that point in time. With all these goals and ideas in mind, we decided to build Mentra as an AI workflow, window-embedded lecture guide that uses AI agents with long memory to teach software to people more effectively.

Challenges we ran into

One big challenge that nearly killed our idea was configuring agentic flows for multi-step instructions including feedback to the user when they make a mistak, all while keeping AI context drift to zero. We solved this by segmenting Lectures into multiple Steps. The AI only needs two things in its co text at any point in time; the overarching goal of the lesson, and the goal of the specific step (could be a step to fix mistakes from a previous step). We saw massive improvements in AI coherence which is paramount to any educational endeavour.

Accomplishments we're proud of

The small translucent box at the top right corner that shows instructions to the user is not only innovative, but incredibly helpful. We’re proud of solving window-embedded UIs for instructive feedback.

What we learned

Start out with the simplest way to solve a specific problem. Complexity should increase out of necessity, not because you want flashy features.

What's next

We believe enterprise will benefit the most from Mentra. Imagine a world where every employee is a rockstar at each software they learn. Imagine the productivity boost!

CalHacks 2025 - Electron + Flask + React

A desktop application built with Electron, Flask backend, and React frontend for CalHacks 2025.

Architecture

Frontend: React application served by Electron
Backend: Flask API server running locally
Desktop: Electron wrapper for cross-platform desktop app

Project Structure

calhacks2025/
├── backend/                 # Flask backend
│   ├── app.py              # Main Flask application
│   ├── requirements.txt    # Python dependencies
│   ├── models/             # Database models
│   ├── routes/             # API routes
│   └── utils/              # Utility functions
├── frontend/               # React frontend
│   ├── src/                # React source code
│   ├── public/             # Static assets
│   └── package.json        # Frontend dependencies
├── scripts/                # Build and utility scripts
│   └── start-backend.js    # Backend process manager
├── main.js                 # Electron main process
├── preload.js              # Electron preload script
└── package.json            # Main dependencies and scripts

Getting Started

Prerequisites

Node.js (v16 or higher)
Python 3.7 or higher
npm or yarn

Installation

Clone the repository:

git clone https://github.com/FabianSiswanto/calhacks2025.git
cd calhacks2025

Install dependencies:

npm install

Install Python dependencies:

cd backend
pip install -r requirements.txt
cd ..

Development

Start the development environment:

npm run dev

This will:

Start the Flask backend on http://localhost:5000
Start the React frontend on http://localhost:3000
Launch the Electron app

Or start components individually:

# Terminal 1: Start backend
npm run start-backend

# Terminal 2: Start frontend
npm run start-frontend

# Terminal 3: Start Electron
npm start

Building for Production

Build the React frontend:

npm run build

Create distributable packages:

# All platforms
npm run dist

# Specific platforms
npm run dist-mac
npm run dist-win
npm run dist-linux

API Endpoints

The Flask backend provides the following endpoints:

GET / - Backend status
GET /health - Health check
GET /api/test - Test endpoint
GET /api/data - Get sample data
POST /api/data - Create new data
GET /api/files - List project files

Development Notes

The Flask backend runs on port 5000
The React frontend runs on port 3000 in development
Electron loads the React app from the built files in production
Backend and frontend communicate via HTTP API calls

Scripts

npm start - Start Electron app
npm run dev - Start development environment
npm run start-backend - Start Flask backend only
npm run start-frontend - Start React frontend only
npm run build - Build React frontend
npm run dist - Create distributable packages

License

MIT

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

CSSIn code
FlaskIn code
HTMLIn code
JavaScriptIn code
PythonIn code
ReactIn code
SupabaseIn code

7 of 7 appear in the indexed code.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

211 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.