added gamification and evolution

src/learnbee/gamification.py

@@ -0,0 +1,190 @@
+"""Gamification system for tracking progress and rewarding achievements in learning sessions."""
+
+from typing import List, Dict, Tuple
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Badge:
+    """Represents an unlockable badge."""
+    name: str
+    emoji: str
+    description: str
+    requirement: int  # Number of stars needed
+
+
+# Define available badges
+BADGES = [
+    Badge("First Steps", "🎯", "Started your learning adventure!", 1),
+    Badge("Explorer", "🔍", "Asked 3 great questions!", 3),
+    Badge("Problem Solver", "🧩", "Solved 5 challenges!", 5),
+    Badge("Star Student", "⭐", "Earned 10 stars!", 10),
+    Badge("Creative Thinker", "🎨", "Showed amazing creativity!", 15),
+    Badge("Adventure Master", "🏆", "Completed the adventure!", 20),
+]
+
+
+class GamificationTracker:
+    """Tracks gamification progress for a learning session."""
+    
+    def __init__(self):
+        """Initialize a new gamification tracker."""
+        self.stars: int = 0
+        self.badges_unlocked: List[str] = []
+        self.achievements: List[Dict[str, str]] = []  # List of {reason, emoji, timestamp}
+        self.milestone_messages: List[str] = []
+        
+    def award_star(self, reason: str = "Great job!") -> Tuple[bool, str]:
+        """
+        Award a star to the child.
+        
+        Args:
+            reason: Why the star was awarded
+            
+        Returns:
+            Tuple of (badge_unlocked, message)
+        """
+        self.stars += 1
+        self.achievements.append({
+            "type": "star",
+            "reason": reason,
+            "emoji": "⭐"
+        })
+        
+        # Check for badge unlocks
+        badge_unlocked, badge_message = self._check_badge_unlock()
+        
+        return badge_unlocked, badge_message
+    
+    def _check_badge_unlock(self) -> Tuple[bool, str]:
+        """
+        Check if any badges should be unlocked based on current stars.
+        
+        Returns:
+            Tuple of (unlocked, message)
+        """
+        for badge in BADGES:
+            if badge.name not in self.badges_unlocked and self.stars >= badge.requirement:
+                self.badges_unlocked.append(badge.name)
+                message = f"🎉 Badge Unlocked: {badge.emoji} {badge.name} - {badge.description}"
+                self.milestone_messages.append(message)
+                return True, message
+        
+        return False, ""
+    
+    def get_progress_percentage(self, max_stars: int = 20) -> int:
+        """
+        Calculate progress percentage.
+        
+        Args:
+            max_stars: Maximum stars for the adventure (default 20)
+            
+        Returns:
+            Progress percentage (0-100)
+        """
+        return min(int((self.stars / max_stars) * 100), 100)
+    
+    def get_next_milestone(self) -> str:
+        """
+        Get the next milestone the child is working towards.
+        
+        Returns:
+            Description of next milestone
+        """
+        for badge in BADGES:
+            if badge.name not in self.badges_unlocked:
+                stars_needed = badge.requirement - self.stars
+                if stars_needed > 0:
+                    return f"{stars_needed} more star{'s' if stars_needed != 1 else ''} to unlock {badge.emoji} {badge.name}!"
+                
+        return "You've unlocked all badges! Amazing work! 🌟"
+    
+    def get_progress_html(self) -> str:
+        """
+        Generate HTML for displaying gamification progress.
+        
+        Returns:
+            HTML string with progress display
+        """
+        # Calculate progress
+        progress_pct = self.get_progress_percentage()
+        progress_bar_filled = int(progress_pct / 5)  # 20 blocks total
+        progress_bar_empty = 20 - progress_bar_filled
+        progress_bar = "█" * progress_bar_filled + "░" * progress_bar_empty
+        
+        # Generate star display (show up to 10 stars visually)
+        star_display = "⭐" * min(self.stars, 10)
+        if self.stars > 10:
+            star_display += f" +{self.stars - 10}"
+        
+        # Generate badges display (compact)
+        badges_html = ""
+        if self.badges_unlocked:
+            badge_items = []
+            for badge in BADGES:
+                if badge.name in self.badges_unlocked:
+                    badge_items.append(f"{badge.emoji} {badge.name}")
+            badges_html = " • ".join(badge_items[:3])  # Show max 3 badges
+            if len(self.badges_unlocked) > 3:
+                badges_html += f" +{len(self.badges_unlocked) - 3}"
+        else:
+            badges_html = "Keep learning to unlock badges!"
+        
+        # Get next milestone
+        next_milestone = self.get_next_milestone()
+        
+        # Build compact horizontal HTML
+        html = f"""
+        <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 16px 24px; border-radius: 12px; color: white; margin: 20px 0; box-shadow: 0 4px 12px rgba(102, 126, 234, 0.3);">
+            <div style="display: flex; align-items: center; justify-content: space-between; flex-wrap: wrap; gap: 20px;">
+                
+                <!-- Stars Section -->
+                <div style="display: flex; align-items: center; gap: 12px;">
+                    <div style="font-size: 1.2rem; font-weight: bold;">🌟 Progress</div>
+                    <div style="background: rgba(255,255,255,0.2); padding: 8px 16px; border-radius: 8px; font-size: 1rem;">
+                        {star_display} <span style="opacity: 0.9;">({self.stars} stars)</span>
+                    </div>
+                </div>
+                
+                <!-- Progress Bar Section -->
+                <div style="flex: 1; min-width: 200px; max-width: 300px;">
+                    <div style="background: rgba(0,0,0,0.2); border-radius: 10px; padding: 6px; font-family: monospace; font-size: 0.85rem; letter-spacing: 1px; text-align: center;">
+                        {progress_bar} {progress_pct}%
+                    </div>
+                </div>
+                
+                <!-- Badges Section -->
+                <div style="display: flex; align-items: center; gap: 12px;">
+                    <div style="font-weight: bold;">🏆</div>
+                    <div style="background: rgba(255,255,255,0.2); padding: 8px 16px; border-radius: 8px; font-size: 0.9rem;">
+                        {badges_html}
+                    </div>
+                </div>
+                
+                <!-- Next Milestone -->
+                <div style="background: rgba(255,255,255,0.25); padding: 8px 16px; border-radius: 8px; font-size: 0.9rem; font-weight: 500;">
+                    🎯 {next_milestone}
+                </div>
+                
+            </div>
+        </div>
+        """
+        
+        return html
+
+    
+    def get_celebration_message(self) -> str:
+        """
+        Get a celebration message if there are new achievements.
+        
+        Returns:
+            Celebration message or empty string
+        """
+        if self.milestone_messages:
+            message = self.milestone_messages[-1]
+            return message
+        return ""
+    
+    def clear_milestone_messages(self):
+        """Clear milestone messages after they've been displayed."""
+        self.milestone_messages.clear()

