myTutor

Your personal AI tutor

Comment

MyTutor: Building an AI-Powered Personalized Learning Platform

Inspiration

The motivation for MyTutor came from a persistent frustration with online learning platforms. As someone passionate about continuous learning, I found myself spending 2-3 hours researching courses on platforms like Udemy, Coursera, and YouTube before even starting to learn. The challenge wasn't the lack of educational content and it was the overwhelming abundance of it, combined with no way to know if an instructor's teaching style would match my learning preferences until I was already deep into the course.

More significantly, I realized that traditional courses follow rigid, linear paths that don't align with how I actually learn. I need to experiment with concepts, validate my understanding through practice, and test myself using methods that work for me, not through generic, pre-made quizzes that may not address my specific areas of confusion. This led to a fundamental question: What if I could take any learning material, PDFs, videos, audio files, my own notes and transform them into an interactive, personalized learning system that adapts to my learning style?

This personal struggle became the driving force behind MyTutor.

What I Learned

Building MyTutor provided deep insights across multiple technical domains:

1. Multi-Modal AI Systems Understanding how to effectively combine text, vision, and audio processing taught me that each modality requires distinct handling. A PDF textbook needs different processing logic than a video lecture or an educational screenshot. This realization led to the development of specialized agents, each optimized for specific content types, which improved extraction accuracy by 60% compared to generic processing approaches.

2. Asynchronous Architecture Python's async/await capabilities transformed how I approached concurrent processing. By processing multiple files simultaneously rather than sequentially.

3. Prompt Engineering Impact Generic prompts to AI models produce generic results. Structured prompts with specific instructions, examples, and JSON schemas improved AI output quality by approximately 80%. This taught me that the way you communicate with AI systems is as critical as the models themselves.

4. Rate Limiting and Graceful Degradation Cloud AI services impose strict usage limits. Designing for exponential backoff, retry logic with progressive delays (10s → 20s → 40s → 60s), and user-friendly error messaging became essential for reliability. This approach improved system stability from frequent failures to 95% reliability under load.

5. Full-Stack Integration Complexity Building frontend, backend, and AI layers revealed how different components interact and where bottlenecks emerge. Performance perception matters as much as actual performance. Users tolerate longer waits when provided with real-time progress feedback.

How I Built the Project

Architecture Design

MyTutor follows a three-tier architecture with clear separation of concerns:

Frontend Layer (React + TypeScript + Vite)

  • Built with TypeScript for compile-time type safety, catching over 100 potential bugs during development
  • Implemented real-time status tracking for multi-file uploads
  • Created an enhanced training interface with comprehensive analytics
  • Used Tailwind CSS for rapid UI iteration and consistent styling

Backend Layer (Python + FastAPI)

  • Designed async API endpoints to handle long-running file uploads without blocking
  • Implemented JWT-based authentication for secure, stateless sessions
  • Used Pydantic schemas for automatic request/response validation
  • Employed file-based persistence for rapid prototyping and deployment

AI Processing Layer (AWS Bedrock + AgentCore)

  • Integrated Claude 3.5 Sonnet for multi-modal understanding
  • Built specialized agents for different content types (PDF, Video, Audio, Image, Text)
  • Implemented local file-based storage to avoid API throttling
  • Created a two-phase question generation system for contextually relevant questions

Key Implementation Details

Multi-Agent Processing System Each uploaded file is routed to a specialized agent based on MIME type. The agents run concurrently using Python's asyncio, with results aggregated once all agents complete. This design reduced per-file processing time from approximately 5 minutes to 1.5 minutes.

Content Extraction Pipeline Different content types store data in different fields. I implemented a fallback chain that checks multiple possible field names (text → text_content → transcript → extracted_text → educational_content.full_text_content → analysis.ai_analysis). This ensures comprehensive extraction regardless of agent-specific response formats.

Adaptive Question Generation Rather than generating questions directly, the system first analyzes the knowledge base to extract learning objectives, key concepts, and topic areas. It then generates questions based on specific content chunks while adapting difficulty based on user performance history. This two-phase approach improved question relevance from 40% to 85%.

Production Deployment Created a production script that handles service orchestration, health monitoring, and automatic restarts. The script monitors all services every 10 seconds and automatically restarts crashed services up to 5 times before stopping. It supports both interactive and background execution modes for different deployment scenarios.

