Implement Lesson Practice 2 Agent with state management and routing logic; add practice and teaching agent functions; create prompts for conversation and teaching; establish pronunciation API with lesson data and search functionality.

.gitattributes

@@ -51,4 +51,5 @@ data_test
 **.tiff
 **.webp
 **.svg
-.serena
+.serena
+*.wav filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -20,4 +20,4 @@ data_test
 **.webp
 **.svg
 .serena
-**.onnx
+**.onnxoutput.wav

src/agents/{lesson_practice_2 → lesson_practice}/flow.py

@@ -45,4 +45,4 @@ class LessonPractice2Agent:
         return graph.compile(checkpointer=checkpointer)
 
 
-lesson_practice_2_agent = LessonPractice2Agent()
+lesson_practice_agent = LessonPractice2Agent()

src/apis/create_app.py

@@ -4,6 +4,7 @@ from src.apis.routes.user_route import router as router_user
 from src.apis.routes.chat_route import router as router_chat
 from src.apis.routes.lesson_route import router as router_lesson
 from src.apis.routes.evaluation_route import router as router_evaluation
+from src.apis.routes.pronunciation_route import router as router_pronunciation
 from src.apis.routes.speaking_route import router as router_speaking
 
 api_router = APIRouter(prefix="/api")
@@ -11,6 +12,7 @@ api_router.include_router(router_user)
 api_router.include_router(router_chat)
 api_router.include_router(router_lesson)
 api_router.include_router(router_evaluation)
+api_router.include_router(router_pronunciation)
 api_router.include_router(router_speaking)
 
 
@@ -25,4 +27,4 @@ def create_app():
         allow_headers=["*"],
     )
 
-    return app
+    return app

src/apis/routes/lesson_route.py

@@ -13,7 +13,7 @@ from src.utils.logger import logger
 from src.services.tts_service import tts_service
 from pydantic import BaseModel, Field
 from typing import List, Dict, Any, Optional
-from src.agents.lesson_practice_2.flow import lesson_practice_2_agent
+from src.agents.lesson_practice.flow import lesson_practice_agent
 from src.apis.models.lesson_models import Lesson, LessonResponse, LessonDetailResponse
 import json
 import os
