v2

backend/CurriculumManager/config.json

@@ -1 +0,0 @@
-{}

backend/CurriculumManager/generate_curriculum.py

@@ -1,41 +0,0 @@
-import json
-import os
-from openai import OpenAI
-from backend.config import config, CURRICULUM_INSTRUCTION
-from backend.utils import write_json_file, ensure_directory
-
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-output_dir = os.path.join(PROJECT_ROOT, "output")
-ensure_directory(output_dir)
-
-client = OpenAI(
-    api_key=config.get('api_key'),
-    base_url=config.get('base_url'),
-)
-
-def get_completion(prompt: str):
-    response = client.chat.completions.create(
-        model=config.get('model'),
-        messages=[
-            {"role": "system", "content": CURRICULUM_INSTRUCTION},
-            {"role": "user", "content": prompt},
-        ],
-        response_format={"type": "json_object"},
-    )
-
-    try:
-        data = json.loads(response.choices[0].message.content)
-        filename = os.path.join(output_dir, "curriculum.json")
-        
-        if write_json_file(filename, data):
-            print(f"JSON data saved to {filename}")
-            # Reset the config when new curriculum is generated
-            config.set("current_week", 0)
-            config.save()
-            return data  # Return the data instead of True
-        print("Failed to save data")
-        return None
-            
-    except json.JSONDecodeError as e:
-        print(f"Error decoding JSON: {e}")
-        return None

backend/LessonManager/generate_daily_lesson.py

@@ -1,38 +0,0 @@
-import json
-import os
-from openai import OpenAI
-from backend.config import config
-from backend.utils import write_json_file, ensure_directory
-
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-output_dir = os.path.join(PROJECT_ROOT, "output")
-ensure_directory(output_dir)
-
-client = OpenAI(
-    api_key=config.get('api_key'),
-    base_url=config.get('base_url'),
-)
-
-def get_completion(prompt: str):
-    response = client.chat.completions.create(
-        model=config.get('model'),
-        messages=[
-            {"role": "system", "content": config.get('daily_lesson_instruction')},
-            {"role": "user", "content": prompt},
-        ],
-        response_format={"type": "json_object"},
-    )
-
-    try:
-        data = json.loads(response.choices[0].message.content)
-        filename = f"{output_dir}/daily_lesson.json"
-        
-        if write_json_file(filename, data):
-            print(f"JSON data saved to {filename}")
-        else:
-            print("Failed to save data")
-        return data
-            
-    except json.JSONDecodeError as e:
-        print(f"Error decoding JSON: {e}")
-        return None

backend/LessonManager/generate_lesson.py

@@ -1,38 +0,0 @@
-import json
-import os
-from openai import OpenAI
-from backend.config import config
-from backend.utils import write_json_file, ensure_directory
-
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-output_dir = os.path.join(PROJECT_ROOT, "output")
-ensure_directory(output_dir)
-
-client = OpenAI(
-    api_key=config.get('api_key'),
-    base_url=config.get('base_url'),
-)
-
-def get_completion(prompt: str):
-    response = client.chat.completions.create(
-        model=config.get('model'),
-        messages=[
-            {"role": "system", "content": config.get('lesson_instruction')},
-            {"role": "user", "content": prompt},
-        ],
-        response_format={"type": "json_object"},
-    )
-
-    try:
-        data = json.loads(response.choices[0].message.content)
-        filename = f"{output_dir}/lesson.json"
-        
-        if write_json_file(filename, data):
-            print(f"JSON data saved to {filename}")
-        else:
-            print("Failed to save data")
-        return data
-            
-    except json.JSONDecodeError as e:
-        print(f"Error decoding JSON: {e}")
-        return None

backend/api.py

@@ -0,0 +1,39 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi import Request
+import uvicorn
+from pydantic import BaseModel, Field
+from typing import Union, List, Dict
+import json
+import asyncio
+from backend.utils import get_completion
+from backend.config import CURRICULUM_INSTRUCTIONS
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Define a request model
+class QueryRequest(BaseModel):
+    user_query: str
+
+# Define a response model
+class QueryResponse(BaseModel):
+    answer: str
+
+@app.get("/")
+async def root():
+    return {"message": "Hello World"}
+
+@app.post("/curriculum")
+async def get_curriculum(request: QueryRequest):
+    query = request.user_query
+    response = await get_completion(prompt=query, instruction=CURRICULUM_INSTRUCTIONS)
+    return JSONResponse(response, media_type="application/json")

backend/api/__init__.py

