update instructions

backend/config.py

@@ -13,10 +13,23 @@ Respond ONLY with a valid JSON object using the following format:
 }
 
 Guidelines:
-- 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".
+- 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.
 """
@@ -27,32 +40,33 @@ 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. You will design a lesson plan with relevant topics, sub-topics, and learning goals to ensure gradual progression in the target language. All outputs should be in the user's native language.
+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.
 
 ### Instructions:
-1. **Start with the Lesson Topic (Main Focus):**
-   - Select a broad lesson topic based on the user’s target language and proficiency. The topic should be aligned with the user's interests (e.g., business, travel, daily conversations, etc.).
-   - Example: "Business Vocabulary," "Travel Essentials," "Basic Conversation Skills."
-
-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 learning goals and should cover key vocabulary and grammar points.
-   - Example:
-     - **Topic:** Business Vocabulary
-       - Sub-topic 1: Introducing yourself professionally
-       - Sub-topic 2: Discussing work tasks
-       - Sub-topic 3: Asking for help in the office
-
-3. **Define Learning Goals for Each Sub-topic:**
-   - Clearly define the learning outcomes for each sub-topic. These goals should be aligned with the user's proficiency and should reflect practical usage of the language.
-   - Example: "By the end of this sub-topic, the learner will be able to introduce themselves in a professional context."
+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."
 
 ### Output Format:
-You should return a JSON object containing:
-- `"lesson_topic"`: The main lesson focus, written in the user's native language.
-- `"sub_topics"`: A list of sub-topics, each with its own set of learning goals, written in the user's native language.
-   - Each sub-topic should have:
-     - `"sub_topic"`: A brief title of the sub-topic in the user's native language.
-     - `"learning_goals"`: A list of clear and measurable learning goals in the user's native language.
+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
@@ -60,31 +74,22 @@ You should return a JSON object containing:
   "lesson_topic": "Business Vocabulary",
   "sub_topics": [
     {
-      "sub_topic": "Introducing yourself in a professional setting",
+      "sub_topic": "Greeting colleagues",
       "learning_goals": [
-        "Introduce yourself using professional language",
-        "Discuss your job role"
+        "Use two common greetings in a workplace",
+        "Respond politely to a greeting"
       ]
     },
     {
-      "sub_topic": "Discussing work tasks",
+      "sub_topic": "Introducing yourself professionally",
       "learning_goals": [
-        "Talk about ongoing projects",
-        "Explain work responsibilities"
-      ]
-    },
-    {
-      "sub_topic": "Asking for help in the office",
-      "learning_goals": [
-        "Politely ask for assistance",
-        "Understand and respond to common office requests"
+        "Introduce yourself with three professional phrases",
+        "State your job role clearly"
       ]
     }
   ]
 }
-
 """
-
 flashcard_mode_instructions = """
 # Metadata:
 # Native language: {native_language}
@@ -101,9 +106,10 @@ You will receive a series of messages in the following structure:
   ...
 ]
 Treat this list as prior conversation history. Use it to:
-- Identify the user's learning patterns, interests, and vocabulary already introduced.
-- Avoid repeating previously generated flashcards.
-- Adjust difficulty based on progression.
+- 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.
 
 ### Generation Guidelines
 When generating a new set of flashcards:
@@ -111,30 +117,37 @@ When generating a new set of flashcards:
    - **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.
-   
+
 2. **Avoid repetition**:
-   - 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.
+   - 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.
 
 3. **Adjust content based on proficiency**:
-   - 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.
+   - **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).
 
 4. **Domain relevance**:
-   - 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.
+   - 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.
 
 ### 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 **base language** (the user’s native language).
-- `"example"`: A natural example sentence in the **target language**, demonstrating the word **within 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, base: English)"
+User: "Flashcards for my hobby: landscape photography in German (intermediate level, native: English)"
 
 #### Example Output:
 ```json
@@ -153,7 +166,10 @@ exercise_mode_instructions = """
 # Target language: {target_language}
 # Proficiency level: {proficiency}
 
-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.
+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:
@@ -162,43 +178,51 @@ You will receive a list of previous messages:
   {"role": "assistant", "content": "<generated exercises>"}
 ]
 Treat this list as prior conversation history. Use it to:
-- Identify the user's learning patterns, interests, and vocabulary already introduced.
-- Avoid repeating exercises or vocabulary.
-- Ensure progression in complexity or topic coverage.
-- Maintain continuity with the user’s learning focus.
+- 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).
 
 ### 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 (beginner, intermediate, advanced).
+   - **Proficiency level**: Adjust the complexity of the exercises based on the user's proficiency.
 
 2. **Domain relevance**:
-   - Focus on the **domain of interest** (e.g., work, hobby, study area).
-   - Use context from previous queries to tailor the exercises, ensuring they are practical and connected to the user’s personal or professional life.
-   
+   - 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.
+
 3. **Avoid repetition**:
-   - Ensure that previously used vocabulary or sentence structures are not repeated.
+   - 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.
 
 4. **Adjust difficulty**:
-   - For **beginner** users, keep the sentences simple and focus on high-frequency vocabulary.
-   - For **intermediate** users, incorporate slightly more complex structures and vocabulary.
-   - For **advanced** users, use more nuanced grammar and specialized vocabulary relevant to their domain.
+   - **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. **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.
 
 ### Output Format
 Produce exactly **5 cloze-style exercises** as a **valid JSON array**, with each item containing:
-- `"sentence"`: A sentence in the **target language** that includes a blank `'___'` for a missing vocabulary word or grammar element. The sentence should be relevant to the user’s domain of interest.
+- `"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 believable but clearly incorrect in context.
+- `"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.
 
 ### Example Query and Expected Output
 
 #### Example Query:
-User: "Beginner French exercises about my work in marketing (base: English)"
+User: "Beginner French exercises about my work in marketing (native: English)"
 
-#### Expected Output:
+#### Example Output:
 ```json
 [
   {"sentence": "Nous devons lancer la nouvelle ___ le mois prochain.", "answer": "campagne", "choices": ["campagne", "produit", "réunion"]},
@@ -323,4 +347,4 @@ Return only the final **JSON object**. Do not include:
     }
   ]
 }
-"""
+"""