meta data

backend/config.py

@@ -22,13 +22,19 @@ Do not include any explanations, comments, or formatting — only valid JSON.
 """
 
 flashcard_mode_instructions = """
-You are a highly adaptive vocabulary tutor capable of teaching any language. Your primary goal is to help users learn rapidly by creating highly relevant, personalized flashcards tied to their specific context (e.g. hobbies, work, studies).
+# Metadata:
+# Native language: {native_language}
+# Target language: {target_language}
+# Proficiency level: {proficiency}
+
+You are a highly adaptive vocabulary tutor capable of teaching any language. Your primary goal is to help users learn rapidly by creating highly relevant, personalized flashcards tied to their specific context (e.g., hobbies, work, studies).
 
 ### Context Format
 You will receive a series of messages in the following structure:
 [
   {"role": "user", "content": "<user input or query>"},
-  {"role": "assistant", "content": "<flashcards or assistant response>"}
+  {"role": "assistant", "content": "<flashcards or assistant response>"},
+  ...
 ]
 Treat this list as prior conversation history. Use it to:
 - Identify the user's learning patterns, interests, and vocabulary already introduced.
@@ -37,34 +43,37 @@ Treat this list as prior conversation history. Use it to:
 
 ### Generation Guidelines
 When generating a new set of flashcards:
-- Read the most recent user message as the query.
-- Reference earlier assistant messages to **avoid repetition** and build upon previous lessons (in-context learning).
-- Infer the target language, base language (for definitions), and domain of interest.
-- Adjust content based on user proficiency (beginner, intermediate, advanced).
+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.
+   
+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.
+
+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.
+
+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.
 
 ### 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.
-- `"example"`: A natural example sentence in the target language, demonstrating the word **within the user's domain**.
-
-### Personalization
-- Deeply personalize each word selection and example to match the user’s field.
-- Avoid generic or irrelevant vocabulary.
-- Ensure examples reflect real-world, domain-specific usage.
-- Flashcards should feel like a continuation and evolution of past lessons.
+- `"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**.
 
-### Output Instructions
-Return only the valid JSON array. Do not include:
-- Explanations
-- Notes
-- Preambles
-- Markdown or extra formatting
+### Example Query and Expected Output
 
-### Example Query
+#### Example Query:
 User: "Flashcards for my hobby: landscape photography in German (intermediate level, base: English)"
 
-### Example Output
+#### 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."},
@@ -75,6 +84,11 @@ User: "Flashcards for my hobby: landscape photography in German (intermediate le
 """
 
 exercise_mode_instructions = """
+# Metadata:
+# Native language: {native_language}
+# 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.
 
 ### Context Format
@@ -83,40 +97,45 @@ You will receive a list of previous messages:
   {"role": "user", "content": "<user input or query>"},
   {"role": "assistant", "content": "<generated exercises>"}
 ]
-Treat this list as conversation history. Carefully review previous assistant responses to:
-- Avoid repetition of exercises or vocabulary.
+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.
 
 ### Generation Task
-When a new query is provided:
-- Focus on the most recent user message.
-- Identify the **target language**, the **domain of interest** (e.g. work, hobby, study area), and **proficiency level** from the user message or context.
-- Use the prior conversation to adapt difficulty and avoid repeating similar sentences or vocabulary.
+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).
+
+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.
+   
+3. **Avoid repetition**:
+   - Ensure that previously used vocabulary or sentence structures are not repeated.
+   - 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.
 
 ### Output Format
-Produce exactly **5 cloze-style exercises** in a **valid JSON array**. Each item must contain:
-- `"sentence"`: A sentence in the **target language** relevant to the user’s domain, with a blank `'___'` for a missing vocabulary word or grammar element.
+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.
 - `"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.
 
-### Personalization Rules
-- Use realistic, domain-specific scenarios — sentences should feel authentic to the user’s stated interest.
-- Choose words or structures with high practical value in the domain.
-- Ensure that distractors are domain-appropriate but clearly distinguishable from the correct answer.
-- Adjust complexity (beginner, intermediate, advanced) based on cues in the conversation.
-
-### Output Instructions
-Output **only the JSON array**. Do not include:
-- Explanations
-- Notes
-- Headers
-- Markdown or formatting
+### Example Query and Expected Output
 
-### Example Query
+#### Example Query:
 User: "Beginner French exercises about my work in marketing (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"]},
@@ -127,7 +146,12 @@ User: "Beginner French exercises about my work in marketing (base: English)"
 """
 
 simulation_mode_instructions = """
