Repository navigation
Personalized Study Plan Generation
- Introduction
- System Architecture
- Core Components
- Weak and Strong Topic Analysis
- Resource Recommendation Algorithms
- Study Schedule Optimization
- JSON Response Parsing and Content Filtering
- Resource Categorization Logic
- Study Plan Generation Workflows
- Customization Options
- Learning Style Considerations
- Adaptive Recommendation Strategies
- Troubleshooting Guide
- Conclusion
The Personalized Study Plan Generation system is an AI-powered feature within the Master Plan educational platform that creates customized learning recommendations based on individual student performance data. This system leverages OpenAI's GPT-4o model to analyze test results, identify weak and strong topics, and generate actionable study plans with targeted resource recommendations.
The platform supports both student and teacher roles, providing personalized learning experiences while maintaining robust performance analytics and adaptive learning capabilities. The system integrates seamlessly with the existing chat-based AI tutor functionality and test management infrastructure.
The study plan generation system follows a client-server architecture with clear separation of concerns between the frontend React application and the Node.js backend services.
graph TB
subgraph "Client Layer"
SP[Study Plan Page]
AT[AI Tutor Interface]
UI[React Components]
end
subgraph "API Layer"
ROUTES[Express Routes]
AUTH[Authentication Middleware]
end
subgraph "Business Logic"
OPENAI[OpenAI Integration]
ANALYTICS[Test Performance Analysis]
STORAGE[MongoDB Storage]
end
subgraph "External Services"
GPT[GPT-4o API]
FIREBASE[Firebase Auth]
end
SP --> ROUTES
AT --> ROUTES
UI --> ROUTES
ROUTES --> OPENAI
ROUTES --> STORAGE
OPENAI --> GPT
ROUTES --> AUTH
AUTH --> FIREBASE
STORAGE --> MONGO[(MongoDB)]
Diagram sources
- server/index.ts
- server/routes.ts
- server/lib/openai.ts
The architecture ensures scalability through modular design, with clear boundaries between presentation, business logic, and data persistence layers.
The client-side implementation consists of a dedicated study plan page that handles user interaction and displays generated recommendations.
classDiagram
class StudyPlanPage {
+string testId
+StudyPlan studyPlan
+boolean isLoading
+handleGenerateStudyPlan()
+render()
}
class StudyPlan {
+string plan
+Resource[] resources
}
class Resource {
+string title
+string type
+string url
}
StudyPlanPage --> StudyPlan : "displays"
StudyPlan --> Resource : "contains"
Diagram sources
- client/src/pages/study-plan.tsx
The backend provides comprehensive APIs for study plan generation, performance analysis, and resource management through a unified Express.js server.
classDiagram
class StudyPlanAPI {
+generateStudyPlan()
+analyzeTestPerformance()
+evaluateSubjectiveAnswer()
+aiChat()
}
class OpenAIIntegration {
+OpenAI openai
+generateStudyPlan()
+analyzeTestPerformance()
+evaluateSubjectiveAnswer()
+aiChat()
}
class StorageLayer {
+MongoStorage storage
+createAnalytics()
+getAnalyticsByUser()
+getAnalyticsByTest()
}
StudyPlanAPI --> OpenAIIntegration : "uses"
StudyPlanAPI --> StorageLayer : "uses"
OpenAIIntegration --> OpenAI : "integrates with"
Diagram sources
- server/lib/openai.ts
- server/storage.ts
Section sources
- client/src/pages/study-plan.tsx
- server/lib/openai.ts
- server/storage.ts
The system performs comprehensive topic analysis by examining test performance data to identify areas requiring improvement and strengths to leverage.
flowchart TD
Start([Test Results Received]) --> ParseData["Parse Student Performance Data"]
ParseData --> ExtractTopics["Extract Topic Scores"]
ExtractTopics --> CalculateMetrics["Calculate Average Scores"]
CalculateMetrics --> IdentifyWeak["Identify Weak Topics"]
IdentifyWeak --> IdentifyStrong["Identify Strong Topics"]
IdentifyStrong --> GenerateInsights["Generate Learning Insights"]
GenerateInsights --> ReturnResults["Return Analysis Results"]
IdentifyWeak --> WeakFilter{"Score Below Threshold?"}
WeakFilter --> |Yes| AddWeak["Add to Weak Topics List"]
WeakFilter --> |No| CheckNext["Check Next Topic"]
IdentifyStrong --> StrongFilter{"Score Above Threshold?"}
StrongFilter --> |Yes| AddStrong["Add to Strong Topics List"]
StrongFilter --> |No| CheckNext
AddWeak --> CheckNext
AddStrong --> CheckNext
CheckNext --> GenerateInsights
Diagram sources
- server/lib/openai.ts
The analysis engine processes multiple aspects of student performance:
- Statistical Analysis: Calculates average scores, standard deviations, and percentile rankings
- Pattern Recognition: Identifies recurring mistakes and conceptual gaps
- Progress Tracking: Monitors improvement trends over time
- Comparative Analysis: Benchmarks individual performance against class averages
Section sources
- server/lib/openai.ts
- shared/schema.ts
The system employs sophisticated algorithms to recommend educational resources tailored to individual learning needs and preferences.
sequenceDiagram
participant Client as "Study Plan Page"
participant API as "Study Plan API"
participant Analyzer as "Topic Analyzer"
participant Recommender as "Resource Recommender"
participant Storage as "Resource Database"
Client->>API : POST /api/study-plan
API->>Analyzer : Analyze test performance
Analyzer->>Analyzer : Extract weak/strong topics
Analyzer->>Recommender : Provide topic analysis
Recommender->>Storage : Query relevant resources
Storage-->>Recommender : Return resource suggestions
Recommender->>API : Generate recommendations
API->>Client : Return study plan with resources
Diagram sources
- server/routes.ts
- server/lib/openai.ts
Resources are categorized using a multi-dimensional classification approach:
| Category | Subcategories | Examples |
|---|---|---|
| Format | Video, Article, Practice, Interactive | YouTube lectures, Khan Academy, Quizlet |
| Complexity | Beginner, Intermediate, Advanced | Foundation concepts, mixed difficulty, challenging problems |
| Learning Style | Visual, Auditory, Kinesthetic, Reading/Writing | Diagrams, podcasts, hands-on activities, textbooks |
| Duration | Short (5-15 min), Medium (15-30 min), Long (30+ min) | Quick reviews, comprehensive lessons, extended tutorials |
Section sources
- server/lib/openai.ts
- shared/schema.ts
The system generates optimized study schedules that balance learning objectives with practical time constraints and individual learning patterns.
flowchart TD
Input[Study Plan Input] --> AnalyzeTopics["Analyze Topic Complexity"]
AnalyzeTopics --> CalculateLoad["Calculate Study Load"]
CalculateLoad --> OptimizeDistribution["Optimize Topic Distribution"]
OptimizeDistribution --> ConsiderConstraints["Consider Time Constraints"]
ConsiderConstraints --> GenerateSchedule["Generate Study Schedule"]
GenerateSchedule --> ValidateFeasibility["Validate Schedule Feasibility"]
ValidateFeasibility --> ReturnSchedule["Return Optimized Schedule"]
AnalyzeTopics --> ComplexityCalc["Calculate Topic Difficulty"]
ComplexityCalc --> LoadCalc["Estimate Study Time"]
LoadCalc --> DistributionCalc["Determine Study Order"]
DistributionCalc --> ConstraintCheck["Check Availability"]
ConstraintCheck --> FeasibilityCheck["Verify Time Requirements"]
Diagram sources
- server/lib/openai.ts
The scheduling algorithm considers multiple factors to create effective study plans:
- Learning Curve: Allocates more time to complex topics
- Spaced Repetition: Distributes review sessions optimally
- Cognitive Load: Balances difficult subjects throughout the week
- Personal Preferences: Adapts to preferred study times and environments
- External Commitments: Respects existing schedule constraints
Section sources
- server/lib/openai.ts
The system implements robust JSON parsing mechanisms to handle AI-generated content and filter it according to predefined quality standards.
flowchart TD
RawResponse[Raw AI Response] --> ParseJSON["Parse JSON Response"]
ParseJSON --> ValidateStructure["Validate Response Structure"]
ValidateStructure --> ExtractFields["Extract Required Fields"]
ExtractFields --> FilterContent["Filter Content Quality"]
FilterContent --> ApplySafety["Apply Safety Filters"]
ApplySafety --> FormatOutput["Format for Display"]
FormatOutput --> ReturnResponse["Return Processed Response"]
ValidateStructure --> StructureValid{"Valid Structure?"}
StructureValid --> |No| ApplyFallback["Apply Fallback Response"]
StructureValid --> |Yes| ExtractFields
FilterContent --> QualityCheck["Check Content Quality"]
QualityCheck --> QualityPass{"Meets Standards?"}
QualityPass --> |No| CleanContent["Clean and Reformat"]
QualityPass --> |Yes| ApplySafety
ApplyFallback --> FormatOutput
CleanContent --> ApplySafety
Diagram sources
- server/lib/openai.ts
The system employs multiple layers of content filtering:
- JSON Validation: Ensures proper response format
- Field Verification: Confirms required fields are present
- Content Safety: Filters inappropriate or low-quality content
- Format Normalization: Converts content to safe HTML format
- Error Recovery: Provides fallback responses for malformed data
Section sources
- server/lib/openai.ts
The resource categorization system organizes educational materials based on multiple criteria to enable precise matching with learning objectives.
erDiagram
RESOURCE {
int id PK
string title
string description
string url
string format
string subject
string difficulty
string learning_style
int duration_minutes
string category
}
TOPIC {
int id PK
string name
string subject
string category
float difficulty_score
}
STUDENT_PROFILE {
int id PK
string learning_style
string preferred_subject
int study_hours_per_week
string time_availability
}
RECOMMENDATION {
int id PK
int student_id FK
int topic_id FK
int resource_id FK
float match_score
string recommendation_reason
}
RESOURCE ||--o{ RECOMMENDATION : "recommended_for"
TOPIC ||--o{ RECOMMENDATION : "matches"
STUDENT_PROFILE ||--o{ RECOMMENDATION : "generates"
Diagram sources
- shared/schema.ts
Resources are classified using comprehensive criteria:
- Educational Level: Aligns with grade level and skill proficiency
- Subject Alignment: Matches curriculum standards and learning objectives
- Learning Style Compatibility: Supports visual, auditory, or kinesthetic preferences
- Content Quality: Verified educational value and accuracy
- Accessibility: Considers disabilities and special needs requirements
Section sources
- shared/schema.ts
The system supports multiple pathways for generating personalized study plans based on different input scenarios and user needs.
flowchart TD
Start([User Initiates Study Plan]) --> ChooseInput["Choose Input Method"]
ChooseInput --> TestBased["Test-Based Analysis"]
ChooseInput --> SelfAssessment["Self-Assessment"]
ChooseInput --> GoalSetting["Goal-Based Planning"]
TestBased --> CollectTestData["Collect Test Data"]
CollectTestData --> AnalyzePerformance["Analyze Performance Metrics"]
AnalyzePerformance --> IdentifyGaps["Identify Knowledge Gaps"]
IdentifyGaps --> GeneratePlan["Generate Study Plan"]
SelfAssessment --> GatherPreferences["Gather Learning Preferences"]
GatherPreferences --> SetGoals["Set Learning Goals"]
SetGoals --> CreateCustomPlan["Create Custom Study Plan"]
GoalSetting --> DefineObjectives["Define Learning Objectives"]
DefineObjectives --> MapCurriculum["Map to Curriculum Standards"]
MapCurriculum --> BuildStructuredPlan["Build Structured Study Plan"]
GeneratePlan --> ReviewRecommendations["Review Resource Recommendations"]
CreateCustomPlan --> ReviewRecommendations
BuildStructuredPlan --> ReviewRecommendations
ReviewRecommendations --> FinalizePlan["Finalize and Present Plan"]
FinalizePlan --> End([Study Plan Complete])
Diagram sources
- client/src/pages/study-plan.tsx
- server/lib/openai.ts
The study plan generation integrates with existing platform features:
- Test Integration: Connects with test management system for performance data
- Analytics Integration: Leverages historical performance analytics
- Resource Integration: Accesses centralized resource database
- User Profile Integration: Incorporates learning style and preference data
Section sources
- client/src/pages/study-plan.tsx
- server/lib/openai.ts
The system provides extensive customization capabilities to accommodate diverse learning needs and preferences.
| Customization Area | Options | Benefits |
|---|---|---|
| Learning Style | Visual, Auditory, Reading/Writing, Kinesthetic | Optimizes content delivery method |
| Pacing | Fast, Standard, Slow | Accommodates different learning speeds |
| Difficulty Level | Beginner, Intermediate, Advanced | Matches current ability level |
| Time Commitment | 1-2 hours, 2-4 hours, 4+ hours | Fits into various schedules |
| Subject Focus | Mathematics, Science, Humanities, Languages | Targets specific areas of need |
The system dynamically adjusts recommendations based on:
- Performance Progress: Modifies difficulty and pacing based on improvement
- Engagement Patterns: Adjusts content variety based on interaction history
- Learning Spacing: Modifies review frequency based on retention data
- Content Preferences: Refines recommendations based on previously successful resources
Section sources
- server/lib/openai.ts
- shared/schema.ts
The system incorporates multiple learning style theories and adapts recommendations accordingly.
graph LR
subgraph "Learning Styles"
Visual[Visual Learners]
Auditory[Auditory Learners]
Kinesthetic[Kinesthetic Learners]
Reading[Reading/Writing Learners]
end
subgraph "Content Adaptation"
Videos[Video Content]
Audio[Audio Content]
Activities[Hands-On Activities]
Text[Text-Based Content]
end
subgraph "Recommendation Engine"
StyleDetector[Style Detection]
ContentMatcher[Content Matching]
PreferenceOptimizer[Preference Optimization]
end
Visual --> Videos
Auditory --> Audio
Kinesthetic --> Activities
Reading --> Text
StyleDetector --> ContentMatcher
ContentMatcher --> PreferenceOptimizer
Diagram sources
- server/lib/openai.ts
The system tailors content delivery based on identified learning styles:
- Visual Learners: Prefer diagrams, charts, video explanations, and visual examples
- Auditory Learners: Benefit from podcasts, discussions, verbal explanations, and music-based learning
- Kinesthetic Learners: Require hands-on activities, experiments, movement-based learning, and tactile materials
- Reading/Writing Learners: Excel with textbooks, articles, note-taking, and written exercises
Section sources
- server/lib/openai.ts
The system employs machine learning-inspired adaptation strategies to continuously improve recommendation quality based on user interaction and performance data.
sequenceDiagram
participant User as "User Interaction"
participant System as "Adaptive System"
participant MLModel as "Learning Model"
participant Database as "Recommendation Database"
User->>System : Engage with Recommendation
System->>MLModel : Analyze Engagement Data
MLModel->>Database : Query Similar Interactions
Database-->>MLModel : Return Pattern Data
MLModel->>System : Generate Improved Recommendation
System->>User : Present Enhanced Recommendation
User->>System : Rate/Interact with Recommendation
System->>MLModel : Update Model Parameters
MLModel->>Database : Store New Patterns
Diagram sources
- server/storage.ts
The system implements several adaptation strategies:
- Collaborative Filtering: Uses peer performance patterns to inform recommendations
- Content-Based Filtering: Matches resources based on topic similarity and learning objectives
- Hybrid Approaches: Combines multiple strategies for optimal recommendation quality
- Real-Time Learning: Updates recommendations based on immediate user feedback
The system tracks multiple metrics to measure recommendation effectiveness:
- Engagement Rates: Measures time spent on recommended resources
- Completion Rates: Tracks completion of suggested learning activities
- Performance Improvements: Monitors academic progress after following recommendations
- User Satisfaction: Collects explicit feedback on recommendation quality
Section sources
- server/storage.ts
- server/lib/openai.ts
Common issues and their resolutions when working with the study plan generation system.
Problem: Study plan generation fails with API errors
- Solution: Verify OPENAI_API_KEY environment variable is properly configured
- Check: Ensure network connectivity to OpenAI services
- Debug: Review server logs for specific error messages
Problem: JSON parsing errors in study plan responses
- Solution: Implement proper error handling and fallback mechanisms
- Check: Validate response format consistency
- Debug: Log raw API responses for analysis
Problem: Slow response times for study plan generation
- Solution: Implement caching for frequently accessed recommendations
- Check: Monitor OpenAI API latency and rate limits
- Optimize: Batch requests and implement request queuing
Problem: Inaccurate topic analysis results
- Solution: Validate test data quality and completeness
- Check: Ensure sufficient sample size for reliable analysis
- Debug: Review data preprocessing and normalization steps
Problem: Study plan content not displaying correctly
- Solution: Verify HTML sanitization and content rendering
- Check: Ensure proper state management for loading states
- Debug: Test cross-browser compatibility and responsiveness
Section sources
- server/lib/openai.ts
- client/src/pages/study-plan.tsx
The Personalized Study Plan Generation system represents a comprehensive approach to adaptive learning technology, combining advanced AI capabilities with robust educational pedagogy. The system successfully addresses the core challenge of creating individualized learning experiences while maintaining scalability and reliability.
Key achievements include:
- AI-Powered Personalization: Leveraging GPT-4o for intelligent study plan generation
- Comprehensive Analysis: Multi-dimensional topic analysis with statistical rigor
- Adaptive Recommendations: Machine learning-inspired continuous improvement
- Scalable Architecture: Modular design supporting future expansion
- User-Centric Design: Intuitive interfaces for both students and educators
The system provides a solid foundation for further enhancement, including expanded learning style support, integration with additional educational resources, and advanced analytics capabilities. Future developments could incorporate more sophisticated machine learning models, real-time performance monitoring, and enhanced collaborative learning features.