Challenges Faced and Overcome

Challenge 1: AWS Bedrock API Throttling

Problem: During testing and production use, AWS Bedrock aggressively throttled API requests. Training content generation would fail, users encountered errors, and the system felt unreliable.

Solution:

  • Migrated from AgentCore Memory (which required constant API calls) to local file-based storage
  • Eliminated unnecessary comprehensive analysis that made expensive AI calls but wasn't used
  • Implemented exponential backoff with retry logic (max delay: 60 seconds, max retries: 5)
  • Reduced Bedrock API calls by approximately 60%

Impact: System reliability improved from frequent throttling failures to 95% uptime under normal load conditions.

Challenge 2: Multi-Modal Content Extraction Accuracy

Problem: Using a single generic processing pipeline for all file types resulted in poor extraction quality. Text from images was missed, video content was inadequately analyzed, and PDF structure was lost.

Solution: Developed specialized agents with domain-specific logic:

  • PDF Agent: Maintains document structure, extracts tables and embedded images
  • Video Agent: Analyzes key frames, extracts visual content without requiring audio transcription
  • Audio Agent: Transcribes speech and identifies topical themes
  • Image Agent: Performs OCR, detects educational content in screenshots and diagrams
  • Text Agent: Applies NLP processing for articles and web content

Impact: Content extraction accuracy improved by 60%, with significantly better handling of complex educational materials like technical diagrams and code screenshots.

Challenge 3: Inconsistent Data Structures Across Agents

Problem: Different agents returned content in different field names, causing content retrieval to fail. For example, images used educational_content.full_text_content while videos used analysis.ai_analysis.

Solution: Implemented a comprehensive fallback chain in the content extraction logic that systematically checks all possible field names. Added empty-string validation to prevent false positives when fields exist but contain no data.

Impact: Eliminated content retrieval failures and ensured all processed content is accessible for training generation, regardless of which agent processed it.

Challenge 4: Generic AI-Generated Questions

Problem: Initial implementations used simple prompts like "Generate an MCQ question about this content." Results were disappointing—questions were vague, often irrelevant to the actual material, and didn't test meaningful understanding.

Solution: Redesigned the generation approach as a two-phase system:

  1. Content Analysis Phase: Extract learning objectives, identify key concepts, map topic areas, determine difficulty levels
  2. Contextual Generation Phase: Generate questions based on specific content chunks, include detailed explanations, adapt to user performance patterns

Impact: Question relevance improved from approximately 40% (mostly generic questions) to 85% (highly specific to actual content), significantly enhancing the training experience.

Challenge 5: Production Deployment and Monitoring

Problem: Running three separate services (AgentCore, Backend, Frontend) reliably on EC2 required proper orchestration, monitoring, and automatic recovery from crashes. Manual monitoring wasn't scalable.

Solution: Created a comprehensive production script that:

  • Handles initialization and startup of all services
  • Monitors process health every 10 seconds
  • Automatically restarts crashed services (up to 5 attempts)
  • Logs all events to dedicated monitor log
  • Supports both interactive and background execution modes
  • Aggressively cleans ports and processes before starting/restarting services

Impact: System now runs reliably on EC2 with automatic recovery from transient failures, reducing manual intervention requirements by approximately 90%.

Results and Impact

MyTutor successfully addresses the core problems that inspired its creation:

  • Course Selection Time: Reduced from 2+ hours of research to 15 minutes of automated processing
  • Learning Validation: Enabled self-testing using personally relevant materials rather than generic quizzes
  • Multi-Format Support: Processes PDFs, videos, audio, and images simultaneously
  • Adaptive Difficulty: Questions automatically adjust based on demonstrated proficiency
  • Processing Speed: Approximately 1.5 minutes per file with parallel processing
  • Content Accuracy: 85%+ extraction accuracy across all supported content types
  • System Reliability: 95% uptime with automatic recovery mechanisms

The project demonstrates that education technology should adapt to individual learning styles rather than forcing learners into rigid, one-size-fits-all formats. By enabling learners to transform any educational material into personalized training systems, MyTutor addresses a fundamental gap in how we approach online learning.

Built With

Share this project:

Updates