@@ -1 +0,0 @@
-# Empty init file

backend/api/app.py

@@ -1,85 +0,0 @@
-import os
-import socket
-from fastapi import FastAPI, HTTPException
-from .models import CurriculumRequest, LessonRequest, DailyLessonRequest
-from backend.CurriculumManager.generate_curriculum import get_completion as generate_curriculum
-from backend.LessonManager.generate_lesson import get_completion as generate_lesson
-from backend.LessonManager.generate_daily_lesson import get_completion as generate_daily_lesson
-from backend.config_manager import Config
-from backend.utils import read_json_file, ensure_directory
-
-# Set up paths correctly
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-CONFIG_DIR = os.path.join(PROJECT_ROOT, "backend")
-CONFIG_PATH = os.path.join(CONFIG_DIR, "config.json")
-
-# Ensure config directory exists
-ensure_directory(CONFIG_DIR)
-
-# Import and run config setup
-from backend.config import (
-    CURRICULUM_INSTRUCTION,
-    MODEL,
-    BASE_URL,
-    API_KEY,
-    API_PORT
-)
-
-app = FastAPI(title="AI Language Tutor API")
-config = Config(CONFIG_PATH)
-
-# Initialize config with default values if not exists
-if not config.data:
-    config.set("curriculum_instruction", CURRICULUM_INSTRUCTION)
-    config.set("model", MODEL)
-    config.set("base_url", BASE_URL)
-    config.set("api_key", API_KEY)
-    config.save()
-
-@app.post("/curriculum")
-async def create_curriculum(request: CurriculumRequest):
-    try:
-        return generate_curriculum(request.prompt)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/lesson")
-async def create_lesson(request: LessonRequest):
-    try:
-        # Simulate args object for compatibility
-        class Args:
-            def __init__(self, week):
-                self.week = week
-        
-        args = Args(request.week)
-        from backend.main import setup_lesson_instruction
-        
-        setup_lesson_instruction(args)
-        return generate_lesson(config.get("lesson_prompt"))
-    except FileNotFoundError:
-        raise HTTPException(status_code=404, detail="Curriculum not found")
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-@app.post("/daily-lesson")
-async def create_daily_lesson(request: DailyLessonRequest):
-    try:
-        class Args:
-            def __init__(self, week, day):
-                self.week = week
-                self.day = day
-        
-        args = Args(request.week, request.day)
-        from backend.main import setup_daily_lesson
-        
-        return setup_daily_lesson(args)
-    except FileNotFoundError:
-        raise HTTPException(status_code=404, detail="Lesson plan not found")
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-# Add Args class at module level
-class Args:
-    def __init__(self, week=0, day=0):
-        self.week = week
-        self.day = day

backend/api/models.py

@@ -1,11 +0,0 @@
-from pydantic import BaseModel
-
-class CurriculumRequest(BaseModel):
-    prompt: str
-
-class LessonRequest(BaseModel):
-    week: int = 0
-
-class DailyLessonRequest(BaseModel):
-    week: int = 0
-    day: int = 0

backend/config.json

