Project Info

CheatSheet

Inspiration

We recognized a significant gap in the education system: students often spend too much time confused about what to study, while instructors lack the bandwidth to provide immediate, personalized guidance to every individual. We wanted to bridge that gap.

What it does

CheatSheet seamlessly integrates with Canvas to retrieve course data. It leverages Generative AI to produce detailed, granular metrics that visualize a student's actual understanding of the course material, moving beyond simple letter grades.

How we built it

Synthetic Data Generation: We created a custom course on Canvas and utilized Gemini to generate comprehensive course materials (assignments, quizzes). We then deployed a 2B parameter LLM to simulate realistic student performance and responses. Content Analysis: We used Gemini to parse and analyze the course syllabus, assignment descriptions, and quiz questions. Knowledge Mapping: Using a Gemini embedding model, we semantically mapped assignments and quizzes to specific course topics derived from the syllabus. Algorithmic Scoring: We implemented a custom algorithm leveraging Bayesian methods to calculate proficiency levels for specific topics based on graded assignment data.

Challenges we ran into

Hardware Failures: One of our key development laptops suffered a critical failure right before the integration and deployment phase, forcing us to scramble for resources. Strategic Pivots: We identified flaws in our initial approach mid-hackathon and had to execute a rapid pivot to a more viable architecture.

Accomplishments we're proud of

Feature Completeness: Despite the setbacks, we successfully implemented every core feature we initially planned. Seamless Integration: We proved that our system can easily and effectively integrate with the Canvas LMS API.

What we learned

We gained a deep appreciation for the complexity of educational structuring. Creating a cohesive curriculum—and building software to manage it—is a multifaceted challenge that requires precise data handling.

What's next

Automated Grading: Integrating directly with auto-graders for real-time feedback loops. Longitudinal Tracking: Implementing features to track student learning trajectories across multiple classes and semesters.

CheatSheet 📊

AI-powered course analytics dashboard for Canvas LMS. Generate student insights, identify knowledge gaps, and create personalized practice problems.

Architecture

CheatSheet consists of two services:

Service	Port	Description
Frontend App	5001	Flask web dashboard for teachers and students
AI Service	8001	FastAPI backend for ML-powered topic analysis

Features

Teacher Dashboard - View all your Canvas courses at a glance
Student Insights - AI-analyzed topic mastery based on grading patterns
Practice PDFs - Generate targeted practice problems for struggling areas

Prerequisites

Docker & Docker Compose
Canvas LMS Access Token
Supabase account (for authentication)
Gemini API Key (for AI service)

Environment Setup

Frontend App (.env)

SUPABASE_URL=your_supabase_project_url
SUPABASE_KEY=your_supabase_anon_key
CANVAS_INSTANCE=canvas.instructure.com

AI Service (aiservice/.env)

GEMINI_API_KEY=your_gemini_api_key

Running with Docker

Start Frontend App

docker compose up -d --build

App available at http://localhost:5001

Start AI Service

cd aiservice
docker compose -f docker-compose.prod.yml up -d --build

API available at http://localhost:8001

View Logs

docker compose logs -f           # Frontend
docker compose -f aiservice/docker-compose.prod.yml logs -f  # AI Service

Stop Services

docker compose down
cd aiservice && docker compose -f docker-compose.prod.yml down

AI Service Endpoints

Endpoint	Method	Description
`/topic-extraction`	POST	Extract topics from syllabus
`/assessment-processing`	POST	Process assignments into question chunks
`/topic-mapping`	POST	Map questions to topics via embeddings
`/topic-understanding`	POST	Compute mastery scores (Bayesian inference)
`/problem-generation`	POST	Generate practice problems with Gemini
`/health`	GET	Health check

Project Structure

├── app.py                  # Flask frontend application
├── db.py                   # Supabase database operations
├── insights.py             # Insight generation (calls AI service)
├── templates/              # HTML templates
├── static/css/             # Stylesheets
├── Dockerfile.app          # Frontend Docker config
├── docker-compose.yml      # Frontend compose config
└── aiservice/
    ├── backend/
    │   ├── app.py          # FastAPI AI service
    │   ├── src/            # ML services & schemas
    │   └── Dockerfile      # AI service Docker config
    └── docker-compose.prod.yml

Tech Stack

Frontend: Flask, Python 3.12, Glassmorphism CSS
AI Backend: FastAPI, Gemini API
Database: Supabase (PostgreSQL)
Auth: Supabase Auth
ML: Embeddings, Cosine similarity, Bayesian inference
PDF Generation: xhtml2pdf
Containerization: Docker

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
PythonIn code
SupabaseIn code

5 of 5 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

115 KB

Source files

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