@@ -228,7 +228,7 @@ async def chat(
     message = {"role": "user", "content": message_content}
 
     try:
-        response = await lesson_practice_2_agent().ainvoke(
+        response = await lesson_practice_agent().ainvoke(
             {
                 "messages": [message],
                 "unit": lesson_dict.get("unit", ""),
@@ -342,7 +342,7 @@ async def chat_stream(
             }
             config = {"configurable": {"thread_id": session_id}}
 
-            async for event in lesson_practice_2_agent().astream(
+            async for event in lesson_practice_agent().astream(
                 input=input_graph,
                 stream_mode=["messages"],
                 config=config,

src/apis/routes/pronunciation_route.py

@@ -0,0 +1,217 @@
+from fastapi import APIRouter, HTTPException, status
+from fastapi.responses import JSONResponse
+from src.utils.logger import logger
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+import json
+import os
+
+router = APIRouter(prefix="/pronunciation", tags=["Pronunciation"])
+
+
+class Level(BaseModel):
+    id: str
+    name: str
+    description: str
+    color: str
+
+
+class Vocabulary(BaseModel):
+    word: str
+    ipa: str
+    vietnamese: str
+    audioUrl: str
+
+
+class Sentence(BaseModel):
+    text: str
+    ipa: str
+    vietnamese: str
+    audioUrl: str
+
+
+class PronunciationLesson(BaseModel):
+    id: str
+    title: str
+    description: str
+    level: str
+    vocabulary: List[Vocabulary]
+    sentence: Sentence
+
+
+class LevelsResponse(BaseModel):
+    levels: List[Level]
+    total: int
+
+
+class LessonsResponse(BaseModel):
+    lessons: List[PronunciationLesson]
+    total: int
+    level: str
+
+
+class LessonDetailResponse(BaseModel):
+    lesson: PronunciationLesson
+
+
+def load_pronunciation_data() -> Dict[str, Any]:
+    """Load pronunciation lessons data from JSON file"""
+    try:
+        data_file_path = os.path.join(
+            os.path.dirname(__file__), "..", "..", "data", "pronunciation_lessons.json"
+        )
+
+        if not os.path.exists(data_file_path):
+            logger.warning(f"Pronunciation lessons file not found at {data_file_path}")
+            return {"levels": [], "lessons": {}}
+
+        with open(data_file_path, "r", encoding="utf-8") as file:
+            data = json.load(file)
+
+        return data
+    except Exception as e:
+        logger.error(f"Error loading pronunciation lessons data: {str(e)}")
+        return {"levels": [], "lessons": {}}
+
+
+@router.get("/levels", response_model=LevelsResponse)
+async def get_levels():
+    """
+    Get all available levels for pronunciation practice
+    
+    Returns:
+        LevelsResponse: Contains list of all levels and total count
+    """
+    try:
+        data = load_pronunciation_data()
+        levels_data = data.get("levels", [])
+        
+        levels = [Level(**level_data) for level_data in levels_data]
+        
+        return LevelsResponse(levels=levels, total=len(levels))
+    except Exception as e:
+        logger.error(f"Error retrieving levels: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve levels",
+        )
+
+
+@router.get("/lessons/{level_id}", response_model=LessonsResponse)
+async def get_lessons_by_level(level_id: str):
+    """
+    Get all lessons for a specific level
+    
+    Args:
+        level_id (str): The level ID (beginner, elementary, etc.)
+        
+    Returns:
+        LessonsResponse: Contains list of lessons for the specified level
+    """
+    try:
+        data = load_pronunciation_data()
+        lessons_data = data.get("lessons", {})
+        
+        if level_id not in lessons_data:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Level '{level_id}' not found",
+            )
+        
+        level_lessons = lessons_data[level_id]
+        lessons = [PronunciationLesson(**lesson_data) for lesson_data in level_lessons]
+        
+        return LessonsResponse(lessons=lessons, total=len(lessons), level=level_id)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error retrieving lessons for level {level_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve lessons",
+        )
+
+
+@router.get("/lesson/{lesson_id}", response_model=LessonDetailResponse)
+async def get_lesson_detail(lesson_id: str):
+    """
+    Get detailed information about a specific lesson
+    
+    Args:
+        lesson_id (str): The unique identifier of the lesson
+        
+    Returns:
+        LessonDetailResponse: Contains the lesson details
+    """
+    try:
+        data = load_pronunciation_data()
+        lessons_data = data.get("lessons", {})
+        
+        # Search for the lesson across all levels
+        found_lesson = None
+        for level_id, level_lessons in lessons_data.items():
+            for lesson_data in level_lessons:
+                if lesson_data.get("id") == lesson_id:
+                    found_lesson = lesson_data
+                    break
+            if found_lesson:
+                break
+        
+        if not found_lesson:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Lesson with ID '{lesson_id}' not found",
+            )
+        
+        lesson = PronunciationLesson(**found_lesson)
+        
+        return LessonDetailResponse(lesson=lesson)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error retrieving lesson {lesson_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve lesson",
+        )
+
+
+@router.get("/search/level/{level_id}/title/{title}")
+async def search_lessons_by_title(level_id: str, title: str):
+    """
+    Search lessons by title within a specific level
+    
+    Args:
+        level_id (str): The level ID to search within
+        title (str): Part of the lesson title to search for
+        
+    Returns:
+        LessonsResponse: Contains list of matching lessons
+    """
+    try:
+        data = load_pronunciation_data()
+        lessons_data = data.get("lessons", {})
+        
+        if level_id not in lessons_data:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Level '{level_id}' not found",
+            )
+        
+        level_lessons = lessons_data[level_id]
+        matching_lessons = [
+            lesson_data for lesson_data in level_lessons
+            if title.lower() in lesson_data.get("title", "").lower()
+        ]
+        
+        lessons = [PronunciationLesson(**lesson_data) for lesson_data in matching_lessons]
+        
+        return LessonsResponse(lessons=lessons, total=len(lessons), level=level_id)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error searching lessons by title '{title}' in level {level_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to search lessons",
+        )

src/apis/routes/speaking_route.py

@@ -1,6 +1,6 @@
 from fastapi import UploadFile, File, Form, HTTPException, APIRouter
 from pydantic import BaseModel
-from typing import List, Dict
+from typing import List, Dict, Optional, Optional
 import tempfile
 import numpy as np
 import re
@@ -15,13 +15,16 @@ from src.utils.speaking_utils import convert_numpy_types
 
 warnings.filterwarnings("ignore")
 
-router = APIRouter(prefix="/pronunciation", tags=["Pronunciation"])
+router = APIRouter(prefix="/speaking", tags=["Speaking"])
 
 
 class PronunciationAssessmentResult(BaseModel):
     transcript: str  # What the user actually said (character transcript)
     transcript_phonemes: str  # User's phonemes
     user_phonemes: str  # Alias for transcript_phonemes for UI clarity
+    user_ipa: Optional[str]  # User's IPA notation
+    reference_ipa: str  # Reference IPA notation
+    reference_phonemes: str  # Reference phonemes
     character_transcript: str
     overall_score: float
     word_highlights: List[Dict]
@@ -36,7 +39,7 @@ assessor = SimplePronunciationAssessor()
 
 @router.post("/assess", response_model=PronunciationAssessmentResult)
 async def assess_pronunciation(
-    audio: UploadFile = File(..., description="Audio file (.wav, .mp3, .m4a)"),
+    audio_file: UploadFile = File(..., description="Audio file (.wav, .mp3, .m4a)"),
     reference_text: str = Form(..., description="Reference text to pronounce"),
     mode: str = Form(
         "normal",
@@ -86,13 +89,13 @@ async def assess_pronunciation(
     try:
         # Save uploaded file temporarily
         file_extension = ".wav"
-        if audio.filename and "." in audio.filename:
-            file_extension = f".{audio.filename.split('.')[-1]}"
+        if audio_file.filename and "." in audio_file.filename:
+            file_extension = f".{audio_file.filename.split('.')[-1]}"
 
         with tempfile.NamedTemporaryFile(
             delete=False, suffix=file_extension
         ) as tmp_file:
-            content = await audio.read()
+            content = await audio_file.read()
             tmp_file.write(content)
             tmp_file.flush()
 
@@ -101,6 +104,47 @@ async def assess_pronunciation(
             # Run assessment using selected mode
             result = assessor.assess_pronunciation(tmp_file.name, reference_text, mode)
 
+        # Get reference phonemes and IPA
+        g2p = SimpleG2P()
+        reference_words = reference_text.strip().split()
+        reference_phonemes_list = []
+        reference_ipa_list = []
+        
+        for word in reference_words:
+            word_phonemes = g2p.text_to_phonemes(word.strip('.,!?;:'))[0]
+            reference_phonemes_list.append(word_phonemes["phoneme_string"])
+            reference_ipa_list.append(word_phonemes["ipa"])
+        
+        # Join phonemes and IPA for the full text
+        result["reference_phonemes"] = " ".join(reference_phonemes_list)
+        result["reference_ipa"] = " ".join(reference_ipa_list)
+        
+        # Create user_ipa from transcript using G2P (same way as reference)
+        if "transcript" in result and result["transcript"]:
+            try:
+                user_transcript = result["transcript"].strip()
+                user_words = user_transcript.split()
+                user_ipa_list = []
+                
+                for word in user_words:
+                    clean_word = word.strip('.,!?;:').lower()
+                    if clean_word:  # Skip empty words
+                        try:
+                            word_phonemes = g2p.text_to_phonemes(clean_word)[0]
+                            user_ipa_list.append(word_phonemes["ipa"])
+                        except Exception as e:
+                            logger.warning(f"Failed to get IPA for word '{clean_word}': {e}")
+                            # Fallback: use the word itself
+                            user_ipa_list.append(f"/{clean_word}/")
+                
+                result["user_ipa"] = " ".join(user_ipa_list) if user_ipa_list else None
+                logger.info(f"Generated user IPA from transcript '{user_transcript}': '{result['user_ipa']}'")
+            except Exception as e:
+                logger.warning(f"Failed to generate user IPA from transcript: {e}")
+                result["user_ipa"] = None
+        else:
+            result["user_ipa"] = None
+
         # Add processing time
         processing_time = time.time() - start_time
         result["processing_info"]["processing_time"] = processing_time
@@ -128,7 +172,7 @@ async def assess_pronunciation(
 
 
 @router.get("/phonemes/{word}")
-async def get_word_phonemes(word: str):
+def get_word_phonemes(word: str):
     """Get phoneme breakdown for a specific word"""
     try:
         g2p = SimpleG2P()

src/data/pronunciation_lessons.json

@@ -0,0 +1,490 @@
+{
+  "levels": [
+    {
+      "id": "beginner",
+      "name": "Beginner",
+      "description": "Basic vocabulary and pronunciation for beginners",
+      "color": "#22c55e"
+    },
+    {
+      "id": "elementary",
+      "name": "Elementary", 
+      "description": "Elementary level vocabulary building",
+      "color": "#3b82f6"
+    },
+    {
+      "id": "pre-intermediate",
+      "name": "Pre-Intermediate",
+      "description": "Pre-intermediate vocabulary and expressions",
+      "color": "#f59e0b"
+    },
+    {
+      "id": "upper-intermediate", 
+      "name": "Upper-Intermediate",
+      "description": "Upper-intermediate complex vocabulary",
+      "color": "#f97316"
+    },
+    {
+      "id": "advanced",
+      "name": "Advanced",
+      "description": "Advanced vocabulary and pronunciation patterns",
+      "color": "#ef4444"
+    }
+  ],
+  "lessons": {
+    "beginner": [
+      {
+        "id": "beginner_1",
+        "title": "Basic Greetings",
+        "description": "Learn how to greet people in English",
+        "level": "beginner",
+        "vocabulary": [
+          {
+            "word": "hello",
+            "ipa": "/həˈloʊ/",
+            "vietnamese": "xin chào",
+            "audioUrl": "/api/tts/hello"
+          },
+          {
+            "word": "goodbye", 
+            "ipa": "/ɡʊdˈbaɪ/",
+            "vietnamese": "tạm biệt",
+            "audioUrl": "/api/tts/goodbye"
+          },
+          {
+            "word": "thank",
+            "ipa": "/θæŋk/",
+            "vietnamese": "cảm ơn",
+            "audioUrl": "/api/tts/thank"
+          },
+          {
+            "word": "please",
+            "ipa": "/pliːz/",
+            "vietnamese": "xin lỗi/làm ơn",
+            "audioUrl": "/api/tts/please"
+          },
+          {
+            "word": "sorry",
+            "ipa": "/ˈsɔːri/",
+            "vietnamese": "xin lỗi",
+            "audioUrl": "/api/tts/sorry"
+          },
+          {
+            "word": "excuse",
+            "ipa": "/ɪkˈskjuːz/",
+            "vietnamese": "xin lỗi/thứ lỗi",
+            "audioUrl": "/api/tts/excuse"
+          },
+          {
+            "word": "morning",
+            "ipa": "/ˈmɔːrnɪŋ/",
+            "vietnamese": "buổi sáng",
+            "audioUrl": "/api/tts/morning"
+          },
+          {
+            "word": "evening",
+            "ipa": "/ˈiːvnɪŋ/",
+            "vietnamese": "buổi tối",
+            "audioUrl": "/api/tts/evening"
+          },
+          {
+            "word": "night",
+            "ipa": "/naɪt/",
+            "vietnamese": "đêm",
+            "audioUrl": "/api/tts/night"
+          },
+          {
+            "word": "welcome",
+            "ipa": "/ˈwelkəm/",
+            "vietnamese": "chào mừng",
+            "audioUrl": "/api/tts/welcome"
+          }
+        ],
+        "sentence": {
+          "text": "Hello, good morning! Thank you very much.",
+          "ipa": "/həˈloʊ ɡʊd ˈmɔːrnɪŋ θæŋk juː ˈveri mʌtʃ/",
+          "vietnamese": "Xin chào, chào buổi sáng! Cảm ơn rất nhiều.",
+          "audioUrl": "/api/tts/hello-good-morning-thank-you-very-much"
+        }
+      },
+      {
+        "id": "beginner_2", 
+        "title": "Family Members",
+        "description": "Learn family vocabulary and pronunciation",
+        "level": "beginner",
+        "vocabulary": [
+          {
+            "word": "family",
+            "ipa": "/ˈfæməli/",
+            "vietnamese": "gia đình",
+            "audioUrl": "/api/tts/family"
+          },
+          {
+            "word": "mother",
+            "ipa": "/ˈmʌðər/", 
+            "vietnamese": "mẹ",
+            "audioUrl": "/api/tts/mother"
+          },
+          {
+            "word": "father",
+            "ipa": "/ˈfɑːðər/",
+            "vietnamese": "bố",
+            "audioUrl": "/api/tts/father"
+          },
+          {
+            "word": "sister",
+            "ipa": "/ˈsɪstər/",
+            "vietnamese": "chị/em gái",
+            "audioUrl": "/api/tts/sister"
+          },
+          {
+            "word": "brother",
+            "ipa": "/ˈbrʌðər/",
+            "vietnamese": "anh/em trai",
+            "audioUrl": "/api/tts/brother"
+          },
+          {
+            "word": "child",
+            "ipa": "/tʃaɪld/",
+            "vietnamese": "đứa trẻ",
+            "audioUrl": "/api/tts/child"
+          },
+          {
+            "word": "parent",
+            "ipa": "/ˈperənt/",
+            "vietnamese": "cha mẹ",
+            "audioUrl": "/api/tts/parent"
+          },
+          {
+            "word": "baby",
+            "ipa": "/ˈbeɪbi/",
+            "vietnamese": "em bé",
+            "audioUrl": "/api/tts/baby"
+          },
+          {
+            "word": "wife",
+            "ipa": "/waɪf/",
+            "vietnamese": "vợ",
+            "audioUrl": "/api/tts/wife"
+          },
+          {
+            "word": "husband",
+            "ipa": "/ˈhʌzbənd/",
+            "vietnamese": "chồng",
+            "audioUrl": "/api/tts/husband"
+          }
+        ],
+        "sentence": {
+          "text": "My family has a mother, father, sister and brother.",
+          "ipa": "/maɪ ˈfæməli hæz ə ˈmʌðər ˈfɑːðər ˈsɪstər ænd ˈbrʌðər/",
+          "vietnamese": "Gia đình tôi có mẹ, bố, chị gái và anh trai.",
+          "audioUrl": "/api/tts/my-family-has-a-mother-father-sister-and-brother"
+        }
+      }
+    ],
+    "elementary": [
+      {
+        "id": "elementary_1",
+        "title": "Daily Activities",
+        "description": "Learn vocabulary for daily activities",
+        "level": "elementary",
+        "vocabulary": [
+          {
+            "word": "breakfast",
+            "ipa": "/ˈbrekfəst/",
+            "vietnamese": "bữa sáng",
+            "audioUrl": "/api/tts/breakfast"
+          },
+          {
+            "word": "lunch",
+            "ipa": "/lʌntʃ/",
+            "vietnamese": "bữa trưa",
+            "audioUrl": "/api/tts/lunch"
+          },
+          {
+            "word": "dinner",
+            "ipa": "/ˈdɪnər/",
+            "vietnamese": "bữa tối",
+            "audioUrl": "/api/tts/dinner"
+          },
+          {
+            "word": "school",
+            "ipa": "/skuːl/",
+            "vietnamese": "trường học",
+            "audioUrl": "/api/tts/school"
+          },
+          {
+            "word": "work",
+            "ipa": "/wɜːrk/",
+            "vietnamese": "làm việc",
+            "audioUrl": "/api/tts/work"
+          },
+          {
+            "word": "exercise",
+            "ipa": "/ˈeksərsaɪz/",
+            "vietnamese": "tập thể dục",
+            "audioUrl": "/api/tts/exercise"
+          },
+          {
+            "word": "sleep",
+            "ipa": "/sliːp/",
+            "vietnamese": "ngủ",
+            "audioUrl": "/api/tts/sleep"
+          },
+          {
+            "word": "study",
+            "ipa": "/ˈstʌdi/",
+            "vietnamese": "học tập",
+            "audioUrl": "/api/tts/study"
+          },
+          {
+            "word": "homework",
+            "ipa": "/ˈhoʊmwɜːrk/",
+            "vietnamese": "bài tập về nhà",
+            "audioUrl": "/api/tts/homework"
+          },
+          {
+            "word": "television",
+            "ipa": "/ˈtelɪvɪʒn/",
+            "vietnamese": "ti vi",
+            "audioUrl": "/api/tts/television"
+          }
+        ],
+        "sentence": {
+          "text": "I eat breakfast, go to school, and do my homework every day.",
+          "ipa": "/aɪ iːt ˈbrekfəst ɡoʊ tuː skuːl ænd duː maɪ ˈhoʊmwɜːrk ˈevri deɪ/",
+          "vietnamese": "Tôi ăn sáng, đi học và làm bài tập về nhà mỗi ngày.",
+          "audioUrl": "/api/tts/i-eat-breakfast-go-to-school-and-do-my-homework-every-day"
+        }
+      }
+    ],
+    "pre-intermediate": [
+      {
+        "id": "pre_intermediate_1",
+        "title": "Travel & Transportation",
+        "description": "Learn travel-related vocabulary",
+        "level": "pre-intermediate",
+        "vocabulary": [
+          {
+            "word": "airport",
+            "ipa": "/ˈerˌpɔːrt/",
+            "vietnamese": "sân bay",
+            "audioUrl": "/api/tts/airport"
+          },
+          {
+            "word": "passport",
+            "ipa": "/ˈpæspɔːrt/",
+            "vietnamese": "hộ chiếu",
+            "audioUrl": "/api/tts/passport"
+          },
+          {
+            "word": "luggage",
+            "ipa": "/ˈlʌɡɪdʒ/",
+            "vietnamese": "hành lý",
+            "audioUrl": "/api/tts/luggage"
+          },
+          {
+            "word": "ticket",
+            "ipa": "/ˈtɪkɪt/",
+            "vietnamese": "vé",
+            "audioUrl": "/api/tts/ticket"
+          },
+          {
+            "word": "destination",
+            "ipa": "/ˌdestɪˈneɪʃn/",
+            "vietnamese": "điểm đến",
+            "audioUrl": "/api/tts/destination"
+          },
+          {
+            "word": "journey",
+            "ipa": "/ˈdʒɜːrni/",
+            "vietnamese": "hành trình",
+            "audioUrl": "/api/tts/journey"
+          },
+          {
+            "word": "adventure",
+            "ipa": "/ədˈventʃər/",
+            "vietnamese": "phiêu lưu",
+            "audioUrl": "/api/tts/adventure"
+          },
+          {
+            "word": "reservation",
+            "ipa": "/ˌrezərˈveɪʃn/",
+            "vietnamese": "đặt chỗ",
+            "audioUrl": "/api/tts/reservation"
+          },
+          {
+            "word": "accommodation",
+            "ipa": "/əˌkɑːməˈdeɪʃn/",
+            "vietnamese": "chỗ ở",
+            "audioUrl": "/api/tts/accommodation"
+          },
+          {
+            "word": "schedule",
+            "ipa": "/ˈskedʒuːl/",
+            "vietnamese": "lịch trình",
+            "audioUrl": "/api/tts/schedule"
+          }
+        ],
+        "sentence": {
+          "text": "I need to check my passport and luggage before the journey to my destination.",
+          "ipa": "/aɪ niːd tuː tʃek maɪ ˈpæspɔːrt ænd ˈlʌɡɪdʒ bɪˈfɔːr ðə ˈdʒɜːrni tuː maɪ ˌdestɪˈneɪʃn/",
+          "vietnamese": "Tôi cần kiểm tra hộ chiếu và hành lý trước chuyến đi đến điểm đến của mình.",
+          "audioUrl": "/api/tts/i-need-to-check-my-passport-and-luggage-before-the-journey-to-my-destination"
+        }
+      }
+    ],
+    "upper-intermediate": [
+      {
+        "id": "upper_intermediate_1",
+        "title": "Business & Professional",
+        "description": "Learn business and professional vocabulary",
+        "level": "upper-intermediate",
+        "vocabulary": [
+          {
+            "word": "presentation",
+            "ipa": "/ˌpriːzenˈteɪʃn/",
+            "vietnamese": "bài thuyết trình",
+            "audioUrl": "/api/tts/presentation"
+          },
+          {
+            "word": "negotiation",
+            "ipa": "/nɪˌɡoʊʃiˈeɪʃn/",
+            "vietnamese": "đàm phán",
+            "audioUrl": "/api/tts/negotiation"
+          },
+          {
+            "word": "collaboration",
+            "ipa": "/kəˌlæbəˈreɪʃn/",
+            "vietnamese": "hợp tác",
+            "audioUrl": "/api/tts/collaboration"
+          },
+          {
+            "word": "achievement",
+            "ipa": "/əˈtʃiːvmənt/",
+            "vietnamese": "thành tựu",
+            "audioUrl": "/api/tts/achievement"
+          },
+          {
+            "word": "responsibility",
+            "ipa": "/rɪˌspɑːnsəˈbɪləti/",
+            "vietnamese": "trách nhiệm",
+            "audioUrl": "/api/tts/responsibility"
+          },
+          {
+            "word": "opportunity",
+            "ipa": "/ˌɑːpərˈtuːnəti/",
+            "vietnamese": "cơ hội",
+            "audioUrl": "/api/tts/opportunity"
+          },
+          {
+            "word": "efficiency",
+            "ipa": "/ɪˈfɪʃnsi/",
+            "vietnamese": "hiệu quả",
+            "audioUrl": "/api/tts/efficiency"
+          },
+          {
+            "word": "innovation",
+            "ipa": "/ˌɪnəˈveɪʃn/",
+            "vietnamese": "đổi mới",
+            "audioUrl": "/api/tts/innovation"
+          },
+          {
+            "word": "development",
+            "ipa": "/dɪˈveləpmənt/",
+            "vietnamese": "phát triển",
+            "audioUrl": "/api/tts/development"
+          },
+          {
+            "word": "implementation",
+            "ipa": "/ˌɪmplɪmenˈteɪʃn/",
+            "vietnamese": "thực hiện",
+            "audioUrl": "/api/tts/implementation"
+          }
+        ],
+        "sentence": {
+          "text": "Successful collaboration and innovation lead to efficient implementation of business development strategies.",
+          "ipa": "/səkˈsesfl kəˌlæbəˈreɪʃn ænd ˌɪnəˈveɪʃn liːd tuː ɪˈfɪʃnt ˌɪmplɪmenˈteɪʃn ʌv ˈbɪznəs dɪˈveləpmənt ˈstrætədʒiz/",
+          "vietnamese": "Hợp tác thành công và đổi mới dẫn đến việc thực hiện hiệu quả các chiến lược phát triển kinh doanh.",
+          "audioUrl": "/api/tts/successful-collaboration-and-innovation-lead-to-efficient-implementation-of-business-development-strategies"
+        }
+      }
+    ],
+    "advanced": [
+      {
+        "id": "advanced_1",
+        "title": "Academic & Scientific",
+        "description": "Learn advanced academic and scientific vocabulary",
+        "level": "advanced",
+        "vocabulary": [
+          {
+            "word": "hypothesis",
+            "ipa": "/haɪˈpɑːθəsɪs/",
+            "vietnamese": "giả thuyết",
+            "audioUrl": "/api/tts/hypothesis"
+          },
+          {
+            "word": "methodology",
+            "ipa": "/ˌmeθəˈdɑːlədʒi/",
+            "vietnamese": "phương pháp luận",
+            "audioUrl": "/api/tts/methodology"
+          },
+          {
+            "word": "phenomenon",
+            "ipa": "/fəˈnɑːmɪnən/",
+            "vietnamese": "hiện tượng",
+            "audioUrl": "/api/tts/phenomenon"
+          },
+          {
+            "word": "theoretical",
+            "ipa": "/ˌθiːəˈretɪkl/",
+            "vietnamese": "lý thuyết",
+            "audioUrl": "/api/tts/theoretical"
+          },
+          {
+            "word": "empirical",
+            "ipa": "/ɪmˈpɪrɪkl/",
+            "vietnamese": "thực nghiệm",
+            "audioUrl": "/api/tts/empirical"
+          },
+          {
+            "word": "comprehensive",
+            "ipa": "/ˌkɑːmprɪˈhensɪv/",
+            "vietnamese": "toàn diện",
+            "audioUrl": "/api/tts/comprehensive"
+          },
+          {
+            "word": "sophisticated",
+            "ipa": "/səˈfɪstɪkeɪtɪd/",
+            "vietnamese": "tinh vi",
+            "audioUrl": "/api/tts/sophisticated"
+          },
+          {
+            "word": "prerequisite",
+            "ipa": "/priːˈrekwəzɪt/",
+            "vietnamese": "điều kiện tiên quyết",
+            "audioUrl": "/api/tts/prerequisite"
+          },
+          {
+            "word": "substantiate",
+            "ipa": "/səbˈstænʃieɪt/",
+            "vietnamese": "chứng minh",
+            "audioUrl": "/api/tts/substantiate"
+          },
+          {
+            "word": "paradigm",
+            "ipa": "/ˈpærədaɪm/",
+            "vietnamese": "mô hình",
+            "audioUrl": "/api/tts/paradigm"
+          }
+        ],
+        "sentence": {
+          "text": "The comprehensive methodology requires sophisticated theoretical frameworks to substantiate empirical hypotheses about complex phenomena.",
+          "ipa": "/ðə ˌkɑːmprɪˈhensɪv ˌmeθəˈdɑːlədʒi rɪˈkwaɪərz səˈfɪstɪkeɪtɪd ˌθiːəˈretɪkl ˈfreɪmwɜːrks tuː səbˈstænʃieɪt ɪmˈpɪrɪkl haɪˈpɑːθəsiz əˈbaʊt kəmˈpleks fəˈnɑːmɪnə/",
+          "vietnamese": "Phương pháp luận toàn diện đòi hỏi các khung lý thuyết tinh vi để chứng minh các giả thuyết thực nghiệm về các hiện tượng phức tạp.",
+          "audioUrl": "/api/tts/the-comprehensive-methodology-requires-sophisticated-theoretical-frameworks-to-substantiate-empirical-hypotheses-about-complex-phenomena"
+        }
+      }
+    ]
+  }
+}