@@ -1,12 +0,0 @@
-{
-    "curriculum_instruction": "\nYou are an expert language learning curriculum designer. Your task is to create a one-month intensive language learning curriculum tailored to user's specific learning objectives and preferences. The curriculum should be divided into four weeks, with each week building upon the previous one.\n\n**Curriculum Design Principles:**\n\n1.  **Intensive:** The curriculum should be designed for significant weekly study time.\n2.  **Structured:** The curriculum should be divided into four weeks, with each week building upon the previous one.\n3.  **Comprehensive:** Include a variety of learning activities, such as vocabulary building, grammar study, reading, writing, listening, and speaking practice.\n4.  **Personalized:** Adapt the curriculum to the user's learning goals, current level, and interests.\n5.  **Measurable:** Suggest ways the user can track their progress.\n6.  **Output Format:** Provide the curriculum in a valid JSON format.\n7.  **Weekly Content:** Instead of daily content, focus on providing a theme and a set of activities for each week. Include the approximate time the user should invest in that week.\n\n**Output JSON Format:**\n\n```json\n{\n  \"language\": \"target_language\",\n  \"learning_goal\": \"user_provided_goal\",\n  \"current_level\": \"user_provided_level\",\n  \"weeks\": [\n    {\n      \"week\": 1,\n      \"theme\": \"week_theme\",\n      \"estimated_duration\": \"estimated_weekly_time\",\n      \"activities\": [\n        {\n          \"type\": \"activity_type\",\n          \"description\": \"activity_description\",\n          \"resources\": [\"resource1\", \"resource2\", ...]\n        },\n        {\n          \"type\": \"activity_type\",\n          \"description\": \"activity_description\",\n          \"resources\": [\"resource1\", \"resource2\", ...]\n        },\n        ...\n      ]\n    },\n    {\n      \"week\": 2,\n      \"theme\": \"week_theme\",\n      \"estimated_duration\": \"estimated_weekly_time\",\n      \"activities\": [\n        {\n          \"type\": \"activity_type\",\n          \"description\": \"activity_description\",\n          \"resources\": [\"resource1\", \"resource2\", ...]\n        },\n        ...\n      ]\n    },\n    ...\n  ]\n}\n",
-    "model": "gemini-1.5-flash-8b",
-    "base_url": "https://generativelanguage.googleapis.com/v1beta/openai/",
-    "api_key": "AIzaSyA5V1Pp8icIuj6vd5agdk9sYsEi4sUzWlU",
-    "lesson_instruction": "\n    You are an advanced AI language tutor specializing in personalized language instruction. Your task is to create detailed, AI-driven daily lesson plans for a full week based on the curriculum provided.\n\n    Student Profile:\n    - Target Language: Chinese\n    - Learning Goal: Advanced fluency in technical Chinese communication for machine learning roles\n    - Current Level: Intermediate\n\n    Instructions:\n    1. Create engaging, AI-driven activities for each day of the week (7 days)\n    2. Focus on interactive, personalized learning experiences\n    3. Avoid suggesting external resources or tools\n    4. Ensure activities align with the week's theme and learning objectives\n    5. Include specific examples and practice scenarios for each day\n    6. Format your response as a valid JSON object\n\n    Output Format:\n    {\n        \"week\": number,\n        \"theme\": \"string\",\n        \"estimated_duration\": \"string\",\n        \"daily_lessons\": [\n            {\n                \"day\": number,\n                \"focus\": \"string\",\n                \"duration\": \"string\",\n                \"activities\": [\n                    {\n                        \"type\": \"string\",\n                        \"description\": \"string\"\n                    }\n                ]\n            },\n            // Repeat for all 7 days\n        ]\n    }\n\n    Notes:\n    - Create lessons for all 7 days of the week\n    - Each day should have a specific focus while maintaining the week's theme\n    - Weekend lessons (days 6-7) can be lighter but should maintain learning momentum\n    - All activities should be completable through AI interaction\n    ",
-    "lesson_prompt": "\n    Based on the curriculum week 4:\n    {'week': 4, 'theme': 'Presentations and Debates', 'estimated_duration': '20-25 hours', 'activities': [{'type': 'Presentation Practice', 'description': 'Prepare and practice presenting a machine learning project or topic in Chinese.  Record your presentation and seek feedback from a language partner or AI assistant.'}, {'type': 'Debate Practice', 'description': 'Practice debating machine learning topics or concepts.  Structure arguments and counter-arguments, using formal and informal Chinese communication strategies.'}, {'type': 'Application Focus', 'description': 'Review the concepts from the past weeks.  Apply the skills from previous weeks in a real-world context.  This could be by joining a discussion, presenting a project, or initiating a conversation with a native speaker. '}, {'type': 'Progress Reflection', 'description': 'Summarize your achievements.  Set realistic next steps for continued language development and technical communication.'}]}\n\n    Generate a detailed, AI-driven lesson plan following the instruction format.\n    ",
-    "daily_lesson_instruction": "\n    You are an AI assistant tasked with curating today's lesson to help the user improve their skills in the target language.\n\n    Instructions:\n    1. Determine the target language based on the user's input.\n    2. Create a bilingual lesson (English and the target language) to enable the user to achieve their learning goal.\n    3. For vocabulary sections:\n       - Provide terms in English, their translations in the target language, and example sentences in both languages.\n       - For character-based languages (e.g., Chinese, Japanese, Korean, Arabic), include phonetic aids alongside the target language:\n         - Chinese: Include Pinyin for Mandarin terms.\n         - Japanese: Include Romaji for Japanese terms.\n         - Korean: Include Romanized Korean (Revised Romanization).\n         - Arabic: Include transliteration using the Latin alphabet.\n       - Example format:\n         - Term: \"prototype\"\n         - Translation: \"原型\" (Chinese), Pinyin: \"yuánxíng\"\n         - Example Sentence: \n           - English: \"We've developed a prototype for the new app.\"\n           - Target Language: \"我们为新应用开发了一个原型。\" (Chinese), Pinyin: \"Wǒmen wèi xīn yìngyòng kāifāle yígè yuánxíng.\"\n    4. For practice activities:\n       - Include prompts in both English and the target language.\n       - Provide example responses in both languages, including phonetic aids for character-based languages.\n    5. Provide feedback on the user's input, focusing on grammar, vocabulary, and fluency. If applicable, include corrections with phonetic aids.\n    6. Always remember to include both English and the target language for all cases, along with phonetic aids for character-based languages.\n\n    The lesson should be engaging, interactive, and tailored to the user's proficiency level.\n    ",
-    "daily_lesson_prompt": "\n    Theme: Foundational Technical Vocabulary\n\n    Based on today's lesson plan, create a bilingual lesson (English and Chinese) with the following structure:\n\n    Lesson Plan: {'day': 5, 'focus': 'Review and Consolidation', 'duration': '2 hours', 'activities': [{'type': 'Vocabulary Recall', 'description': 'The AI will present a list of machine learning terms.  You will write the definition or appropriate synonym in Chinese for each.'}, {'type': 'Grammar Application', 'description': 'The AI will give a series of technical statements about machine learning.  Reformulate each statement into a question using appropriate grammar structures for questioning.  The AI will check your accuracy.'}]}\n    ",
-    "target_language": "Chinese",
-    "current_week": 3
-}