src/learnbee/llm_call.py

@@ -161,21 +161,22 @@ class LLMCall:
         concepts_text = ", ".join(concepts[:8])  # Show up to 8 concepts
         
         system_prompt = (
-            f"You are an educational expert creating an introduction for a lesson for children ages 3-12. "
+            f"You are an educational expert creating a warm, natural introduction for an interactive learning adventure for children ages 3-12. "
             f"IMPORTANT: You must write the ENTIRE introduction in {language}. "
-            f"Create a friendly, engaging introduction that includes:\n\n"
-            f"1. A brief, exciting summary of what the child will learn (2-3 sentences, very simple language)\n"
-            f"2. A list of the key concepts they'll explore\n"
-            f"3. 2-3 example questions that the tutor could ask to start the conversation and guide the child\n\n"
-            f"Format your response as follows:\n"
-            f"SUMMARY:\n"
-            f"[Brief summary here in {language}]\n\n"
-            f"KEY CONCEPTS:\n"
-            f"[List concepts here, one per line with a bullet point]\n\n"
-            f"EXAMPLE QUESTIONS TO GET STARTED:\n"
-            f"[2-3 engaging questions, one per line with a bullet point, in {language}]\n\n"
-            f"Use very simple, age-appropriate language in {language}. Make it fun and exciting! "
-            f"The questions should be open-ended and encourage exploration. "
+            f"Create a friendly, conversational introduction that:\n\n"
+            f"1. Explains what adventure/activity the child is about to experience (in natural, story-like language)\n"
+            f"2. Describes the child's role or task in this adventure (what they'll be doing)\n"
+            f"3. Ends with an engaging, open-ended question to start the conversation\n\n"
+            f"STYLE GUIDELINES:\n"
+            f"- Write in a warm, conversational tone (like a friend talking to the child)\n"
+            f"- Use simple, age-appropriate language in {language}\n"
+            f"- Make it exciting and inviting, not formal or structured\n"
+            f"- Don't use bullet points or structured lists - write in natural paragraphs\n"
+            f"- The question at the end should be specific to the adventure and encourage the child to share their thoughts\n"
+            f"- Keep it to 3-4 sentences total, then the question\n\n"
+            f"Example structure (but make it unique to the lesson):\n"
+            f"'Today we're going on [adventure description]! Your mission is to [child's task]. "
+            f"Along the way, we'll discover [what they'll learn]. So, [engaging question]?'\n\n"
             f"Everything must be written in {language}."
         )
 

