increasing number of workers

.dockerignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.git/
+.env
+.DS_Store

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.10
+FROM python:3.12-slim
 
 COPY ./ ./
 
@@ -6,5 +6,5 @@ COPY ./ ./
 RUN pip install --no-cache --upgrade -r /requirements.txt
 
 # Start the application
-CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "2"]
 

prev_backend_v1/prev_backend_v/config.py

@@ -0,0 +1,350 @@
+language_metadata_extraction_prompt = """
+You are a language learning assistant. Your task is to analyze the user's input and infer their:
+- 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)
+
+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>"
+}
+
+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.
+"""
+
+curriculum_instructions = """
+# Metadata:
+# Native language: {native_language}
+# 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.
+
+### 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."
+
+### 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"
+      ]
+    }
+  ]
+}
+"""
+flashcard_mode_instructions = """
+# 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>"},
+  ...
+]
+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.
+
+### 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.
+
+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.
+
+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).
+
+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.
+
+### 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."}
+]
+"""
+
+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.
+
+### 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:
+[
+  {"role": "user", "content": "<user input or query>"},
+  {"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).
+
+### 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.
+
+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.
+
+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.
+
+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. **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** 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.
+
+### Example Query and Expected Output
+
+#### Example Query:
+User: "Beginner French exercises about my work in marketing (native: English)"
+
+#### Example 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"]}
+]
+"""
+
+simulation_mode_instructions = """
+# 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:
+[
+  {"role": "user", "content": "<user input>"},
+  {"role": "assistant", "content": "<last generated story>"}
+]
+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:
+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 **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 **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 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?"
+    }
+  ]
+}
+"""

prev_backend_v1/prev_backend_v/database.py

@@ -0,0 +1,293 @@
+import psycopg2
+import os
+from psycopg2 import sql
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Database Configuration from environment variables
+DB_NAME = os.getenv("POSTGRES_DB", "linguaai")
+DB_USER = os.getenv("POSTGRES_USER", "linguaai_user")
+DB_PASSWORD = os.getenv("POSTGRES_PASSWORD", "LinguaAI1008")
+DB_HOST = os.getenv("DB_HOST", "localhost")
+DB_PORT = os.getenv("DB_PORT", "5432")
+
+# SQL Schema Definition
+SCHEMA_SQL = """
+-- Drop existing objects if they exist
+-- Note: Some drops below might be for tables not defined in this specific script.
+DROP TABLE IF EXISTS user_activity_progress CASCADE;
+DROP TABLE IF EXISTS activities CASCADE;
+DROP TABLE IF EXISTS weekly_modules CASCADE;
+DROP TABLE IF EXISTS curriculums CASCADE;
+DROP TABLE IF EXISTS generated_flashcards CASCADE;
+DROP TABLE IF EXISTS flashcard_sets CASCADE;          -- Corrected name
+DROP TABLE IF EXISTS generated_exercises CASCADE;
+DROP TABLE IF EXISTS exercise_sets CASCADE;           -- Corrected name
+DROP TABLE IF EXISTS simulations CASCADE;             -- Corrected name
+DROP TABLE IF EXISTS users CASCADE;
+DROP TYPE IF EXISTS activity_status CASCADE;
+
+-- Table `users`
+CREATE TABLE users (
+    user_id SERIAL PRIMARY KEY,
+    username VARCHAR(50) UNIQUE NOT NULL,
+    email VARCHAR(100) UNIQUE NOT NULL,
+    password_hash VARCHAR(255) NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Trigger function (remains the same)
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = now();
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- Trigger for users (remains the same)
+CREATE TRIGGER users_update_updated_at
+    BEFORE UPDATE ON users
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+
+-- ============================================
+-- Tables for Generated Content (Flashcards)
+-- ============================================
+
+-- Table `flashcard_sets` (Represents one request/query)
+CREATE TABLE flashcard_sets (
+    id SERIAL PRIMARY KEY,
+    user_id INTEGER NOT NULL REFERENCES users(user_id), -- Added FK reference for completeness
+    query TEXT NOT NULL,
+    flashcards JSONB NOT NULL,  -- Stores an array of 5 flashcards
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP -- Added updated_at for consistency
+);
+
+CREATE INDEX idx_flashcard_set_user ON flashcard_sets(user_id);
+
+-- Corrected Trigger definition for flashcard_sets
+CREATE TRIGGER flashcard_sets_update_updated_at      -- Renamed trigger
+    BEFORE UPDATE ON flashcard_sets                  -- Corrected table name
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();     -- Assumes you want updated_at here too
+
+-- Table `generated_flashcards` (Individual flashcards within a set)
+CREATE TABLE generated_flashcards (
+    flashcard_id SERIAL PRIMARY KEY,
+    set_id INT NOT NULL REFERENCES flashcard_sets(id) ON DELETE CASCADE, -- Corrected FK reference (table and column)
+    word TEXT NOT NULL,
+    definition TEXT NOT NULL,
+    example TEXT, -- Example might be optional
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_flashcard_set ON generated_flashcards(set_id);
+
+-- Trigger for generated_flashcards (remains the same)
+CREATE TRIGGER generated_flashcards_update_updated_at
+    BEFORE UPDATE ON generated_flashcards
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+
+-- ============================================
+-- Tables for Generated Content (Exercises)
+-- ============================================
+
+-- Table `exercise_sets` (Represents one request/query) -- Corrected comment
+CREATE TABLE exercise_sets (
+    id SERIAL PRIMARY KEY,
+    user_id INTEGER NOT NULL REFERENCES users(user_id), -- Added FK reference for completeness
+    query TEXT NOT NULL,
+    exercises JSONB NOT NULL,  -- Array of 5 exercises
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP -- Added updated_at for consistency
+);
+
+CREATE INDEX idx_exercise_set_user ON exercise_sets(user_id); -- Corrected table name (was already correct but double-checked)
+
+-- Corrected Trigger definition for exercise_sets
+CREATE TRIGGER exercise_sets_update_updated_at       -- Renamed trigger
+    BEFORE UPDATE ON exercise_sets                   -- Corrected table name
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();      -- Assumes you want updated_at here too
+
+-- Table `generated_exercises` (Individual exercises within a set)
+CREATE TABLE generated_exercises (
+    exercise_id SERIAL PRIMARY KEY,
+    set_id INT NOT NULL REFERENCES exercise_sets(id) ON DELETE CASCADE, -- Corrected FK reference (table and column)
+    sentence TEXT NOT NULL,
+    answer TEXT NOT NULL,
+    choices JSONB NOT NULL, -- Storing the array of choices
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_exercise_set ON generated_exercises(set_id);
+
+-- Trigger for generated_exercises (remains the same)
+CREATE TRIGGER generated_exercises_update_updated_at
+    BEFORE UPDATE ON generated_exercises
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+
+-- ============================================
+-- Table for Generated Content (Simulations)
+-- ============================================
+
+-- Table `simulations` (Represents one simulation request/result) -- Corrected comment
+CREATE TABLE simulations (
+    id SERIAL PRIMARY KEY,
+    user_id INTEGER NOT NULL REFERENCES users(user_id), -- Added FK reference for completeness
+    query TEXT NOT NULL,
+    scenario TEXT NOT NULL,
+    dialog JSONB NOT NULL,  -- Array of turns with 'role', 'chinese', 'pinyin', 'english'
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP -- Added updated_at for consistency
+);
+
+CREATE INDEX idx_simulation_user ON simulations(user_id); -- Corrected table name
+
+-- Corrected Trigger definition for simulations
+CREATE TRIGGER simulations_update_updated_at       -- Renamed trigger
+    BEFORE UPDATE ON simulations                   -- Corrected table name
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();      -- Assumes you want updated_at here too
+"""
+
+def get_db_connection():
+    """Get a synchronous database connection."""
+    try:
+        conn = psycopg2.connect(
+            dbname=DB_NAME,
+            user=DB_USER,
+            password=DB_PASSWORD,
+            host=DB_HOST,
+            port=DB_PORT
+        )
+        return conn
+    except psycopg2.Error as e:
+        print(f"Database connection error: {e}")
+        raise
+
+def reset_sequences():
+    """Generate SQL to reset all sequences (auto-incrementing IDs) to 1."""
+    sequences_sql = """
+    SELECT 'ALTER SEQUENCE ' || sequence_name || ' RESTART WITH 1;'
+    FROM information_schema.sequences
+    WHERE sequence_schema = 'public';
+    """
+    return sequences_sql
+
+def reset_database(confirm=True):
+    """Reset the database by dropping all tables and recreating them."""
+    if confirm:
+        user_confirm = input("WARNING: This will DELETE ALL DATA. Type 'yes' to proceed: ")
+        if user_confirm.lower() != 'yes':
+            print("Database reset cancelled.")
+            return
+
+    conn = None
+    try:
+        conn = get_db_connection()
+        conn.autocommit = False
+        print("Database connection established.")
+
+        with conn.cursor() as cur:
+            print("Dropping and recreating schema...")
+            # Execute the main schema SQL (includes drops)
+            cur.execute(SCHEMA_SQL)
+            print("Schema recreated successfully.")
+
+            # Generate and execute sequence reset SQL
+            print("Resetting sequences...")
+            reset_sql_query = reset_sequences()
+            cur.execute(reset_sql_query)
+            reset_commands = cur.fetchall()
+            for command in reset_commands:
+                cur.execute(command[0])
+            print("Sequences reset successfully.")
+
+        conn.commit()
+        print("Database reset complete.")
+
+    except psycopg2.Error as e:
+        print(f"Database error during reset: {e}")
+        if conn:
+            conn.rollback()
+            print("Transaction rolled back.")
+    except Exception as e:
+        print(f"An unexpected error occurred during reset: {e}")
+        if conn:
+            conn.rollback()
+    finally:
+        if conn:
+            conn.close()
+            print("Database connection closed.")
+
+def setup_database(confirm=True):
+    """Set up the database schema if tables do not exist."""
+    if confirm:
+        user_confirm = input("Do you want to set up the database? Type 'yes' to proceed: ")
+        if user_confirm.lower() != 'yes':
+            print("Database setup cancelled.")
+            return
+
+    conn = None
+    try:
+        conn = get_db_connection()
+        conn.autocommit = False
+        print("Database connection established.")
+
+        with conn.cursor() as cur:
+            print("Checking if tables exist...")
+            cur.execute("""
+                SELECT EXISTS (
+                    SELECT FROM information_schema.tables
+                    WHERE table_schema = 'public'
+                    AND table_name = 'users'
+                );
+            """)
+            tables_exist = cur.fetchone()[0]
+
+            if tables_exist:
+                print("Tables already exist. Use reset_database() to reset the database or run setup with confirm=False.")
+                conn.rollback() # Rollback as no changes should be made
+                return
+
+            print("Creating schema...")
+            cur.execute(SCHEMA_SQL)
+            print("Schema created successfully.")
+
+        conn.commit()
+        print("Database setup complete.")
+
+    except psycopg2.Error as e:
+        print(f"Database error during setup: {e}")
+        if conn:
+            conn.rollback()
+            print("Transaction rolled back.")
+    except Exception as e:
+        print(f"An unexpected error occurred during setup: {e}")
+        if conn:
+            conn.rollback()
+    finally:
+        if conn:
+            conn.close()
+            print("Database connection closed.")
+
+if __name__ == "__main__":
+    action = input("Enter 'setup' to setup database or 'reset' to reset database: ").lower()
+    if action == 'reset':
+        reset_database()
+    elif action == 'setup':
+        setup_database()
+    else:
+        print("Invalid action. Use 'setup' or 'reset'.")

prev_backend_v1/prev_backend_v/main.py

@@ -0,0 +1,177 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from backend.utils import generate_completions
+from backend import config
+from backend.database import get_db_connection
+import psycopg2
+from psycopg2.extras import RealDictCursor
+from typing import Union, List, Literal, Optional
+import logging
+import json
+
+logging.basicConfig(level=logging.INFO)
+
+app = FastAPI()
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+# Dependency to get database connection
+async def get_db():
+    conn = await get_db_connection()
+    try:
+        yield conn
+    finally:
+        conn.close()
+
+class Message(BaseModel):
+    role: Literal["user", "assistant"]
+    content: str
+
+class GenerationRequest(BaseModel):
+    user_id: int
+    query: Union[str, List[Message]]
+
+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!"}
+
+@app.post("/extract/metadata")
+async def extract_metadata(data: MetadataRequest):
+    logging.info(f"Query: {data.query}")
+    try:
+        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": metadata_dict,
+                "type": "language_metadata",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/generate/curriculum")
+async def generate_curriculum(data: GenerationRequest):
+    try:
+        # Use previously extracted metadata
+        instructions = (
+            config.curriculum_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,
+            instructions
+        )
+        return JSONResponse(
+            content={
+                "data": response,
+                "type": "curriculum",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/generate/flashcards")
+async def generate_flashcards(data: GenerationRequest):
+    try:
+        # 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,
+            instructions
+        )
+        return JSONResponse(
+            content={
+                "data": response,
+                "type": "flashcards",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/generate/exercises")
+async def generate_exercises(data: GenerationRequest):
+    try:
+        # 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,
+            instructions
+        )
+        return JSONResponse(
+            content={
+                "data": response,
+                "type": "exercises",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/generate/simulation")
+async def generate_simulation(data: GenerationRequest):
+    try:
+        # 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,
+            instructions
+        )
+        return JSONResponse(
+            content={
+                "data": response,
+                "type": "simulation",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

prev_backend_v1/prev_backend_v/utils/generate_completions.py

@@ -0,0 +1,107 @@
+from openai import AsyncOpenAI, OpenAI
+import asyncio
+import json
+from typing import AsyncIterator
+from typing import Union, List, Dict, Literal
+from dotenv import load_dotenv
+import os
+from pydantic import BaseModel
+load_dotenv()
+
+# Initialize the async client
+client = AsyncOpenAI(
+    base_url=os.getenv("BASE_URL"),
+    api_key=os.getenv("API_KEY"),
+)
+
+class Message(BaseModel):
+    role: Literal["user", "assistant"]
+    content: str
+
+# Helper function to flatten chat messages into a single string prompt
+def flatten_messages(messages: List[Message]) -> str:
+    return "\n".join([f"{m.role}: {m.content}" for m in messages])
+
+def process_input(data: Union[str, List[Dict[str, str]]]) -> Union[str, List[Dict[str, str]]]:
+    """
+    Processes input to either uppercase a string or modify the 'content' field
+    of a list of dictionaries.
+    """
+    if isinstance(data, str):
+        return data.strip()  # Ensures prompt is cleaned up (optional)
+
+    elif isinstance(data, list):
+        # Ensure each item in the list is a dictionary with a 'content' key
+        return [
+            {**item, "content": item["content"].strip()}  # Trims whitespace in 'content'
+            for item in data if isinstance(item, dict) and "content" in item
+        ]
+    
+    else:
+        raise TypeError("Input must be a string or a list of dictionaries with a 'content' field")
+
+
+# async def get_completions(
+#     prompt: Union[str, List[Dict[str, str]]],
+#     instructions: str
+# ) -> str:
+#     processed_prompt = process_input(prompt)  # Ensures the input format is correct
+
+#     if isinstance(processed_prompt, str):
+#         messages = [
+#             {"role": "system", "content": instructions},
+#             {"role": "user", "content": processed_prompt}
+#         ]
+#     elif isinstance(processed_prompt, list):
+#         messages = [{"role": "system", "content": instructions}] + processed_prompt
+#     else:
+#         raise TypeError("Unexpected processed input type.")
+
+#     response = await client.chat.completions.create(
+#         model=os.getenv("MODEL"),
+#         messages=messages,
+#         response_format={"type": "json_object"}
+#     )
+
+#     output: str = response.choices[0].message.content
+#     return output
+
+async def get_completions(
+    prompt: Union[str, List[Dict[str, str]]],
+    instructions: str
+) -> str:
+    if isinstance(prompt, list):
+        formatted_query = flatten_messages(prompt)
+    else:
+        formatted_query = prompt
+
+    processed_prompt = process_input(formatted_query)
+
+    messages = [{"role": "system", "content": instructions}]
+
+    if isinstance(processed_prompt, str):
+        messages.append({"role": "user", "content": processed_prompt})
+
+    elif isinstance(processed_prompt, list):
+        # Only keep the history for context and append the latest user query at the end
+        history = processed_prompt[:-1]
+        last_user_msg = processed_prompt[-1]
+
+        # Optional: Validate that the last message is from the user
+        if last_user_msg.get("role") != "user":
+            raise ValueError("Last message must be from the user.")
+
+        messages += history
+        messages.append(last_user_msg)
+
+    else:
+        raise TypeError("Unexpected processed input type.")
+
+    # print(os.getenv("MODEL"))
+    response = await client.chat.completions.create(
+        model=os.getenv("MODEL"),
+        messages=messages,
+        response_format={"type": "json_object"}
+    )
+
+    return response.choices[0].message.content  # adjust based on your client

prev_backend_v2/backend/config.py

@@ -0,0 +1,226 @@
+language_metadata_extraction_prompt = """
+You are a language learning assistant. Your task is to analyze the user's input and infer their:
+- 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": "<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:
+- 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 = """
+# Metadata:
+# Native language: {native_language}
+# Target language: {target_language}
+# Proficiency level: {proficiency}
+
+You are an AI-powered language learning assistant tasked with generating an extensive, personalized curriculum. Your goal is to help the user learn {target_language} by designing a 25-lesson curriculum that reflects the user's goals, interests, and proficiency level. All outputs should be written in {native_language}.
+
+### Curriculum Goals:
+- Provide 25 lessons.
+- Ensure logical progression from basic to advanced topics (according to {proficiency}).
+- Align each lesson with a practical communication goal.
+- Tailor vocabulary and sub-topics to the user’s intended use (e.g., work, travel, hobbies, daily life).
+
+### Instructions:
+
+1. **Define the Lesson Series (Overall Theme):**
+   - Choose a main theme relevant to the user's motivation for learning {target_language} (e.g., "Living in a new country", "Professional communication", "Traveling in {target_language}-speaking regions").
+   - The theme should guide the tone, content, and scope of the entire 25-lesson sequence.
+
+2. **Divide the Curriculum into 25 Thematic Lessons:**
+   - Each lesson should have a clear focus (e.g., asking for help, describing your job, booking accommodation).
+   - Sequence lessons to build from foundational topics to more complex, specialized language use.
+   - Vary grammar, vocabulary, and communication functions across lessons to avoid repetition and ensure comprehensive coverage.
+
+3. **Describe Each Lesson Clearly and Concisely:**
+   For each of the 25 lessons, provide:
+   - "sub_topic": A clear and practical lesson title in {native_language}.
+   - "keywords": A list of 1–3 high-level categories in {native_language} that describe the lesson focus (e.g., "directions", "daily routine", "formal conversation").
+   - "description": One sentence in {native_language} that explains what the learner will achieve or be able to do after completing the lesson. Be specific and learner-oriented.
+
+### Output Format:
+Return a valid JSON object with:
+- "lesson_topic": The overall learning theme (in {native_language}).
+- "sub_topics": A list of 25 items. Each item must include:
+   - "sub_topic": A short title of the lesson (in {native_language}).
+   - "keywords": A list of 1–3 general-purpose categories (in {native_language}).
+   - "description": One clear sentence (in {native_language}) describing the purpose of the lesson.
+
+Avoid:
+- Using overly generic or repetitive titles or descriptions.
+- Keyword lists with only one-word entries (e.g., use "ordering in a restaurant" instead of "food").
+- Abstract lessons with no real-world relevance.
+
+Ensure the curriculum builds toward user fluency in relevant contexts.
+"""
+
+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 learners reinforce vocabulary and grammar through realistic, domain-specific practice. You support any language.
+
+### Input Format
+You will receive a structured lesson or topic description (e.g., text excerpt, dialogue, thematic scenario). For example, this could be a short paragraph about daily routines, a dialogue between a customer and a shopkeeper, or a scenario involving travel planning. Use it to:  
+- Identify 5 concrete vocabulary items or grammar points suited to the learner’s immediate needs.  
+- Ground each exercise in a specific, vivid scenario.  
+- Reflect real-world tasks or conversations the learner will encounter.
+
+### Generation Guidelines
+1. **Metadata usage**  
+   - **Native language**: Use {native_language} for all explanations.  
+   - **Target language**: Use {target_language} for sentences, answers, and choices.  
+   - **Proficiency**:  
+     - *Beginner*: Focus on high-frequency vocabulary and simple grammar structures, such as present tense, basic prepositions, and common nouns and verbs.  
+     - *Intermediate*: Incorporate a mix of common and thematic vocabulary, and introduce one new tense or grammatical structure per exercise.  
+     - *Advanced*: Use domain-specific terminology, idiomatic expressions, and complex syntax to challenge learners.
+
+2. **Sentence specificity**  
+   - Craft each sentence around a concrete action, object, or event (e.g., “At the café counter, she ___ her order,” not “I want to ___”). To make exercises more engaging, consider adding details that paint a vivid picture, such as specific locations, times, or characters. For instance, use "On a sunny Saturday morning, Maria is heading to the local farmers' market to buy fresh produce" instead of "I am going to the store."  
+   - Avoid “template” prompts like “I am going to ___” or “I like to ___” without added context.  
+   - Each sentence must clearly point to one—and only one—correct word or structure.
+
+3. **Unique, unambiguous answers**  
+   - Design each prompt so distractors could be grammatically plausible but contextually impossible. For example, if the sentence is "She ___ the book on the table," and the correct answer is "put," ensure only "put" fits the context, while distractors like "placed," "set," or "laid" are plausible but incorrect here.  
+   - Ensure there is no secondary interpretation that could validate another choice.
+
+4. **Plausible distractors**  
+   - Provide four total options: one correct, three context-related but incorrect.  
+   - Distractors must belong to the same word class (noun, verb, adjective, etc.) and semantic field.  
+   - Shuffle answer positions randomly.  
+   - Ensure distractors are not too similar to the correct answer to avoid confusion.
+
+5. **Explanations**  
+   - Offer a concise 1–2-sentence rationale in {native_language}, explaining why the correct answer fits this very context and briefly noting why each distractor fails. If space allows, consider adding a brief example or analogy to reinforce the learning point.
+
+### Output Format
+Return exactly **5** cloze-style exercises as a **JSON array**, each element with:  
+- `"sentence"`: A fully contextualized sentence in {target_language} containing one blank (`___`).  
+- `"answer"`: The single correct fill-in, in {target_language}.  
+- `"choices"`: A list of four total options (in randomized order), all in {target_language}.  
+- `"explanation"`: A concise note in {native_language} clarifying the correct answer and why others don’t fit.  
+
+_Do not wrap the array in any additional objects or metadata—output only the raw JSON array._
+"""
+
+flashcard_mode_instructions = """
+# 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 goal is to help users learn rapidly by generating personalized flashcards from lesson-based content.
+
+### Input Format
+You will receive a structured lesson as input (text, dialogue, or vocabulary list). Use this input to:
+- Identify new or useful vocabulary terms.
+- Extract contextually relevant and domain-specific language.
+- Ensure that flashcards reflect the lesson's language, style, and purpose.
+
+### Generation Guidelines
+When generating flashcards:
+1. **Use the provided metadata**:
+   - **Native language**: Use {native_language} for definitions.
+   - **Target language**: Extract and present vocabulary and examples in {target_language}.
+   - **Proficiency level**: Adjust vocabulary complexity based on {proficiency}:
+     - *Beginner*: High-frequency, essential words.
+     - *Intermediate*: Broader, topic-specific terms and common collocations.
+     - *Advanced*: Nuanced, idiomatic, or technical vocabulary.
+
+2. **Contextual relevance**:
+   - Flashcards should reflect the themes, activities, or domain of the lesson input (e.g., cooking, business, travel).
+   - Ensure that example sentences are directly related to the input content and sound natural in use.
+
+3. **Avoid redundancy**:
+   - Select terms that are novel, useful, or not overly repetitive within the lesson.
+   - Prioritize terms that learners are likely to encounter again in real-world usage.
+
+### Flashcard Format
+Generate exactly **10 flashcards** as a **valid JSON array**, with each flashcard containing:
+- `"word"`: A key word or phrase in {target_language} drawn from the lesson.
+- `"definition"`: A learner-friendly explanation in {native_language}.
+- `"example"`: A clear, natural sentence in {target_language} demonstrating the word **in context with the lesson**.
+"""
+
+simulation_mode_instructions = """
+# Metadata:
+# Native language: {native_language}
+# Target language: {target_language}
+# Proficiency level: {proficiency}
+
+You are a **creative, context-aware storytelling engine**. Your task is to generate short, engaging stories or dialogues in **any language** to make language learning enjoyable, memorable, and relevant. Stories must reflect the user's interests, profession, or hobbies, and align with their learning level.
+
+### Input Format
+You will receive a user-provided **lesson topic, theme, or domain of interest** (e.g., “a courtroom drama for a law student” or “space mission dialogue for a space enthusiast”). Use this input to:
+- Personalize characters, setting, and vocabulary.
+- Make the story both educational and entertaining.
+- Ensure the language reflects real-world use in that context.
+
+### Story Generation Task
+1. **Use the provided metadata**:
+   - **Native language**: Present explanations, setup, and translations in {native_language}.
+   - **Target language**: Write dialogue and narration in {target_language}.
+   - **Proficiency level**: Match language complexity to {proficiency}:
+     - *Beginner*: Simple grammar, short sentences, high-frequency vocabulary.
+     - *Intermediate*: Natural sentence flow, basic narrative devices, slightly challenging vocabulary.
+     - *Advanced*: Complex structures, idiomatic expressions, domain-specific language.
+
+2. **Domain relevance**:
+   - Base the story or dialogue on the user’s interests or specified topic.
+   - Integrate relevant vocabulary and situations (e.g., a chef character using cooking terms, or a pilot discussing navigation).
+
+3. **Engagement and originality**:
+   - Make the story fun, dramatic, or surprising to increase engagement.
+   - Avoid clichés and repetition—each story should be fresh and imaginative.
+   - Vary tone and structure depending on the theme (e.g., suspenseful for a mystery, humorous for a slice-of-life scene).
+
+4. **Educational value**:
+   - Use natural-sounding language learners would benefit from hearing or using.
+   - Provide translations and (where helpful) phonetic transcription to support pronunciation and comprehension.
+
+### Output Format
+Return a valid **JSON object** with the following structure:
+- `"title"`: An engaging title in {native_language}.
+- `"setting"`: A brief setup paragraph in {native_language} explaining the story’s background and relevance to the user’s interest.
+- `"content"`: A list of **10 segments**, each structured as:
+  - `"speaker"`: A named or role-based character label in {native_language} (e.g., "Narrator", "Captain Li", "The Botanist").
+  - `"target_language_text"`: The sentence or dialogue line in {target_language}.
+  - `"phonetics"`: A phonetic transcription (IPA, Pinyin, etc.), only if helpful or relevant for the target language.
+  - `"base_language_translation"`: A simple, clear translation in {native_language}.
+
+Ensure that all entries are structured cleanly and consistently. Do not wrap the result in additional containers or metadata.
+"""

prev_backend_v2/backend/database.py

@@ -0,0 +1,293 @@
+import psycopg2
+import os
+from psycopg2 import sql
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Database Configuration from environment variables
+DB_NAME = os.getenv("POSTGRES_DB", "linguaai")
+DB_USER = os.getenv("POSTGRES_USER", "linguaai_user")
+DB_PASSWORD = os.getenv("POSTGRES_PASSWORD", "LinguaAI1008")
+DB_HOST = os.getenv("DB_HOST", "localhost")
+DB_PORT = os.getenv("DB_PORT", "5432")
+
+# SQL Schema Definition
+SCHEMA_SQL = """
+-- Drop existing objects if they exist
+-- Note: Some drops below might be for tables not defined in this specific script.
+DROP TABLE IF EXISTS user_activity_progress CASCADE;
+DROP TABLE IF EXISTS activities CASCADE;
+DROP TABLE IF EXISTS weekly_modules CASCADE;
+DROP TABLE IF EXISTS curriculums CASCADE;
+DROP TABLE IF EXISTS generated_flashcards CASCADE;
+DROP TABLE IF EXISTS flashcard_sets CASCADE;          -- Corrected name
+DROP TABLE IF EXISTS generated_exercises CASCADE;
+DROP TABLE IF EXISTS exercise_sets CASCADE;           -- Corrected name
+DROP TABLE IF EXISTS simulations CASCADE;             -- Corrected name
+DROP TABLE IF EXISTS users CASCADE;
+DROP TYPE IF EXISTS activity_status CASCADE;
+
+-- Table `users`
+CREATE TABLE users (
+    user_id SERIAL PRIMARY KEY,
+    username VARCHAR(50) UNIQUE NOT NULL,
+    email VARCHAR(100) UNIQUE NOT NULL,
+    password_hash VARCHAR(255) NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Trigger function (remains the same)
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = now();
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- Trigger for users (remains the same)
+CREATE TRIGGER users_update_updated_at
+    BEFORE UPDATE ON users
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+
+-- ============================================
+-- Tables for Generated Content (Flashcards)
+-- ============================================
+
+-- Table `flashcard_sets` (Represents one request/query)
+CREATE TABLE flashcard_sets (
+    id SERIAL PRIMARY KEY,
+    user_id INTEGER NOT NULL REFERENCES users(user_id), -- Added FK reference for completeness
+    query TEXT NOT NULL,
+    flashcards JSONB NOT NULL,  -- Stores an array of 5 flashcards
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP -- Added updated_at for consistency
+);
+
+CREATE INDEX idx_flashcard_set_user ON flashcard_sets(user_id);
+
+-- Corrected Trigger definition for flashcard_sets
+CREATE TRIGGER flashcard_sets_update_updated_at      -- Renamed trigger
+    BEFORE UPDATE ON flashcard_sets                  -- Corrected table name
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();     -- Assumes you want updated_at here too
+
+-- Table `generated_flashcards` (Individual flashcards within a set)
+CREATE TABLE generated_flashcards (
+    flashcard_id SERIAL PRIMARY KEY,
+    set_id INT NOT NULL REFERENCES flashcard_sets(id) ON DELETE CASCADE, -- Corrected FK reference (table and column)
+    word TEXT NOT NULL,
+    definition TEXT NOT NULL,
+    example TEXT, -- Example might be optional
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_flashcard_set ON generated_flashcards(set_id);
+
+-- Trigger for generated_flashcards (remains the same)
+CREATE TRIGGER generated_flashcards_update_updated_at
+    BEFORE UPDATE ON generated_flashcards
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+
+-- ============================================
+-- Tables for Generated Content (Exercises)
+-- ============================================
+
+-- Table `exercise_sets` (Represents one request/query) -- Corrected comment
+CREATE TABLE exercise_sets (
+    id SERIAL PRIMARY KEY,
+    user_id INTEGER NOT NULL REFERENCES users(user_id), -- Added FK reference for completeness
+    query TEXT NOT NULL,
+    exercises JSONB NOT NULL,  -- Array of 5 exercises
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP -- Added updated_at for consistency
+);
+
+CREATE INDEX idx_exercise_set_user ON exercise_sets(user_id); -- Corrected table name (was already correct but double-checked)
+
+-- Corrected Trigger definition for exercise_sets
+CREATE TRIGGER exercise_sets_update_updated_at       -- Renamed trigger
+    BEFORE UPDATE ON exercise_sets                   -- Corrected table name
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();      -- Assumes you want updated_at here too
+
+-- Table `generated_exercises` (Individual exercises within a set)
+CREATE TABLE generated_exercises (
+    exercise_id SERIAL PRIMARY KEY,
+    set_id INT NOT NULL REFERENCES exercise_sets(id) ON DELETE CASCADE, -- Corrected FK reference (table and column)
+    sentence TEXT NOT NULL,
+    answer TEXT NOT NULL,
+    choices JSONB NOT NULL, -- Storing the array of choices
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_exercise_set ON generated_exercises(set_id);
+
+-- Trigger for generated_exercises (remains the same)
+CREATE TRIGGER generated_exercises_update_updated_at
+    BEFORE UPDATE ON generated_exercises
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+
+-- ============================================
+-- Table for Generated Content (Simulations)
+-- ============================================
+
+-- Table `simulations` (Represents one simulation request/result) -- Corrected comment
+CREATE TABLE simulations (
+    id SERIAL PRIMARY KEY,
+    user_id INTEGER NOT NULL REFERENCES users(user_id), -- Added FK reference for completeness
+    query TEXT NOT NULL,
+    scenario TEXT NOT NULL,
+    dialog JSONB NOT NULL,  -- Array of turns with 'role', 'chinese', 'pinyin', 'english'
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP -- Added updated_at for consistency
+);
+
+CREATE INDEX idx_simulation_user ON simulations(user_id); -- Corrected table name
+
+-- Corrected Trigger definition for simulations
+CREATE TRIGGER simulations_update_updated_at       -- Renamed trigger
+    BEFORE UPDATE ON simulations                   -- Corrected table name
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();      -- Assumes you want updated_at here too
+"""
+
+def get_db_connection():
+    """Get a synchronous database connection."""
+    try:
+        conn = psycopg2.connect(
+            dbname=DB_NAME,
+            user=DB_USER,
+            password=DB_PASSWORD,
+            host=DB_HOST,
+            port=DB_PORT
+        )
+        return conn
+    except psycopg2.Error as e:
+        print(f"Database connection error: {e}")
+        raise
+
+def reset_sequences():
+    """Generate SQL to reset all sequences (auto-incrementing IDs) to 1."""
+    sequences_sql = """
+    SELECT 'ALTER SEQUENCE ' || sequence_name || ' RESTART WITH 1;'
+    FROM information_schema.sequences
+    WHERE sequence_schema = 'public';
+    """
+    return sequences_sql
+
+def reset_database(confirm=True):
+    """Reset the database by dropping all tables and recreating them."""
+    if confirm:
+        user_confirm = input("WARNING: This will DELETE ALL DATA. Type 'yes' to proceed: ")
+        if user_confirm.lower() != 'yes':
+            print("Database reset cancelled.")
+            return
+
+    conn = None
+    try:
+        conn = get_db_connection()
+        conn.autocommit = False
+        print("Database connection established.")
+
+        with conn.cursor() as cur:
+            print("Dropping and recreating schema...")
+            # Execute the main schema SQL (includes drops)
+            cur.execute(SCHEMA_SQL)
+            print("Schema recreated successfully.")
+
+            # Generate and execute sequence reset SQL
+            print("Resetting sequences...")
+            reset_sql_query = reset_sequences()
+            cur.execute(reset_sql_query)
+            reset_commands = cur.fetchall()
+            for command in reset_commands:
+                cur.execute(command[0])
+            print("Sequences reset successfully.")
+
+        conn.commit()
+        print("Database reset complete.")
+
+    except psycopg2.Error as e:
+        print(f"Database error during reset: {e}")
+        if conn:
+            conn.rollback()
+            print("Transaction rolled back.")
+    except Exception as e:
+        print(f"An unexpected error occurred during reset: {e}")
+        if conn:
+            conn.rollback()
+    finally:
+        if conn:
+            conn.close()
+            print("Database connection closed.")
+
+def setup_database(confirm=True):
+    """Set up the database schema if tables do not exist."""
+    if confirm:
+        user_confirm = input("Do you want to set up the database? Type 'yes' to proceed: ")
+        if user_confirm.lower() != 'yes':
+            print("Database setup cancelled.")
+            return
+
+    conn = None
+    try:
+        conn = get_db_connection()
+        conn.autocommit = False
+        print("Database connection established.")
+
+        with conn.cursor() as cur:
+            print("Checking if tables exist...")
+            cur.execute("""
+                SELECT EXISTS (
+                    SELECT FROM information_schema.tables
+                    WHERE table_schema = 'public'
+                    AND table_name = 'users'
+                );
+            """)
+            tables_exist = cur.fetchone()[0]
+
+            if tables_exist:
+                print("Tables already exist. Use reset_database() to reset the database or run setup with confirm=False.")
+                conn.rollback() # Rollback as no changes should be made
+                return
+
+            print("Creating schema...")
+            cur.execute(SCHEMA_SQL)
+            print("Schema created successfully.")
+
+        conn.commit()
+        print("Database setup complete.")
+
+    except psycopg2.Error as e:
+        print(f"Database error during setup: {e}")
+        if conn:
+            conn.rollback()
+            print("Transaction rolled back.")
+    except Exception as e:
+        print(f"An unexpected error occurred during setup: {e}")
+        if conn:
+            conn.rollback()
+    finally:
+        if conn:
+            conn.close()
+            print("Database connection closed.")
+
+if __name__ == "__main__":
+    action = input("Enter 'setup' to setup database or 'reset' to reset database: ").lower()
+    if action == 'reset':
+        reset_database()
+    elif action == 'setup':
+        setup_database()
+    else:
+        print("Invalid action. Use 'setup' or 'reset'.")

prev_backend_v2/backend/main.py

@@ -0,0 +1,189 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from backend.utils import generate_completions
+from backend import config
+from backend.database import get_db_connection
+import psycopg2
+from psycopg2.extras import RealDictCursor
+from typing import Union, List, Literal, Optional
+import logging
+import json
+
+logging.basicConfig(level=logging.INFO)
+
+app = FastAPI()
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+# Dependency to get database connection
+async def get_db():
+    conn = await get_db_connection()
+    try:
+        yield conn
+    finally:
+        conn.close()
+
+class Message(BaseModel):
+    role: Literal["user", "assistant"]
+    content: str
+
+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
+
+# 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!"}
+
+@app.post("/extract/metadata")
+async def extract_metadata(data: MetadataRequest):
+    logging.info(f"Query: {data.query}")
+    try:
+        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', 'unknown')
+        return JSONResponse(
+            content={
+                "data": metadata_dict,
+                "type": "language_metadata",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/generate/curriculum")
+async def generate_curriculum(data: GenerationRequest):
+    try:
+        # 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}", nl)
+            .replace("{target_language}", tl)
+            .replace("{proficiency}", prof)
+        )
+        response = await generate_completions.get_completions(
+            data.query,
+            instructions
+        )
+        return JSONResponse(
+            content={
+                "data": response,
+                "type": "curriculum",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/generate/flashcards")
+async def generate_flashcards(data: GenerationRequest):
+    try:
+        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}", nl)
+            .replace("{target_language}", tl)
+            .replace("{proficiency}", prof)
+        )
+        response = await generate_completions.get_completions(
+            data.query,
+            instructions
+        )
+        return JSONResponse(
+            content={
+                "data": response,
+                "type": "flashcards",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/generate/exercises")
+async def generate_exercises(data: GenerationRequest):
+    try:
+        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}", nl)
+            .replace("{target_language}", tl)
+            .replace("{proficiency}", prof)
+        )
+        response = await generate_completions.get_completions(
+            data.query,
+            instructions
+        )
+        return JSONResponse(
+            content={
+                "data": response,
+                "type": "exercises",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/generate/simulation")
+async def generate_simulation(data: GenerationRequest):
+    try:
+        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}", nl)
+            .replace("{target_language}", tl)
+            .replace("{proficiency}", prof)
+        )
+        response = await generate_completions.get_completions(
+            data.query,
+            instructions
+        )
+        return JSONResponse(
+            content={
+                "data": response,
+                "type": "simulation",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

prev_backend_v2/backend/utils/generate_completions.py

@@ -0,0 +1,107 @@
+from openai import AsyncOpenAI, OpenAI
+import asyncio
+import json
+from typing import AsyncIterator
+from typing import Union, List, Dict, Literal
+from dotenv import load_dotenv
+import os
+from pydantic import BaseModel
+load_dotenv()
+
+# Initialize the async client
+client = AsyncOpenAI(
+    base_url=os.getenv("BASE_URL"),
+    api_key=os.getenv("API_KEY"),
+)
+
+class Message(BaseModel):
+    role: Literal["user", "assistant"]
+    content: str
+
+# Helper function to flatten chat messages into a single string prompt
+def flatten_messages(messages: List[Message]) -> str:
+    return "\n".join([f"{m.role}: {m.content}" for m in messages])
+
+def process_input(data: Union[str, List[Dict[str, str]]]) -> Union[str, List[Dict[str, str]]]:
+    """
+    Processes input to either uppercase a string or modify the 'content' field
+    of a list of dictionaries.
+    """
+    if isinstance(data, str):
+        return data.strip()  # Ensures prompt is cleaned up (optional)
+
+    elif isinstance(data, list):
+        # Ensure each item in the list is a dictionary with a 'content' key
+        return [
+            {**item, "content": item["content"].strip()}  # Trims whitespace in 'content'
+            for item in data if isinstance(item, dict) and "content" in item
+        ]
+    
+    else:
+        raise TypeError("Input must be a string or a list of dictionaries with a 'content' field")
+
+
+# async def get_completions(
+#     prompt: Union[str, List[Dict[str, str]]],
+#     instructions: str
+# ) -> str:
+#     processed_prompt = process_input(prompt)  # Ensures the input format is correct
+
+#     if isinstance(processed_prompt, str):
+#         messages = [
+#             {"role": "system", "content": instructions},
+#             {"role": "user", "content": processed_prompt}
+#         ]
+#     elif isinstance(processed_prompt, list):
+#         messages = [{"role": "system", "content": instructions}] + processed_prompt
+#     else:
+#         raise TypeError("Unexpected processed input type.")
+
+#     response = await client.chat.completions.create(
+#         model=os.getenv("MODEL"),
+#         messages=messages,
+#         response_format={"type": "json_object"}
+#     )
+
+#     output: str = response.choices[0].message.content
+#     return output
+
+async def get_completions(
+    prompt: Union[str, List[Dict[str, str]]],
+    instructions: str
+) -> str:
+    if isinstance(prompt, list):
+        formatted_query = flatten_messages(prompt)
+    else:
+        formatted_query = prompt
+
+    processed_prompt = process_input(formatted_query)
+
+    messages = [{"role": "system", "content": instructions}]
+
+    if isinstance(processed_prompt, str):
+        messages.append({"role": "user", "content": processed_prompt})
+
+    elif isinstance(processed_prompt, list):
+        # Only keep the history for context and append the latest user query at the end
+        history = processed_prompt[:-1]
+        last_user_msg = processed_prompt[-1]
+
+        # Optional: Validate that the last message is from the user
+        if last_user_msg.get("role") != "user":
+            raise ValueError("Last message must be from the user.")
+
+        messages += history
+        messages.append(last_user_msg)
+
+    else:
+        raise TypeError("Unexpected processed input type.")
+
+    # print(os.getenv("MODEL"))
+    response = await client.chat.completions.create(
+        model=os.getenv("MODEL"),
+        messages=messages,
+        response_format={"type": "json_object"}
+    )
+
+    return response.choices[0].message.content  # adjust based on your client