backend/config.py

@@ -1,96 +1,59 @@
-from dotenv import load_dotenv
-from backend.config_manager import Config
-from backend.utils import ensure_directory
-import os
-
-load_dotenv()
-
-# Set up base paths
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-CONFIG_DIR = os.path.join(PROJECT_ROOT, "backend")
-OUTPUT_DIR = os.path.join(PROJECT_ROOT, "output")
-
-# Ensure directories exist
-ensure_directory(CONFIG_DIR)
-ensure_directory(OUTPUT_DIR)
-
-config_path = os.path.join(CONFIG_DIR, "config.json")
-config = Config(config_path)
-
-# Default values - update API key handling
-API_KEY = os.getenv('OPENAI_API_KEY') or os.getenv('GEMINI_API_KEY')
-if not API_KEY:
-    raise ValueError("No API key found. Please set OPENAI_API_KEY or GEMINI_API_KEY environment variable")
-
-MODEL = "gemini-1.5-flash-8b"
-BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
-
-# Add API port configuration
-API_PORT = int(os.getenv('API_PORT', 8000))
-
-CURRICULUM_INSTRUCTION = """
-You are an expert AI language learning curriculum designer. Your task is to create a one-month intensive language learning curriculum tailored to user's specific learning objectives and preferences. The curriculum should be divided into four weeks, with each week building upon the previous one.
+CURRICULUM_INSTRUCTIONS = """
+You are an expert AI language learning curriculum designer. 
+Your task is to create an intensive language learning curriculum tailored to the user's specific learning objectives and preferences. 
+By default, design a one-month curriculum (divided into four weeks), but note that the duration can be adjusted if the user desires a different length of study time.
 
 **Curriculum Design Principles:**
 
-1.  **AI-Driven:** The curriculum leverages AI for personalized learning experiences.
-2.  **Intensive:** The curriculum should be designed for significant weekly study time.
-3.  **Structured:** The curriculum should be divided into four weeks, with each week building upon the previous one.
-4.  **Comprehensive:** Include a variety of learning activities, such as vocabulary building, grammar study, reading, writing, listening, and speaking practice.
-5.  **Personalized:** Adapt the curriculum to the user's learning goals, current level, and interests.
-6.  **Measurable:** Suggest ways the user can track their progress.
-7.  **Output Format:** Provide the curriculum in a valid JSON format.
-8.  **Weekly Content:** Instead of daily content, focus on providing a theme and a set of activities for each week. Include the approximate time the user should invest in that week.
+1. **AI-Driven:** Leverage AI to create personalized learning experiences.
+2. **Intensive:** Design the curriculum for significant weekly study time.
+3. **Structured:** Divide the curriculum into four weeks (or the user-specified duration), with each week building upon the previous one.
+4. **Comprehensive:** Include a variety of learning activities such as vocabulary building, grammar study, reading, writing, listening, and speaking practice.
+5. **Personalized:** Adapt the curriculum to the user's learning goals, current level, interests, and native language.
+6. **Measurable:** Suggest ways for the user to track their progress.
+7. **Output Format:** Provide the curriculum in a valid JSON format.
+8. **Weekly Content:** Focus on providing a theme and a set of activities for each week instead of daily content. For each week, include the approximate time the user should invest during that week (for example, "estimated_duration": "20 hours per week"). Adjust the duration if the user requests a different total timeframe.
 