src/learnbee/prompts.py

@@ -5,7 +5,8 @@ def generate_tutor_system_prompt(
     tutor_name: str,
     tutor_description: str,
     difficulty_level: str,
-    lesson_content: str
+    lesson_content: str,
+    adaptive_context: str = ""
 ) -> str:
     """
     Generate the system prompt for an educational tutor.
@@ -97,7 +98,18 @@ def generate_tutor_system_prompt(
         "====================\n"
         f"{lesson_content}\n"
         "====================\n\n"
-        
+    )
+    
+    # Add adaptive context if provided
+    if adaptive_context:
+        system_prompt += (
+            "ADAPTIVE PERSONALIZATION:\n"
+            "====================\n"
+            f"{adaptive_context}\n"
+            "====================\n\n"
+        )
+    
+    system_prompt += (
         "YOUR ROLE:\n"
         "You are teaching this lesson content through PROBLEMS AND QUESTIONS. Your job is to:\n"
         "1. Present engaging challenges based on the lesson\n"

src/learnbee/session_state.py

@@ -0,0 +1,175 @@
+"""Session state management for tracking child interactions and adaptive personalization."""
+
+from dataclasses import dataclass, field
+from typing import List, Dict
+
+
+@dataclass
+class SessionState:
+    """Tracks the state of a learning session for adaptive personalization."""
+    
+    # Interaction tracking
+    total_messages: int = 0
+    correct_answers: int = 0
+    incorrect_answers: int = 0
+    questions_asked_by_child: int = 0
+    
+    # Engagement metrics
+    short_responses: int = 0  # 1-5 words
+    detailed_responses: int = 0  # 6+ words
+    emoji_count: int = 0
+    exclamation_count: int = 0
+    
+    # Adaptive difficulty
+    current_difficulty_adjustment: str = "neutral"  # "easier", "neutral", "harder"
+    
+    # Topics explored
+    topics_discussed: List[str] = field(default_factory=list)
+    
+    # Gamification (will be used by GamificationTracker)
+    stars_earned: int = 0
+    badges_unlocked: List[str] = field(default_factory=list)
+    
+    def analyze_message(self, message: str) -> Dict[str, any]:
+        """
+        Analyze a child's message to extract engagement and comprehension signals.
+        
+        Args:
+            message: The child's message
+            
+        Returns:
+            Dictionary with analysis results
+        """
+        self.total_messages += 1
+        
+        # Count words
+        words = message.split()
+        word_count = len(words)
+        
+        # Track response length
+        if word_count <= 5:
+            self.short_responses += 1
+        else:
+            self.detailed_responses += 1
+        
+        # Count engagement markers
+        emoji_count = sum(1 for char in message if ord(char) > 127000)  # Simple emoji detection
+        exclamation_count = message.count('!')
+        question_count = message.count('?')
+        
+        self.emoji_count += emoji_count
+        self.exclamation_count += exclamation_count
+        
+        if question_count > 0:
+            self.questions_asked_by_child += 1
+        
+        # Calculate engagement level
+        engagement_score = 0
+        if word_count > 5:
+            engagement_score += 2
+        if emoji_count > 0:
+            engagement_score += 1
+        if exclamation_count > 0:
+            engagement_score += 1
+        if question_count > 0:
+            engagement_score += 2
+        
+        engagement_level = "low" if engagement_score < 2 else "medium" if engagement_score < 4 else "high"
+        
+        return {
+            "word_count": word_count,
+            "engagement_level": engagement_level,
+            "has_question": question_count > 0,
+            "has_emoji": emoji_count > 0,
+            "has_exclamation": exclamation_count > 0
+        }
+    
+    def record_answer_quality(self, is_correct: bool):
+        """
+        Record whether the child's answer was correct.
+        
+        Args:
+            is_correct: True if answer was correct, False otherwise
+        """
+        if is_correct:
+            self.correct_answers += 1
+        else:
+            self.incorrect_answers += 1
+        
+        # Update difficulty adjustment based on success rate
+        total_answers = self.correct_answers + self.incorrect_answers
+        if total_answers >= 3:  # Need at least 3 answers to adjust
+            success_rate = self.correct_answers / total_answers
+            
+            if success_rate < 0.4:
+                self.current_difficulty_adjustment = "easier"
+            elif success_rate > 0.8:
+                self.current_difficulty_adjustment = "harder"
+            else:
+                self.current_difficulty_adjustment = "neutral"
+    
+    def get_adaptive_context(self) -> str:
+        """
+        Generate adaptive context string for the system prompt.
+        
+        Returns:
+            String with adaptive instructions based on session state
+        """
+        context_parts = []
+        
+        # Difficulty adjustment
+        if self.current_difficulty_adjustment == "easier":
+            context_parts.append(
+                "ADAPTIVE INSTRUCTION: The child is struggling. Simplify your language, "
+                "break problems into smaller steps, and provide more hints and encouragement."
+            )
+        elif self.current_difficulty_adjustment == "harder":
+            context_parts.append(
+                "ADAPTIVE INSTRUCTION: The child is excelling! Increase the challenge, "
+                "ask deeper questions, and introduce more complex concepts."
+            )
+        
+        # Engagement adjustment
+        if self.total_messages >= 3:
+            engagement_ratio = self.detailed_responses / max(self.total_messages, 1)
+            
+            if engagement_ratio < 0.3:
+                context_parts.append(
+                    "ENGAGEMENT NOTE: The child is giving short responses. Make your questions "
+                    "more exciting, use more of your character's personality, and relate to their interests."
+                )
+            elif engagement_ratio > 0.7:
+                context_parts.append(
+                    "ENGAGEMENT NOTE: The child is highly engaged with detailed responses! "
+                    "Match their energy and enthusiasm. Present bonus challenges and celebrate their curiosity."
+                )
+        
+        # Question-asking behavior
+        if self.questions_asked_by_child >= 2:
+            context_parts.append(
+                "CURIOSITY NOTE: The child is asking great questions! Encourage this curiosity "
+                "and turn their questions into exciting learning opportunities."
+            )
+        
+        return "\n".join(context_parts) if context_parts else ""
+    
+    def get_session_summary(self) -> Dict[str, any]:
+        """
+        Get a summary of the current session state.
+        
+        Returns:
+            Dictionary with session statistics
+        """
+        total_answers = self.correct_answers + self.incorrect_answers
+        success_rate = (self.correct_answers / total_answers * 100) if total_answers > 0 else 0
+        
+        return {
+            "total_messages": self.total_messages,
+            "correct_answers": self.correct_answers,
+            "incorrect_answers": self.incorrect_answers,
+            "success_rate": success_rate,
+            "questions_asked": self.questions_asked_by_child,
+            "stars_earned": self.stars_earned,
+            "badges_unlocked": len(self.badges_unlocked),
+            "difficulty_adjustment": self.current_difficulty_adjustment
+        }

src/learnbee/tutor_handlers.py

@@ -9,6 +9,10 @@ from learnbee.mcp_server import create_lesson, get_lesson_content, get_lesson_li
 from learnbee.prompts import generate_tutor_system_prompt
 
 
+from learnbee.session_state import SessionState
+from learnbee.gamification import GamificationTracker
+
+
 def load_lesson_content(lesson_name, selected_tutor, selected_language, progress=gr.Progress()):
     """
     Load lesson content and extract key concepts.
