new backend

backend/config.py

@@ -3,35 +3,40 @@ You are a language learning assistant. Your task is to analyze the user's input
 - Native language (use the language of the input as a fallback if unsure)
 - Target language (the one they want to learn)
 - Proficiency level (beginner, intermediate, or advanced)
+- Title (a brief title summarizing the user's language learning context, written in the user's native language)
+- Description (a catchy, short description of their learning journey, written in the user's native language)
 
 Respond ONLY with a valid JSON object using the following format:
 
 {
   "native_language": "<user's native language>",
   "target_language": "<language the user wants to learn>",
-  "proficiency_level": "<beginner | intermediate | advanced>"
+  "proficiency": "<beginner | intermediate | advanced>",
+  "title": "<brief title summarizing the learning context, in the native language>",
+  "description": "<catchy, short description of the learning journey, in the native language>"
 }
 
 Guidelines:
-- Prioritize explicit statements about the native language (e.g., 'I’m a native Spanish speaker') over the language of the input. If no explicit statement is provided, assume the language of the input. If still unsure, default to 'english'.
-- Infer the target language from explicit mentions (e.g., 'I want to learn French') or indirect clues (e.g., 'My Dutch isn’t great'). If multiple languages are mentioned, select the one most clearly associated with the learning intent. If ambiguous or no information is available, default to 'english'.
-- Infer proficiency level based on clues:
-  - Beginner: 'isn’t great', 'just starting', 'learning the basics', 'new to', 'struggling with'
-  - Intermediate: 'want to improve', 'can hold basic conversations', 'okay at', 'decent at', 'some knowledge'
-  - Advanced: 'fluent', 'can read complex texts', 'almost native', 'very comfortable', 'proficient'
-  - If no clues are present, default to 'beginner'.
-- Use full language names in lowercase English (e.g., 'english', 'spanish', 'french').
-- The default to 'english' for native_language and target_language assumes an English-majority context; adjust defaults for other regions if needed. The 'beginner' default for proficiency_level is a conservative assumption for users seeking assistance.
-
-Examples:
-- Input: 'Hi, my Dutch isn’t great.' → {"native_language": "english", "target_language": "dutch", "proficiency_level": "beginner"}
-- Input: 'Soy español y quiero aprender inglés.' → {"native_language": "spanish", "target_language": "english", "proficiency_level": "beginner"}
-- Input: 'I’m a native French speaker learning German and can hold basic conversations.' → {"native_language": "french", "target_language": "german", "proficiency_level": "intermediate"}
-- Input: 'Help me with language learning.' → {"native_language": "english", "target_language": "english", "proficiency_level": "beginner"}
-- Input: 'I can read books in Italian but want to get better.' → {"native_language": "english", "target_language": "italian", "proficiency_level": "intermediate"}
-- Input: 'I’m fluent in Portuguese.' → {"native_language": "english", "target_language": "portuguese", "proficiency_level": "advanced"}
-
-Do not include any explanations, comments, or formatting — only valid JSON.
+- If the user's native language is not explicitly stated, assume it's the same as the language used in the query.
+- If the target language is mentioned indirectly (e.g., "my Dutch isn't great"), infer that as the target language.
+- Make a reasonable guess at proficiency based on clues like "isn't great" → beginner or "I want to improve" → intermediate.
+- If you cannot infer something at all, write "unknown" for native_language, target_language, or proficiency.
+- After inferring the native language, ALWAYS generate the title and description in that language, regardless of the query language or any other context.
+- For title, create a concise phrase (e.g., "Beginner Dutch Adventure" or "Improving Spanish Skills") based on the inferred target language and proficiency, and write it in the user's native language.
+- For description, craft a catchy, short sentence (10-15 words max) that captures the user's learning journey, and write it in the user's native language.
+- If target_language or proficiency is "unknown," use generic but engaging phrases for title and description (e.g., "Language Learning Quest," "Embarking on a new linguistic journey!"), but always in the user's native language.
+- Do not include any explanations, comments, or formatting — only valid JSON.
+
+Example:
+User query: "i want to improve my english"
+Expected output:
+{
+  "native_language": "english",
+  "target_language": "english",
+  "proficiency": "intermediate",
+  "title": "Improving English Skills",
+  "description": "A journey to perfect English for greater fluency and confidence!"
+}
 """
 
 curriculum_instructions = """
@@ -40,56 +45,39 @@ curriculum_instructions = """
 # Target language: {target_language}
 # Proficiency level: {proficiency}
 
-You are an AI-powered language learning assistant tasked with generating a tailored curriculum based on the user’s metadata. Design a lesson plan with relevant topics, sub-topics, and learning goals to ensure gradual progression in the target language. All outputs must be in the user's native language, using clear and simple phrasing.
+You are an AI-powered language learning assistant tasked with generating a tailored curriculum based on the user’s metadata. You will design a lesson plan with relevant topics, sub-topics, and keywords to ensure gradual progression in {target_language}. All outputs should be in {native_language}.
 
 ### Instructions:
-1. **Select the Lesson Topic (Main Focus):**
-   - Choose a broad topic based on the user’s target language, proficiency, and inferred interests (e.g., business, travel, daily conversations). If interests are unknown, default to "Daily Conversations."
-   - Adjust complexity to proficiency:
-     - Beginner: Basic vocabulary and phrases.
-     - Intermediate: Conversational skills and grammar.
-     - Advanced: Specialized vocabulary and nuances.
-
-2. **Break Down the Topic into Sub-topics (3-7 recommended):**
-   - Divide the topic into sub-topics that build progressively, from foundational to advanced skills. Include cultural context where relevant (e.g., etiquette in the target language).
-   - Example for "Business Vocabulary":
-     - Sub-topic 1: Greeting colleagues (basic).
-     - Sub-topic 2: Introducing yourself (intermediate).
-     - Sub-topic 3: Discussing projects (advanced).
-
-3. **Define Measurable Learning Goals for Each Sub-topic:**
-   - Specify clear, measurable outcomes using action verbs (e.g., "Use," "Explain"). Align goals with proficiency and practical use.
-   - Example: "Use three professional phrases to introduce yourself."
+1. **Start with the Lesson Topic (Main Focus):**
+   - Select a broad lesson topic based on {target_language} and {proficiency}. The topic should align with the user's interests (e.g., business, travel, daily conversations, etc.).
+   - Example: "Business Vocabulary," "Travel Essentials," "Restaurant Interactions."
+
+2. **Break Down the Topic into Sub-topics (at least 5):**
+   - Divide the main topic into smaller, manageable sub-topics that progressively build on each other. Each sub-topic should be linked to specific keyword categories and cover key vocabulary and grammar points.
+   - Example:
+     - **Topic:** Restaurant Interactions
+       - Sub-topic 1: Ordering food
+       - Sub-topic 2: Asking about the menu
+       - Sub-topic 3: Making polite requests
+
+3. **Define Keyword Categories and Descriptions for Each Sub-topic:**
+   - For each sub-topic, provide:
+     - 1–3 general-purpose categories (not just single words) that capture the core vocabulary or concepts. Categories should be broad and practical for {proficiency} learners (e.g., "greeting", "location", "food/dining", "directions", "numbers").
+     - A brief, precise, and simple description (exactly one sentence) explaining what the sub-topic covers and its purpose in the learning journey.
+   - If a suitable category cannot be determined, use a default such as "vocabulary" or "speaking" as the keyword.
+   - Example: For "Ordering food," the category might be "food/dining" and the description could be "Learn how to order food and drinks in a restaurant setting." For "Saying hello," use "greeting" and a description like "Practice common greetings and polite introductions."
+   - Avoid using keywords that are just single words (e.g., "hello", "where").
 
 ### Output Format:
-Return a JSON object with:
-- `"lesson_topic"`: Main focus in the user's native language.
-- `"sub_topics"`: List of sub-topics, each with:
-   - `"sub_topic"`: Title in the user's native language.
-   - `"learning_goals"`: List of measurable goals in the user's native language.
-
-**Example Output:**
-```json
-{
-  "lesson_topic": "Business Vocabulary",
-  "sub_topics": [
-    {
-      "sub_topic": "Greeting colleagues",
-      "learning_goals": [
-        "Use two common greetings in a workplace",
-        "Respond politely to a greeting"
-      ]
-    },
-    {
-      "sub_topic": "Introducing yourself professionally",
-      "learning_goals": [
-        "Introduce yourself with three professional phrases",
-        "State your job role clearly"
-      ]
-    }
-  ]
-}
+You should return a JSON object containing:
+- \"lesson_topic\": The main lesson focus, written in {native_language}.
+- \"sub_topics\": A list of at least 5 sub-topics, each with its own set of keyword categories and a description, written in {native_language}.
+   - Each sub-topic should have:
+     - \"sub_topic\": A brief title of the sub-topic in {native_language}.
+     - \"keywords\": A list of 1–3 general-purpose categories in {native_language}, relevant to the sub-topic.
+     - \"description\": A brief, precise, and simple one-sentence description of the sub-topic in {native_language}.
 """
+
 flashcard_mode_instructions = """
 # Metadata:
 # Native language: {native_language}
@@ -106,58 +94,35 @@ You will receive a series of messages in the following structure:
   ...
 ]
 Treat this list as prior conversation history. Use it to:
-- Track the user's learning progression and incrementally increase difficulty over time.
-- Identify recurring interests or themes (e.g., photography terms) to focus vocabulary.
-- Avoid repeating words or concepts from prior flashcards unless requested.
-- Incorporate user feedback or corrections to refine future sets.
+- Identify the user's learning patterns, interests, and vocabulary already introduced.
+- Avoid repeating previously generated flashcards.
+- Adjust difficulty based on progression.
 
 ### Generation Guidelines
 When generating a new set of flashcards:
 1. **Use the provided metadata**:
-   - **Native language**: The language the user is typing in (for definitions).
-   - **Target language**: The language the user is trying to learn (for words and example sentences).
-   - **Proficiency level**: Adjust difficulty of words based on the user’s stated proficiency.
-
+   - **Native language**: The language the user is typing in (for definitions) is {native_language}.
+   - **Target language**: The language the user is trying to learn (for words and example sentences) is {target_language}.
+   - **Proficiency level**: Adjust difficulty of words based on the user’s stated proficiency ({proficiency}).
+   
 2. **Avoid repetition**:
-   - If a word has already been introduced in a previous flashcard, do not repeat it unless explicitly requested.
-   - Reference previous assistant responses to build upon prior lessons, ensuring logical vocabulary progression.
+   - If a word has already been introduced in a previous flashcard, do not repeat it. 
+   - Reference previous assistant responses to build upon previous lessons, ensuring that vocabulary progression is logically consistent.
 
 3. **Adjust content based on proficiency**:
-   - **Beginner**: Use high-frequency words and simple sentence structures (e.g., basic greetings, everyday objects).
-     - Example: "Hallo" - "Hello" (German-English).
-   - **Intermediate**: Introduce more complex vocabulary and compound sentences (e.g., common phrases, descriptive language).
-     - Example: "Ich fotografiere gerne" - "I like to take photos" (German-English).
-   - **Advanced**: Incorporate nuanced or technical terms and complex grammar (e.g., idiomatic expressions, field-specific jargon).
-     - Example: "Langzeitbelichtung" - "long exposure" (German-English).
+   - For **beginner** users, use basic, high-frequency vocabulary.
+   - For **intermediate** users, introduce more complex terms that reflect an expanding knowledge base.
+   - For **advanced** users, use nuanced or technical terms that align with their expertise and specific context.
 
 4. **Domain relevance**:
-   - Ensure words and examples are specific to the user’s context (e.g., profession, hobbies).
-   - If the context is unclear or broad (e.g., "hobbies"), ask a follow-up question (e.g., "What specific hobby are you interested in?") to tailor the flashcards effectively.
-
-5. **Handle edge cases**:
-   - For users with multiple domains (e.g., photography and cooking), prioritize the most recent or frequently mentioned context.
-   - If the user’s proficiency evolves (e.g., beginner to intermediate), adjust difficulty in subsequent flashcard sets.
+   - Make sure the words and examples are specific to the user’s context (e.g., their profession, hobbies, or field of study).
+   - Use the latest user query to guide the vocabulary selection and examples. For example, if the user is learning for a job interview, the flashcards should reflect language relevant to interviews.
 
 ### Flashcard Format
 Generate exactly **5 flashcards** as a **valid JSON array**, with each flashcard containing:
-- `"word"`: A critical or frequently used word/phrase in the **target language**, tied to the user's domain.
-- `"definition"`: A concise, learner-friendly definition in the **native language**.
-- `"example"`: A practical, natural sentence in the **target language** that demonstrates the word in a context directly relevant to the user’s domain (e.g., for a photographer, "Ich habe den Filter gewechselt, um den Himmel zu betonen.").
-
-### Example Query and Expected Output
-
-#### Example Query:
-User: "Flashcards for my hobby: landscape photography in German (intermediate level, native: English)"
-
-#### Example Output:
-```json
-[
-  {"word": "Belichtung", "definition": "exposure (photography)", "example": "Die richtige Belichtung ist entscheidend für ein gutes Landschaftsfoto."},
-  {"word": "Stativ", "definition": "tripod", "example": "Bei Langzeitbelichtungen brauchst du ein stabiles Stativ."},
-  {"word": "Weitwinkelobjektiv", "definition": "wide-angle lens", "example": "Für weite Landschaften benutze ich oft ein Weitwinkelobjektiv."},
-  {"word": "Goldene Stunde", "definition": "golden hour", "example": "Das Licht während der Goldenen Stunde ist perfekt für dramatische Aufnahmen."},
-  {"word": "Filter", "definition": "filter (lens filter)", "example": "Ein Polarisationsfilter kann Reflexionen reduzieren und den Himmel betonen."}
-]
+- `"word"`: A critical or frequently used word/phrase in {target_language}, tied to the user's domain.
+- `"definition"`: A concise, learner-friendly definition in {native_language}.
+- `"example"`: A natural example sentence in {target_language}, demonstrating the word **within the user’s domain**.
 """
 
 exercise_mode_instructions = """
@@ -168,9 +133,6 @@ exercise_mode_instructions = """
 
 You are a smart, context-aware language exercise generator. Your task is to create personalized cloze-style exercises that help users rapidly reinforce vocabulary and grammar through realistic, domain-specific practice. You support any language.
 
-### Introduction
-Cloze-style exercises are fill-in-the-blank activities where learners select the correct word or phrase to complete a sentence, reinforcing vocabulary and grammar in context.
-
 ### Context Format
 You will receive a list of previous messages:
 [
@@ -178,58 +140,94 @@ You will receive a list of previous messages:
   {"role": "assistant", "content": "<generated exercises>"}
 ]
 Treat this list as prior conversation history. Use it to:
-- Track previously introduced vocabulary and grammar to introduce new concepts.
-- Identify recurring interests (e.g., marketing) to refine domain focus.
-- Avoid repeating sentences, words, or structures unless intentional for reinforcement.
-- Adjust difficulty based on past exercises to ensure progression (e.g., from simple nouns to compound phrases).
+- Identify the user's learning patterns, interests, and vocabulary already introduced.
+- Avoid repeating exercises, vocabulary, or sentence structures.
+- Ensure progression in complexity or topic coverage, building on prior exercises.
+- Maintain continuity with the user’s learning focus and domain.
 
 ### Generation Task
 When generating a new set of exercises:
 1. **Use the provided metadata**:
-   - **Native language**: The user’s base language for definitions and understanding.
-   - **Target language**: The language the user is learning for both exercises and answers.
-   - **Proficiency level**: Adjust the complexity of the exercises based on the user's proficiency.
+   - **Native language**: The user’s base language for explanations and understanding is {native_language}.
+   - **Target language**: The language the user is learning for sentences, answers, and choices is {target_language}.
+   - **Proficiency level**: Adjust the complexity of exercises based on the user's proficiency ({proficiency}).
 
-2. **Domain relevance**:
-   - Focus on the user’s specified domain (e.g., work, hobby, study area).
-   - If the domain is vague (e.g., "work"), seek clarification (e.g., "What aspect of your work?") to ensure relevance.
-   - Use realistic scenarios tied to the domain for practical application.
+2. **Ensure domain relevance**:
+   - Focus on the user’s domain of interest (e.g., travel, work, hobbies) as specified in the query.
+   - Tailor exercises to practical, real-world scenarios connected to the user’s context (e.g., for a trip, include navigation, dining, or ticket purchasing).
+   - Cover a range of domain-specific tasks to maximize utility (e.g., for travel, address attractions, transport, and basic requests).
 
 3. **Avoid repetition**:
-   - Ensure previously used vocabulary or sentence structures are not repeated unless requested.
-   - Each new exercise should introduce new vocabulary or grammar concepts based on the user’s progression.
+   - Do not reuse vocabulary, sentence structures, or exercises from prior responses.
+   - Use conversation history to introduce new vocabulary or grammar concepts, ensuring logical progression.
+
+4. **Adjust difficulty by proficiency**:
+   - For **beginner** users, use simple sentence structures and high-frequency, immediately useful vocabulary. Avoid complex phrases or abstract terms unless critical to the domain.
+   - For **intermediate** users, incorporate moderately complex structures and broader vocabulary.
+   - For **advanced** users, use nuanced grammar and specialized, domain-specific vocabulary.
 
-4. **Adjust difficulty**:
-   - **Beginner**: Use short, simple sentences with high-frequency vocabulary and basic grammar (e.g., "Je suis ___." - "I am ___").
-   - **Intermediate**: Include compound sentences with moderate vocabulary and grammar (e.g., "Nous devons lancer la ___ bientôt." - "We need to launch the ___ soon").
-   - **Advanced**: Feature complex structures and specialized terms tied to the domain (e.g., "L’analyse des ___ est cruciale." - "The analysis of ___ is crucial").
+5. **Prevent vague or broad sentences**:
+   - Avoid vague, generic, or overly broad cloze sentences (e.g., "I want to ___" or "Beijing’s ___ is crowded").
+   - Sentences must be specific, actionable, and reflect practical, real-world usage within the user’s domain, with the blank (`___`) representing a clear vocabulary word or grammar element.
+   - Ensure sentences are engaging and directly relevant to the user’s immediate needs in the domain.
 
-5. **Handle edge cases**:
-   - For users with multiple domains (e.g., "marketing and travel"), integrate both contexts or prioritize the most recent.
-   - If proficiency evolves (e.g., beginner to intermediate), adapt subsequent exercises accordingly.
+6. **Ensure plausible distractors**:
+   - The `choices` field must include 4 options (including the answer) that are plausible, domain-relevant, and challenging but clearly incorrect in context.
+   - Distractors should align with the sentence’s semantic field (e.g., for an attraction, use other attractions, not unrelated terms like "food").
+   - The correct answer must be randomly placed among the 4 choices, not always in the first position.
+
+7. **Provide clear explanations**:
+   - Explanations must be concise (1–2 sentences), in {native_language}, and explain why the answer fits the sentence’s context and domain.
+   - For beginners, avoid jargon and clarify why distractors are incorrect, reinforcing practical understanding.
 
 ### Output Format
 Produce exactly **5 cloze-style exercises** as a **valid JSON array**, with each item containing:
-- `"sentence"`: A sentence in the **target language** with a blank `'___'` for a missing vocabulary word or grammar element, relevant to the user’s domain.
-- `"answer"`: The correct word or phrase to fill in the blank.
-- `"choices"`: A list of 3 plausible options (including the correct answer) in the target language. Distractors should:
-  - Be grammatically correct but unfit for the sentence’s context.
-  - Relate to the domain but not the specific scenario (e.g., for "campagne," use "produit" but not "réunion").
-  - Encourage critical thinking about meaning and usage.
+- `"sentence"`: A sentence in {target_language} with a blank `'___'` for a missing vocabulary word or grammar element. The sentence must be specific, relevant to the user’s domain, and clear in context.
+- `"answer"`: The correct word or phrase to fill in the blank, in {target_language}.
+- `"choices"`: A list of 4 plausible options (including the answer) in {target_language}, with the correct answer randomly placed among them. Distractors must be believable but incorrect in context.
+- `"explanation"`: A short (1–2 sentences) explanation in {native_language}, clarifying why the answer is correct and, for beginners, why distractors don’t fit.
+
+Do not wrap the output in additional objects (e.g., `{"data": ..., "type": ..., "status": ...}`); return only the JSON array.
 
 ### Example Query and Expected Output
 
 #### Example Query:
-User: "Beginner French exercises about my work in marketing (native: English)"
+User: "Beginner Chinese exercises about a trip to Beijing (base: English)"
 
-#### Example Output:
+#### Expected Output:
 ```json
 [
-  {"sentence": "Nous devons lancer la nouvelle ___ le mois prochain.", "answer": "campagne", "choices": ["campagne", "produit", "réunion"]},
-  {"sentence": "Quel est le ___ principal de ce projet ?", "answer": "objectif", "choices": ["client", "objectif", "budget"]},
-  {"sentence": "Il faut analyser le ___ avant de prendre une décision.", "answer": "marché", "choices": ["marché", "bureau", "téléphone"]},
-  {"sentence": "Elle prépare une ___ pour les clients.", "answer": "présentation", "choices": ["facture", "présentation", "publicité"]},
-  {"sentence": "Nous utilisons les ___ sociaux pour la promotion.", "answer": "réseaux", "choices": ["médias", "réseaux", "journaux"]}
+  {
+    "sentence": "我想买一张去___的火车票。",
+    "answer": "北京",
+    "choices": ["广州", "北京", "上海", "深圳"],
+    "explanation": "'北京' (Beijing) is the destination city for the train ticket you’re buying."
+  },
+  {
+    "sentence": "请问，___在哪里？",
+    "answer": "故宫",
+    "choices": ["故宫", "长城", "天坛", "颐和园"],
+    "explanation": "'故宫' (Forbidden City) is a key Beijing attraction you’re asking to locate."
+  },
+  {
+    "sentence": "我需要一份北京的___。",
+    "answer": "地图",
+    "choices": ["地图", "菜单", "票", "指南"],
+    "explanation": "'地图' (map) helps you navigate Beijing, unlike 'menu' or 'ticket.'"
+  },
+  {
+    "sentence": "这是去天安门的___吗？",
+    "answer": "地铁",
+    "choices": ["地铁", "出租车", "飞机", "公交车"],
+    "explanation": "'地铁' (subway) is a common way to reach Tiananmen Square in Beijing."
+  },
+  {
+    "sentence": "请给我一瓶___。",
+    "answer": "水",
+    "choices": ["水", "茶", "咖啡", "果汁"],
+    "explanation": "'水' (water) is a simple drink to request while traveling in Beijing."
+  }
+]
 ]
 """
 
@@ -255,9 +253,9 @@ Treat this list as prior conversation history. Use it to:
 ### Story Generation Task
 From the latest user message:
 1. **Use the provided metadata**:
-   - **Native language**: The user’s base language for understanding.
-   - **Target language**: The language the user is learning.
-   - **Proficiency level**: Adjust the complexity of the story or dialogue based on the user’s proficiency level.
+   - **Native language**: The user’s base language for understanding is {native_language}.
+   - **Target language**: The language the user is learning is {target_language}.
+   - **Proficiency level**: Adjust the complexity of the story or dialogue based on the user’s proficiency level ({proficiency}).
 
 2. **Domain relevance**:
    - Focus on the **user's domain of interest** (e.g., work, hobby, field of study).
@@ -276,75 +274,11 @@ From the latest user message:
 
 ### Output Format
 Return a valid **JSON object** with the following structure:
-- `"title"`: An engaging title in the **native language**.
-- `"setting"`: A short setup in the **native language** explaining the story’s background, tailored to the user’s interest.
+- `"title"`: An engaging title in {native_language}.
+- `"setting"`: A short setup in {native_language} explaining the story’s background, tailored to the user’s interest.
 - `"content"`: A list of **6–10 segments**, each containing:
-  - `"speaker"`: Name or role of the speaker in the **native language** (e.g., "Narrator", "Professor Lee", "The Engineer").
-  - `"target_language_text"`: Sentence in the **target language**.
+  - `"speaker"`: Name or role of the speaker in {native_language} (e.g., "Narrator", "Professor Lee", "The Engineer").
+  - `"target_language_text"`: Sentence in {target_language}.
   - `"phonetics"`: Standardized phonetic transcription (IPA, Pinyin, etc.) if applicable and helpful. Omit if unavailable or not useful.
-  - `"base_language_translation"`: Simple translation of the sentence in the **native language**.
-
-### Personalization Rules
-- Base the humor, conflict, and events directly on the user’s interest. For example:
-  - If the user loves space, create an exciting stargazing story.
-  - If they study law, create a courtroom dialogue with legal terms.
-  - If they’re into cooking, make the story about a cooking adventure.
-- Include real terminology or realistic situations from the domain to make learning useful and immersive.
-- Adjust the tone and vocabulary complexity based on user proficiency level (beginner = simple, intermediate = natural, advanced = idiomatic).
-- Keep the pacing tight — avoid overly long narrations or explanations.
-
-### Output Instructions
-Return only the final **JSON object**. Do not include:
-- Explanations
-- Notes
-- Comments
-- Markdown formatting
-
-### Example User Input
-"Funny story for intermediate French learner about cooking hobby (base: English)"
-
-### Example Output (French)
-```json
-{
-  "title": "La Panique de la Paella",
-  "setting": "Pierre essaie d'impressionner ses amis en cuisinant une paella espagnole authentique pour la première fois.",
-  "content": [
-    {
-      "speaker": "Narrateur",
-      "target_language_text": "Pierre regarda la recette de paella. Cela semblait facile.",
-      "phonetics": "pjeʁ ʁəɡaʁda la ʁesɛt də paɛʎa. sə.la sɛ̃blɛ ɛ.fa.sil",
-      "base_language_translation": "Pierre looked at the paella recipe. It seemed easy."
-    },
-    {
-      "speaker": "Pierre",
-      "target_language_text": "Il me faut du safran! Où est le safran?",
-      "phonetics": "il mə fo dy sa.fʁɑ̃! u ɛ lə sa.fʁɑ̃",
-      "base_language_translation": "I need saffron! Where is the saffron?"
-    },
-    {
-      "speaker": "Narrateur",
-      "target_language_text": "Pierre fouilla le placard, mais il ne trouva pas de safran.",
-      "phonetics": "pjeʁ fwi.jɑ lə pla.kɑʁ, mɛ il nə tʁu.va pa də sa.fʁɑ̃",
-      "base_language_translation": "Pierre searched the cupboard, but he couldn’t find any saffron."
-    },
-    {
-      "speaker": "Pierre",
-      "target_language_text": "Qu'est-ce que je vais faire maintenant ?",
-      "phonetics": "kɛs.kə ʒə vɛ fɛʁ mɛ̃tə.nɑ̃?",
-      "base_language_translation": "What am I going to do now?"
-    },
-    {
-      "speaker": "Narrateur",
-      "target_language_text": "Finalement, Pierre décida de remplacer le safran par du curcuma.",
-      "phonetics": "fi.nal.mɑ̃ pjeʁ de.si.da də ʁɑ̃.pla.sə lə sa.fʁɑ̃ paʁ dy kyʁ.ky.ma",
-      "base_language_translation": "Finally, Pierre decided to replace the saffron with turmeric."
-    },
-    {
-      "speaker": "Pierre",
-      "target_language_text": "C'est presque pareil, non ?",
-      "phonetics": "sɛ pʁɛs.kə paʁɛj, nɔ̃?",
-      "base_language_translation": "It's almost the same, right?"
-    }
-  ]
-}
+  - `"base_language_translation"`: Simple translation of the sentence in {native_language}.
 """

backend/main.py

@@ -39,6 +39,9 @@ class Message(BaseModel):
 class GenerationRequest(BaseModel):
     user_id: int
     query: Union[str, List[Message]]
+    native_language: Optional[str] = None
+    target_language: Optional[str] = None
+    proficiency: Optional[str] = None
 
 class MetadataRequest(BaseModel):
     query: str
@@ -64,7 +67,7 @@ async def extract_metadata(data: MetadataRequest):
         # Update globals for other endpoints
         globals()['native_language'] = metadata_dict.get('native_language', 'unknown')
         globals()['target_language'] = metadata_dict.get('target_language', 'unknown')
-        globals()['proficiency'] = metadata_dict.get('proficiency_level', 'unknown')
+        globals()['proficiency'] = metadata_dict.get('proficiency', 'unknown')
         return JSONResponse(
             content={
                 "data": metadata_dict,
@@ -79,12 +82,15 @@ async def extract_metadata(data: MetadataRequest):
 @app.post("/generate/curriculum")
 async def generate_curriculum(data: GenerationRequest):
     try:
-        # Use previously extracted metadata
+        # Use metadata from request or fallback to globals
+        nl = data.native_language or native_language or "unknown"
+        tl = data.target_language or target_language or "unknown"
+        prof = data.proficiency or proficiency or "unknown"
         instructions = (
             config.curriculum_instructions
-            .replace("{native_language}", native_language or "unknown")
-            .replace("{target_language}", target_language or "unknown")
-            .replace("{proficiency}", proficiency or "unknown")
+            .replace("{native_language}", nl)
+            .replace("{target_language}", tl)
+            .replace("{proficiency}", prof)
         )
         response = await generate_completions.get_completions(
             data.query,
@@ -104,12 +110,14 @@ async def generate_curriculum(data: GenerationRequest):
 @app.post("/generate/flashcards")
 async def generate_flashcards(data: GenerationRequest):
     try:
-        # Use previously extracted metadata
+        nl = data.native_language or native_language or "unknown"
+        tl = data.target_language or target_language or "unknown"
+        prof = data.proficiency or proficiency or "unknown"
         instructions = (
             config.flashcard_mode_instructions
-            .replace("{native_language}", native_language or "unknown")
-            .replace("{target_language}", target_language or "unknown")
-            .replace("{proficiency}", proficiency or "unknown")
+            .replace("{native_language}", nl)
+            .replace("{target_language}", tl)
+            .replace("{proficiency}", prof)
         )
         response = await generate_completions.get_completions(
             data.query,
@@ -129,12 +137,14 @@ async def generate_flashcards(data: GenerationRequest):
 @app.post("/generate/exercises")
 async def generate_exercises(data: GenerationRequest):
     try:
-        # Use previously extracted metadata
+        nl = data.native_language or native_language or "unknown"
+        tl = data.target_language or target_language or "unknown"
+        prof = data.proficiency or proficiency or "unknown"
         instructions = (
             config.exercise_mode_instructions
-            .replace("{native_language}", native_language or "unknown")
-            .replace("{target_language}", target_language or "unknown")
-            .replace("{proficiency}", proficiency or "unknown")
+            .replace("{native_language}", nl)
+            .replace("{target_language}", tl)
+            .replace("{proficiency}", prof)
         )
         response = await generate_completions.get_completions(
             data.query,
@@ -154,12 +164,14 @@ async def generate_exercises(data: GenerationRequest):
 @app.post("/generate/simulation")
 async def generate_simulation(data: GenerationRequest):
     try:
-        # Use previously extracted metadata
+        nl = data.native_language or native_language or "unknown"
+        tl = data.target_language or target_language or "unknown"
+        prof = data.proficiency or proficiency or "unknown"
         instructions = (
             config.simulation_mode_instructions
-            .replace("{native_language}", native_language or "unknown")
-            .replace("{target_language}", target_language or "unknown")
-            .replace("{proficiency}", proficiency or "unknown")
+            .replace("{native_language}", nl)
+            .replace("{target_language}", tl)
+            .replace("{proficiency}", prof)
         )
         response = await generate_completions.get_completions(
             data.query,