-**Output JSON Format:**
+**Important Notes:**
+- The curriculum should be **bilingual** in the user's **native language** and the **target language**.
+- Provide detailed instructions, explanations, and examples in the user's **native language** (for context and easier understanding).
+- Activities and exercises should also include explanations in the user's **native language** where necessary, ensuring the learning experience is smooth and intuitive.
 
+**Output JSON Format:**
 ```json
-{
-  "language": "target_language",
-  "learning_goal": "user_provided_goal",
-  "current_level": "user_provided_level",
-  "weeks": [
-    {
-      "week": 1,
-      "theme": "week_theme",
-      "estimated_duration": "estimated_weekly_time",
-      "activities": [
-        {
-          "type": "activity_type",
-          "description": "activity_description"
-        },
-        {
-          "type": "activity_type",
-          "description": "activity_description"
-        },
-        ...
-      ]
-    },
-    {
-      "week": 2,
-      "theme": "week_theme",
-      "estimated_duration": "estimated_weekly_time",
-      "activities": [
-        {
-          "type": "activity_type",
-          "description": "activity_description"
-        },
-        ...
-      ]
-    },
-    ...
-  ]
+{ 
+    "language": "target_language", 
+    "native_language": "user_native_language", 
+    "learning_goal": "user_provided_goal", 
+    "current_level": "user_provided_level", 
+    "weeks": [ 
+        { 
+            "week": 1, 
+            "theme": "week_theme", 
+            "estimated_duration": "estimated_weekly_time", 
+            "activities": [ 
+                { 
+                    "type": "activity_type", 
+                    "description": "activity_description_in_native_language" 
+                }, 
+                { 
+                    "type": "activity_type", 
+                    "description": "activity_description_in_native_language" 
+                }, ... 
+            ] 
+        }, 
+        { 
+            "week": 2, 
+            "theme": "week_theme", 
+            "estimated_duration": "estimated_weekly_time", 
+            "activities": [ 
+                { 
+                    "type": "activity_type", 
+                    "description": "activity_description_in_native_language" 
+                }, ... 
+            ] 
+        }, ... // repeat for the duration of the curriculum
+    ] 
 }
-"""
-
-# Export CURRICULUM_INSTRUCTION
-__all__ = ['config', 'CURRICULUM_INSTRUCTION', 'API_PORT']
-
-# Initialize config with default values if not exists
-if not config.data:
-    config.set("curriculum_instruction", CURRICULUM_INSTRUCTION)
-    config.set("model", MODEL)
-    config.set("base_url", BASE_URL)
-    config.set("api_key", API_KEY)
-    config.set("api_port", API_PORT)
-    config.save()
+```
+"""

backend/config_manager.py

@@ -1,71 +0,0 @@
-import json
-import os
-
-
-class Config:
-    def __init__(self, file_path="config.json"):
-        self.file_path = file_path
-        self.data = {}
-        self.load()
-
-    def load(self):
-        """Loads the configuration data from the JSON file."""
-        try:
-            with open(self.file_path, "r", encoding="utf-8") as f:
-                self.data = json.load(f)
-        except FileNotFoundError:
-            print(f"Config file not found at {self.file_path}. Creating a new one.")
-            self.data = {}  # Start with an empty config
-            self.save()
-        except json.JSONDecodeError:
-            print(
-                f"Error: Invalid JSON format in config file at {self.file_path}. The file will be reset."
-            )
-            self.data = {}
-            self.save()
-
-    def save(self):
-        """Saves the configuration data to the JSON file."""
-        with open(self.file_path, "w", encoding="utf-8") as f:
-            json.dump(self.data, f, indent=4, ensure_ascii=False)
-
-    def get(self, key, default=None):
-        """Gets a configuration value by key.
-
-        Args:
-            key (str): The key to look up.
-            default: The default value to return if the key is not found.
-
-        Returns:
-            The configuration value or the default.
-        """
-        return self.data.get(key, default)
-
-    def set(self, key, value):
-        """Sets a configuration value.
-
-        Args:
-            key (str): The key to set.
-            value: The value to set.
-        """
-        self.data[key] = value
-        self.save()
-
-    def update(self, new_data):
-        """Updates the config data with a new dict
-
-        Args:
-            new_data: The data to update
-        """
-        self.data.update(new_data)
-        self.save()
-
-    def delete(self, key):
-        """Deletes a key from the config
-
-        Args:
-            key (str): the key to delete
-        """
-        if key in self.data:
-            del self.data[key]
-        self.save()

backend/main.py

@@ -1,248 +1,20 @@
-import os
-import argparse
-import sys
-from backend.CurriculumManager.generate_curriculum import get_completion as generate_curriculum
-from backend.LessonManager.generate_lesson import get_completion as generate_lesson
-from backend.LessonManager.generate_daily_lesson import get_completion as generate_daily_lesson
-from backend.config_manager import Config
-from backend.utils import read_json_file, ensure_directory
-
-# Set up paths
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-CONFIG_PATH = os.path.join(PROJECT_ROOT, "backend", "config.json")
-OUTPUT_DIR = os.path.join(PROJECT_ROOT, "output")
-CURRICULUM_PATH = os.path.join(OUTPUT_DIR, "curriculum.json")
-LESSON_PATH = os.path.join(OUTPUT_DIR, "lesson.json")
-
-# Ensure output directory exists
-ensure_directory(OUTPUT_DIR)
-
-config = Config(CONFIG_PATH)
-
-def parse_args():
-    parser = argparse.ArgumentParser(description='AI Language Tutor')
-    parser.add_argument('--mode', choices=['curriculum', 'lesson', 'daily'], required=True,
-                      help='Mode of operation: curriculum, weekly lesson, or daily micro-lessons')
-    parser.add_argument('--prompt', type=str, required='curriculum' in sys.argv,
-                      help='User prompt for curriculum generation (required for curriculum mode)')
-    parser.add_argument('--week', type=int, default=0, help='Week number (0-based index)')
-    parser.add_argument('--day', type=int, default=0, help='Day number (0-based index)')
-    return parser.parse_args()
-
-def setup_lesson_instruction(args):
-    """Setup lesson instruction from curriculum data using specified week."""
-    curriculum_data = read_json_file(CURRICULUM_PATH)
-    if curriculum_data is None:
-        raise FileNotFoundError("Curriculum not found. Please generate curriculum first.")
-
-    if args.week >= len(curriculum_data["weeks"]):
-        raise ValueError(f"Week {args.week} not found. Available weeks: 0-{len(curriculum_data['weeks'])-1}")
-
-    language = curriculum_data["language"]
-    learning_goal = curriculum_data["learning_goal"]
-    current_level = curriculum_data["current_level"]
-    week = curriculum_data["weeks"][args.week]
-
-    lesson_instruction = """
-    You are an advanced AI language tutor specializing in personalized language instruction. Your task is to create detailed, AI-driven daily lesson plans for a full week based on the curriculum provided.
-
-    Student Profile:
-    - Target Language: {language}
-    - Learning Goal: {learning_goal}
-    - Current Level: {current_level}
-
-    Instructions:
-    1. Create engaging, AI-driven activities for each day of the week (7 days)
-    2. Focus on interactive, personalized learning experiences
-    3. Avoid suggesting external resources or tools
-    4. Ensure activities align with the week's theme and learning objectives
-    5. Include specific examples and practice scenarios for each day
-    6. Format your response as a valid JSON object
-
-    Output Format:
-    {{
-        "week": number,
-        "theme": "string",
-        "estimated_duration": "string",
-        "daily_lessons": [
-            {{
-                "day": number,
-                "focus": "string",
-                "duration": "string",
-                "activities": [
-                    {{
-                        "type": "string",
-                        "description": "string"
-                    }}
-                ]
-            }},
-            // Repeat for all 7 days
-        ]
-    }}
-
-    Notes:
-    - Create lessons for all 7 days of the week
-    - Each day should have a specific focus while maintaining the week's theme
-    - Weekend lessons (days 6-7) can be lighter but should maintain learning momentum
-    - All activities should be completable through AI interaction
-    """.format(
-        language=language,
-        learning_goal=learning_goal,
-        current_level=current_level
-    )
-
-    lesson_prompt = """
-    Based on the curriculum week {week_num}:
-    {curriculum}
-
-    Generate a detailed, AI-driven lesson plan following the instruction format.
-    """.format(week_num=args.week + 1, curriculum=week)
-
-    config.set("target_language", language)
-    config.set("lesson_instruction", lesson_instruction)
-    config.set("lesson_prompt", lesson_prompt)
-    
-    # Return the generated lesson directly instead of True
-    return generate_lesson(lesson_prompt)
-
-def setup_daily_lesson(args):
-    """Setup and generate daily lesson using specified day"""
-    lesson_data = read_json_file(LESSON_PATH)
-    theme = lesson_data["theme"]
-    lessons = lesson_data["daily_lessons"]
-
-    if args.day >= len(lessons):
-        raise ValueError(f"Day {args.day} not found in lesson plan. Available days: 0-{len(lessons)-1}")
-
-    daily_lesson_instruction = """
-    You are an AI assistant tasked with curating today's lesson to help the user improve their skills in the target language.
-
-    Instructions:
-    1. Determine the target language based on the user's input.
-    2. Create a bilingual lesson (English and the target language) to enable the user to achieve their learning goal.
-    3. For vocabulary sections:
-       - Provide terms in English, their translations in the target language, and example sentences in both languages.
-       - For character-based languages (e.g., Chinese, Japanese, Korean, Arabic), include phonetic aids alongside the target language:
-         - Chinese: Include Pinyin for Mandarin terms.
-         - Japanese: Include Romaji for Japanese terms.
-         - Korean: Include Romanized Korean (Revised Romanization).
-         - Arabic: Include transliteration using the Latin alphabet.
-       - Example format:
-         - Term: "prototype"
-         - Translation: "原型" (Chinese), Pinyin: "yuánxíng"
-         - Example Sentence: 
-           - English: "We've developed a prototype for the new app."
-           - Target Language: "我们为新应用开发了一个原型。" (Chinese), Pinyin: "Wǒmen wèi xīn yìngyòng kāifāle yígè yuánxíng."
-    4. For practice activities:
-       - Include prompts in both English and the target language.
-       - Provide example responses in both languages, including phonetic aids for character-based languages.
-    5. Provide feedback on the user's input, focusing on grammar, vocabulary, and fluency. If applicable, include corrections with phonetic aids.
-    6. Always remember to include both English and the target language for all cases, along with phonetic aids for character-based languages.
-
-    The lesson should be engaging, interactive, and tailored to the user's proficiency level.
-    """
-
-    lesson_prompt = """
-    Theme: {theme}
-
-    Based on today's lesson plan, create a bilingual lesson (English and {target_language}) with the following structure:
-
-    Lesson Plan: {lesson_plan}
-    """.format(
-        theme=theme,
-        target_language=config.get("target_language"),
-        lesson_plan=lessons[args.day]
-    )
-
-    config.set("daily_lesson_instruction", daily_lesson_instruction)
-    config.set("daily_lesson_prompt", lesson_prompt)
-    return generate_daily_lesson(lesson_prompt)
-
-def main():
-    args = parse_args()
-
-    if args.mode == 'curriculum':
-        if not args.prompt:
-            raise ValueError("--prompt is required for curriculum mode")
-        generate_curriculum(args.prompt)
-    elif args.mode == 'lesson':
-        setup_lesson_instruction(args)  # Remove separate generate_lesson call
-    elif args.mode == 'daily':
-        setup_daily_lesson(args)  # Already generates lesson using internal prompt
-
+import asyncio  # <-- Import asyncio
+from backend.utils import get_completion
+from backend.config import CURRICULUM_INSTRUCTIONS
+
+# Define an async function to hold the await call
+async def main():
+    query = "need to improve my chinese so as to propose to my girlfriend"
+    print("Getting completion...") # Optional: Indicate progress
+    try:
+        response = await get_completion(prompt=query, instruction=CURRICULUM_INSTRUCTIONS)
+        print("\nResponse:")
+        print(response)
+    except Exception as e:
+        print(f"An error occurred: {e}") # Basic error handling
+
+# Use asyncio.run() to execute the async main function
+# The if __name__ == "__main__": block ensures this runs only when
+# the script is executed directly (e.g., python -m backend.main)
 if __name__ == "__main__":
-    main()
-
-# curriculum_data = read_json_file(CURRICULUM_PATH)
-# if curriculum_data is None:
-#     raise FileNotFoundError("Curriculum not found. Please generate curriculum first.")
-
-# if args.week >= len(curriculum_data["weeks"]):
-#     raise ValueError(f"Week {args.week} not found. Available weeks: 0-{len(curriculum_data['weeks'])-1}")
-
-# language = curriculum_data["language"]
-# learning_goal = curriculum_data["learning_goal"]
-# current_level = curriculum_data["current_level"]
-# week = curriculum_data["weeks"][args.week]
-
-# lesson_instruction = """
-# You are an advanced AI language tutor specializing in personalized language instruction. Your task is to create detailed, AI-driven daily lesson plans for a full week based on the curriculum provided.
-
-# Student Profile:
-# - Target Language: {language}
-# - Learning Goal: {learning_goal}
-# - Current Level: {current_level}
-
-# Instructions:
-# 1. Create engaging, AI-driven activities for each day of the week (7 days)
-# 2. Focus on interactive, personalized learning experiences
-# 3. Avoid suggesting external resources or tools
-# 4. Ensure activities align with the week's theme and learning objectives
-# 5. Include specific examples and practice scenarios for each day
-# 6. Format your response as a valid JSON object
-
-# Output Format:
-# {{
-#     "week": number,
-#     "theme": "string",
-#     "estimated_duration": "string",
-#     "daily_lessons": [
-#         {{
-#             "day": number,
-#             "focus": "string",
-#             "duration": "string",
-#             "activities": [
-#                 {{
-#                     "type": "string",
-#                     "description": "string"
-#                 }}
-#             ]
-#         }},
-#         // Repeat for all 7 days
-#     ]
-# }}
-
-# Notes:
-# - Create lessons for all 7 days of the week
-# - Each day should have a specific focus while maintaining the week's theme
-# - Weekend lessons (days 6-7) can be lighter but should maintain learning momentum
-# - All activities should be completable through AI interaction
-# """.format(
-#     language=language,
-#     learning_goal=learning_goal,
-#     current_level=current_level
-# )
-
-# lesson_prompt = """
-# Based on the curriculum week {week_num}:
-# {curriculum}
-
-# Generate a detailed, AI-driven lesson plan following the instruction format.
-# """.format(week_num=args.week + 1, curriculum=week)
-
-# config.set("target_language", language)
-# config.set("lesson_instruction", lesson_instruction)
-# config.set("lesson_prompt", lesson_prompt)
-
-# # Return the generated lesson directly instead of True
-# generate_lesson(lesson_prompt)
+    asyncio.run(main())