@@ -73,8 +77,7 @@ def load_lesson_content(lesson_name, selected_tutor, selected_language, progress
                 # Format the introduction as a friendly greeting from the tutor
                 tutor_greeting = (
                     f"Hello! 👋 I'm {selected_tutor}, and I'm so excited to learn with you today!\n\n"
-                    f"{introduction}\n\n"
-                    f"Let's start our learning adventure! What would you like to explore first? 🌟"
+                    f"{introduction}\n"
                 )
                 chatbot_messages = [{"role": "assistant", "content": tutor_greeting}]
             else:
@@ -93,6 +96,9 @@ def load_lesson_content(lesson_name, selected_tutor, selected_language, progress
                 chatbot_messages,
                 gr.update(visible=False),  # Hide welcome card
                 gr.update(visible=True, value=status_message),  # Show status
+                SessionState(),  # Reset session state
+                GamificationTracker(),  # Reset gamification
+                gr.update(visible=True),  # Show gamification display
             )
         else:
             status_message = (
@@ -111,6 +117,9 @@ def load_lesson_content(lesson_name, selected_tutor, selected_language, progress
                 chatbot_messages,
                 gr.update(visible=False),  # Hide welcome card
                 gr.update(visible=True, value=status_message),  # Show status
+                SessionState(),  # Reset session state
+                GamificationTracker(),  # Reset gamification
+                gr.update(visible=True),  # Show gamification display
             )
     except Exception as e:
         status_message = (
@@ -129,6 +138,9 @@ def load_lesson_content(lesson_name, selected_tutor, selected_language, progress
             chatbot_messages,
             gr.update(visible=False),  # Hide welcome card
             gr.update(visible=True, value=status_message),  # Show status
+            SessionState(),  # Reset session state
+            GamificationTracker(),  # Reset gamification
+            gr.update(visible=True),  # Show gamification display
         )
 
 
@@ -157,6 +169,9 @@ def reset_chat_interface():
         gr.update(visible=False),  # Hide status
         [],
         gr.update(visible=True),  # Show welcome card
+        SessionState(),  # Reset session state
+        GamificationTracker(),  # Reset gamification
+        gr.update(visible=False),  # Hide gamification display
     )
 
 
@@ -218,11 +233,13 @@ def create_new_lesson(topic, lesson_name, age_range, progress=gr.Progress()):
     return result + lesson_content_preview, "", lesson_dropdown_update
 
 
+
 def custom_respond(
-    message, history, lesson_name, lesson_content, selected_tutor, difficulty_level
+    message, history, lesson_name, lesson_content, selected_tutor, difficulty_level,
+    session_state, gamification_tracker
 ):
     """
-    Custom respond function with educational system prompt.
+    Custom respond function with educational system prompt, adaptive personalization, and gamification.
     
     Args:
         message: User's message
@@ -231,32 +248,52 @@ def custom_respond(
         lesson_content: Content of the lesson
         selected_tutor: Name of the selected tutor
         difficulty_level: Difficulty level (beginner, intermediate, advanced)
+        session_state: SessionState object for tracking interactions
+        gamification_tracker: GamificationTracker object for progress tracking
     
     Yields:
-        Response chunks from the LLM
+        Tuple of (response, gamification_html)
     """
     if not lesson_name or not selected_tutor:
-        yield "Please select a lesson and tutor first."
+        yield "Please select a lesson and tutor first.", ""
         return
 
     if not lesson_content:
         lesson_content = get_lesson_content(lesson_name, LESSON_CONTENT_MAX_LENGTH)
 
+    # Analyze the child's message for adaptive personalization
+    message_analysis = session_state.analyze_message(message)
+    
+    # Award star for engagement (not on first message)
+    star_awarded = False
+    badge_message = ""
+    if session_state.total_messages > 1:  # Skip first message
+        # Award star based on engagement
+        if message_analysis["engagement_level"] in ["medium", "high"]:
+            star_awarded, badge_message = gamification_tracker.award_star("Great engagement!")
+        elif message_analysis["has_question"]:
+            star_awarded, badge_message = gamification_tracker.award_star("Excellent question!")
+    
     # Get tutor description
     tutor_description = get_tutor_description(selected_tutor)
     if not tutor_description:
         tutor_description = "a friendly and patient educational tutor"
 
-    # Generate educational system prompt with enhanced pedagogy focused on problem-solving
+    # Get adaptive context from session state
+    adaptive_context = session_state.get_adaptive_context()
+
+    # Generate educational system prompt with adaptive personalization
     system_prompt = generate_tutor_system_prompt(
         tutor_name=selected_tutor,
         tutor_description=tutor_description,
         difficulty_level=difficulty_level,
-        lesson_content=lesson_content
+        lesson_content=lesson_content,
+        adaptive_context=adaptive_context
     )
 
     # Call the respond method with educational system prompt
     call_llm = LLMCall()
+    response_text = ""
     for response in call_llm.respond(
         message, 
         history, 
@@ -264,5 +301,28 @@ def custom_respond(
         tutor_name=selected_tutor,
         difficulty_level=difficulty_level
     ):
-        yield response
+        response_text = response
+        # Generate updated gamification HTML
+        gamification_html = gamification_tracker.get_progress_html()
+        yield response, gamification_html
+    
+    # After response is complete, check if we should award additional stars
+    # (This is a simple heuristic - in production you might use LLM to evaluate)
+    if len(response_text) > 0:
+        # Award star if tutor gave positive feedback (heuristic: contains praise words)
+        praise_words = ["great", "excellent", "wonderful", "amazing", "perfect", "correct", "right", "good job"]
+        if any(word in response_text.lower() for word in praise_words):
+            # Record as correct answer
+            session_state.record_answer_quality(is_correct=True)
+            # Award star for correct answer
+            star_awarded, new_badge_message = gamification_tracker.award_star("Correct answer!")
+            if new_badge_message:
+                badge_message = new_badge_message
+        elif any(word in response_text.lower() for word in ["try again", "not quite", "almost", "let's think"]):
+            # Record as incorrect/partial answer
+            session_state.record_answer_quality(is_correct=False)
+    
+    # Final yield with updated gamification display
+    final_html = gamification_tracker.get_progress_html()
+    yield response_text, final_html
 

src/learnbee/ui.py

@@ -12,6 +12,8 @@ from learnbee.tutor_handlers import (
     create_new_lesson,
     custom_respond
 )
+from learnbee.session_state import SessionState
+from learnbee.gamification import GamificationTracker
 
 
 def create_gradio_ui():
@@ -23,6 +25,10 @@ def create_gradio_ui():
     """
     lesson_name = gr.BrowserState("")
     selected_tutor = gr.BrowserState(get_tutor_names()[0] if TUTOR_NAMES else "")
+    
+    # Session state for adaptive personalization
+    session_state_obj = gr.State(SessionState())
+    gamification_tracker_obj = gr.State(GamificationTracker())
 
     lesson_choices = json.loads(get_lesson_list())
 
@@ -169,7 +175,11 @@ def create_gradio_ui():
                     # Spacer where the multilingual card used to be (moved to footer)
                     with gr.Row():
                         gr.HTML('<div style="height:0.5rem;"></div>')
+            
+            # Define gamification display here (will be positioned in footer visually)
+            gamification_display = gr.HTML(visible=False, value="")
 
+            with gr.Row():
                 with gr.Column(scale=2):
                     # Chat interface - defined before use
                     chat_interface = gr.ChatInterface(
@@ -179,7 +189,10 @@ def create_gradio_ui():
                             lesson_content,
                             tutor_dropdown,
                             difficulty_dropdown,
+                            session_state_obj,
+                            gamification_tracker_obj,
                         ],
+                        additional_outputs=[gamification_display],
                         type="messages",
                         autofocus=False
                     )
@@ -195,6 +208,9 @@ def create_gradio_ui():
                             chat_interface.chatbot_value,
                             welcome_card,
                             status_markdown,
+                            session_state_obj,
+                            gamification_tracker_obj,
+                            gamification_display,
                         ],
                     )
 
@@ -210,6 +226,9 @@ def create_gradio_ui():
                             status_markdown,
                             chat_interface.chatbot_value,
                             welcome_card,
+                            session_state_obj,
+                            gamification_tracker_obj,
+                            gamification_display,
                         ],
                     )
                     

user_profile.json

@@ -0,0 +1,45 @@
+{
+    "name": "Explorer1",
+    "age": 6,
+    "interests": "Space, Animals, Magic",
+    "stars": 0,
+    "level": 1,
+    "badges": [
+        {
+            "id": "first_lesson",
+            "name": "First Step",
+            "description": "Complete your first lesson",
+            "icon": "\ud83c\udf31",
+            "unlocked": false
+        },
+        {
+            "id": "star_collector",
+            "name": "Star Collector",
+            "description": "Earn 10 stars",
+            "icon": "\u2b50",
+            "unlocked": false
+        },
+        {
+            "id": "curious_mind",
+            "name": "Curious Mind",
+            "description": "Ask 5 questions",
+            "icon": "\ud83d\udd0d",
+            "unlocked": false
+        },
+        {
+            "id": "super_learner",
+            "name": "Super Learner",
+            "description": "Complete 5 lessons",
+            "icon": "\ud83d\ude80",
+            "unlocked": false
+        },
+        {
+            "id": "creative_artist",
+            "name": "Creative Artist",
+            "description": "Generate an image",
+            "icon": "\ud83c\udfa8",
+            "unlocked": false
+        }
+    ],
+    "completed_lessons": []
+}