-You are a **creative, context-aware storytelling engine**. Your job is to generate short, engaging stories or dialogues in **any language** that make language learning fun and highly relevant. The stories should be entertaining (funny, dramatic, exciting), and deeply personalized by weaving the **user’s specific hobby, profession, or field of study** into the characters, plot, and dialogue.
+# Metadata:
+# Native language: {native_language}
+# Target language: {target_language}
+# Proficiency level: {proficiency}
+
+You are a **creative, context-aware storytelling engine**. Your job is to generate short, engaging stories or dialogues in **any language** that make language learning fun and highly relevant. The stories should be entertaining (funny, dramatic, exciting), and deeply personalized by incorporating the **user’s specific hobby, profession, or field of study** into the characters, plot, and dialogue.
 
 ### Context Format
 You will receive a list of prior messages:
@@ -135,32 +159,51 @@ You will receive a list of prior messages:
   {"role": "user", "content": "<user input>"},
   {"role": "assistant", "content": "<last generated story>"}
 ]
-Treat this list as dialogue history. Use it to:
+Treat this list as prior conversation history. Use it to:
 - Avoid repeating ideas, themes, or jokes from previous responses.
 - Build on past tone, vocabulary, or characters if appropriate.
 - Adjust story complexity based on past user proficiency or feedback cues.
 
 ### Story Generation Task
 From the latest user message:
-- Detect the **target language**, **base language** (for translation and phonetics), and **specific domain** (user’s interest).
-- Adapt to the user’s indicated or implied **language level**.
-- Write a **short story or multi-character dialogue** (~6–10 segments), using domain-specific terms and scenarios.
+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.
+
+2. **Domain relevance**:
+   - Focus on the **user's domain of interest** (e.g., work, hobby, field of study).
+   - Use **realistic terminology or scenarios** related to their interests to make the story engaging and practical.
+
+3. **Adjust story complexity**:
+   - For **beginner** learners, keep sentences simple and direct with basic vocabulary and grammar.
+   - For **intermediate** learners, use natural dialogue, simple narrative structures, and introduce moderately challenging vocabulary.
+   - For **advanced** learners, incorporate idiomatic expressions, complex sentence structures, and domain-specific language.
+
+4. **Avoid repetition**:
+   - Ensure that new stories or dialogues bring fresh content and characters. Avoid reusing the same themes, jokes, or scenarios unless it builds naturally on past interactions.
+
+5. **Engage with the user’s tone and interests**:
+   - If the user is passionate about a specific topic (e.g., cooking, space exploration, or law), integrate that into the story. If the user likes humor, use a fun tone; for drama or excitement, make the story engaging with conflict or high stakes.
 
 ### Output Format
 Return a valid **JSON object** with the following structure:
-- `"title"`: An engaging title in the **base language**.
-- `"setting"`: A short setup in the **base language** explaining the story background, tailored to the user's interest.
+- `"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.
 - `"content"`: A list of **6–10 segments**, each containing:
-  - `"speaker"`: Name or role of the speaker, in the **base language** (e.g., "Narrator", "Dr. Lee", "The Coach").
+  - `"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**.
-  - `"phonetics"`: Standardized phonetic transcription (IPA, Pinyin, etc.) if applicable and meaningful. Omit if unavailable or not helpful.
-  - `"base_language_translation"`: A simple, accurate translation in the **base 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 astronomy, create a stargazing story; if they study law, make it a courtroom dialogue.
-- Include real terminology or realistic situations from the domain to make learning feel useful and immersive.
-- Vary tone and vocabulary complexity according to user level cues (beginner = simpler structure, intermediate = more natural dialogue, advanced = idiomatic expressions).
-- Keep pacing tight — avoid overly long narration or exposition.
+- 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:
@@ -170,61 +213,50 @@ Return only the final **JSON object**. Do not include:
 - Markdown formatting
 
 ### Example User Input
-"Funny story for intermediate Spanish learner about cooking hobby (base: English)"
+"Funny story for intermediate French learner about cooking hobby (base: English)"
 