backend/requirements.txt

@@ -1,6 +0,0 @@
-fastapi==0.68.0
-uvicorn==0.15.0
-python-dotenv==0.19.0
-pydantic==1.8.2
-openai==0.27.0
-python-multipart==0.0.5

backend/utils.py

@@ -1,56 +1,22 @@
-import json
 import os
-
-def read_json_file(file_path: str) -> dict:
-    """Reads and parses a JSON file.
-
-    Args:
-        file_path (str): Path to the JSON file
-
-    Returns:
-        dict: Parsed JSON data or None if there was an error
-    """
-    try:
-        with open(file_path, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except FileNotFoundError:
-        print(f"Error: File not found at {file_path}")
-        return None
-    except json.JSONDecodeError:
-        print(f"Error: Invalid JSON format in file at {file_path}")
-        return None
-
-def write_json_file(file_path: str, data: dict, indent: int = 4) -> bool:
-    """Writes data to a JSON file.
-
-    Args:
-        file_path (str): Path to save the JSON file
-        data (dict): Data to write
-        indent (int): Indentation level for pretty printing
-
-    Returns:
-        bool: True if successful, False otherwise
-    """
-    try:
-        with open(file_path, "w", encoding="utf-8") as f:
-            json.dump(data, f, indent=indent, ensure_ascii=False)
-        return True
-    except Exception as e:
-        print(f"Error writing to file {file_path}: {str(e)}")
-        return False
-
-def ensure_directory(directory_path: str) -> bool:
-    """Ensures a directory exists, creates it if it doesn't.
-
-    Args:
-        directory_path (str): Path to the directory
-
-    Returns:
-        bool: True if directory exists or was created successfully
-    """
-    try:
-        os.makedirs(directory_path, exist_ok=True)
-        return True
-    except Exception as e:
-        print(f"Error creating directory {directory_path}: {str(e)}")
-        return False
+import asyncio
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = AsyncOpenAI(
+    api_key=os.getenv("GEMINI_API_KEY"),
+    base_url=os.getenv("GEMINI_BASE_URL"),
+)
+
+async def get_completion(prompt: str, instruction: str) -> str:
+    response = await client.chat.completions.create(
+        model=os.getenv("MODEL"),
+        messages=[
+            {"role": "system", "content": instruction},
+            {"role": "user", "content": prompt}
+        ],
+        response_format={"type": "json_object"},
+    )
+    return response.choices[0].message.content