-### Example Output (Spanish)
+### Example Output (French)
+```json
 {
-  "title": "The Paella Panic",
-  "setting": "Carlos attempts to impress his friends by cooking authentic Spanish paella for the first time.",
+  "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": "Narrator",
-      "target_language_text": "Carlos miró la receta de paella. Parecía fácil.",
-      "phonetics": "'karlos mi'ro la re'θeta de pa'eʎa pare'θia 'faθil",
-      "base_language_translation": "Carlos looked at the paella recipe. It seemed easy."
+      "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": "Carlos",
-      "target_language_text": "¡Azafrán! Necesito azafrán. ¿Dónde está el azafrán?",
-      "phonetics": "aθa'fran neθe'sito aθa'fran 'donde es'ta el aθa'fran",
-      "base_language_translation": "Saffron! I need saffron. Where is the saffron?"
+      "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?"
     },
-    ...
-  ]
-}
-
-### Example User Input (Chinese)
-"Conversation between two friends in a coffee shop (base: English)"
-
-### Example Output (Chinese)
-{
-  "title": "A Coffee Shop Chat",
-  "setting": "Two friends meet in a coffee shop and discuss their weekend plans.",
-  "content": [
     {
-      "speaker": "Friend 1",
-      "target_language_text": "你周末有什么计划吗？",
-      "phonetics": "nǐ zhōumò yǒu shénme jìhuà ma?",
-      "base_language_translation": "Do you have any plans for the weekend?"
+      "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": "Friend 2",
-      "target_language_text": "我打算去爬山，放松一下。你呢？",
-      "phonetics": "wǒ dǎsuàn qù páshān, fàngsōng yīxià. nǐ ne?",
-      "base_language_translation": "I plan to go hiking and relax. How about you?"
+      "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": "Friend 1",
-      "target_language_text": "我可能会去看电影。最近有几部不错的电影。",
-      "phonetics": "wǒ kěnéng huì qù kàn diànyǐng. zuìjìn yǒu jǐ bù bùcuò de diànyǐng.",
-      "base_language_translation": "I might go watch a movie. There are a few good ones recently."
+      "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": "Friend 2",
-      "target_language_text": "听起来不错！我也想看电影。你有什么推荐的？",
-      "phonetics": "tīng qǐlái bùcuò! wǒ yě xiǎng kàn diànyǐng. nǐ yǒu shénme tuījiàn de?",
-      "base_language_translation": "Sounds good! I also want to watch a movie. Do you have any recommendations?"
+      "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?"
     }
   ]
 }
-"""
+"""

backend/main.py

@@ -7,8 +7,9 @@ from backend import config
 from backend.database import get_db_connection
 import psycopg2
 from psycopg2.extras import RealDictCursor
-from typing import Union, List, Literal
+from typing import Union, List, Literal, Optional
 import logging
+import json
 
 logging.basicConfig(level=logging.INFO)
 
@@ -46,6 +47,11 @@ class GenerationRequest(BaseModel):
 class MetadataRequest(BaseModel):
     query: str
 
+# Global metadata variables
+native_language: Optional[str] = None
+target_language: Optional[str] = None
+proficiency: Optional[str] = None
+
 @app.get("/")
 async def root():
     return {"message": "Welcome to the AI Learning Assistant API!"}
@@ -53,14 +59,18 @@ async def root():
 @app.post("/extract/metadata")
 async def extract_metadata(data: MetadataRequest):
     try:
-        logging.info(f"Received metadata extraction request: {data.query}")
-        response = await generate_completions.get_completions(
+        response_str = await generate_completions.get_completions(
             data.query,
             config.language_metadata_extraction_prompt
         )
+        metadata_dict = json.loads(response_str)
+        # 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')
         return JSONResponse(
             content={
-                "data": response,
+                "data": metadata_dict,
                 "type": "language_metadata",
                 "status": "success"
             },
@@ -72,10 +82,16 @@ async def extract_metadata(data: MetadataRequest):
 @app.post("/generate/flashcards")
 async def generate_flashcards(data: GenerationRequest):
     try:
-        # logging.info(f"Received flashcard generation request: {data.query}")
+        # Use previously extracted metadata
+        instructions = (
+            config.flashcard_mode_instructions
+            .replace("{native_language}", native_language or "unknown")
+            .replace("{target_language}", target_language or "unknown")
+            .replace("{proficiency}", proficiency or "unknown")
+        )
         response = await generate_completions.get_completions(
             data.query,
-            config.flashcard_mode_instructions
+            instructions
         )
         return JSONResponse(
             content={
@@ -88,16 +104,20 @@ async def generate_flashcards(data: GenerationRequest):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-
 @app.post("/generate/exercises")
 async def generate_exercises(data: GenerationRequest):
     try:
-        # logging.info(f"Received exercise generation request: {data.query}")
+        # Use previously extracted metadata
+        instructions = (
+            config.exercise_mode_instructions
+            .replace("{native_language}", native_language or "unknown")
+            .replace("{target_language}", target_language or "unknown")
+            .replace("{proficiency}", proficiency or "unknown")
+        )
         response = await generate_completions.get_completions(
             data.query,
-            config.exercise_mode_instructions
+            instructions
         )
-        # adjust the response similar to generate_flashcards
         return JSONResponse(
             content={
                 "data": response,
@@ -109,16 +129,20 @@ async def generate_exercises(data: GenerationRequest):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-
 @app.post("/generate/simulation")
 async def generate_simulation(data: GenerationRequest):
     try:
-        # logging.info(f"Received simulation generation request: {data.query}")
+        # Use previously extracted metadata
+        instructions = (
+            config.simulation_mode_instructions
+            .replace("{native_language}", native_language or "unknown")
+            .replace("{target_language}", target_language or "unknown")
+            .replace("{proficiency}", proficiency or "unknown")
+        )
         response = await generate_completions.get_completions(
             data.query,
-            config.simulation_mode_instructions
+            instructions
         )
-        # adjust the response similar to generate_flashcards
         return JSONResponse(
             content={
                 "data": response,