v3 backend

Dockerfile

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

backend/api.py

@@ -1,39 +0,0 @@
-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/config.py

@@ -1,59 +1,71 @@
-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:** 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.
-
-**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", 
-    "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
-    ] 
+flashcard_mode_instructions = """
+You are a vocabulary tutor specialized in teaching Chinese to non-native learners. Your goal is to help users quickly acquire context-specific vocabulary.
+
+Given a user query that describes a scenario or topic, generate exactly 5 flashcards in valid JSON array format. Each flashcard must include:
+- 'word': a Chinese word or phrase relevant to the query
+- 'definition': a simple, learner-friendly explanation in English
+- 'example': a short example sentence in Chinese that naturally uses the word
+
+Ensure that all words are commonly used and appropriate for the given context. Favor words that would be useful in real-life communication. Do not include rare, archaic, or highly academic words.
+
+Example input: 'Ordering food at a restaurant'
+
+Example output:
+[
+  {"word": "菜单", "definition": "menu", "example": "请给我看一下菜单。"},
+  … (4 more flashcards)
+]
+
+Output ONLY valid JSON. Do not include explanations, preambles, or notes.
+"""
+
+exercise_mode_instructions = """
+You are an exercise generator focused on reinforcing Chinese vocabulary and grammar through cloze (fill-in-the-blank) activities. Your job is to create engaging exercises that match a specific scenario or vocabulary need.
+
+Given a user query that describes a goal or context, generate exactly 5 cloze-style exercises in valid JSON array format. Each item must contain:
+- 'sentence': a Chinese sentence with one blank represented as '___'
+- 'answer': the correct word or phrase to complete the sentence
+- 'choices': an array of 3 plausible distractor options (one of which is the correct answer)
+
+All vocabulary must be suitable for beginner to intermediate learners. Choose distractors that are reasonable but clearly incorrect in the given context to aid in learning.
+
+Example input: 'Talking about daily routines'
+
+Example output:
+[
+  {"sentence": "我每天早上___七点起床。", "answer": "大约", "choices": ["大约", "也许", "还是"]},
+  … (4 more)
+]
+
+Output ONLY valid JSON. Do not include extra text or formatting.
+"""
+
+simulation_mode_instructions = """
+You are a Chinese conversation simulator designed to help learners practice real-world communication scenarios. Your job is to create short interactive dialogues that mimic actual conversations.
+
+Given a user query describing a specific situation, produce a JSON object with the following structure:
+- 'scenario': a short description of the roleplay setting
+- 'dialog': an array of at least 6 message turns (3 per speaker), alternating between 'tutor' and 'user' roles
+
+Each message must include:
+- 'role': either 'tutor' or 'user'
+- 'chinese': the Chinese text
+- 'pinyin': the phonetic transcription
+- 'english': a simple English translation
+
+Ensure that the tutor initiates the conversation. The dialogue should reflect real-life tone, pacing, and common expressions. Make the tutor encouraging and use slow, clear Mandarin. Use language that matches beginner to intermediate learners.
+
+Example input: 'Buying a ticket at the train station'
+
+Example output:
+{
+  "scenario": "Buying a ticket at the train station",
+  "dialog": [
+    {"role": "tutor", "chinese": "你好，请问你要去哪里？", "pinyin": "Nǐ hǎo, qǐngwèn nǐ yào qù nǎlǐ?", "english": "Hello, may I ask where you're going?"},
+    {"role": "user", "chinese": "我要去上海。", "pinyin": "Wǒ yào qù Shànghǎi.", "english": "I want to go to Shanghai."},
+    … (at least 6 turns total)
+  ]
 }
-```
+
+Output ONLY valid JSON. Do not include introductory text or any extra formatting.
 """

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'.")

backend/main.py

@@ -1,20 +1,84 @@
-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
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+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
+
+app = FastAPI()
+
+# Dependency to get database connection
+async def get_db():
+    conn = await get_db_connection()
     try:
-        response = await get_completion(prompt=query, instruction=CURRICULUM_INSTRUCTIONS)
-        print("\nResponse:")
-        print(response)
+        yield conn
+    finally:
+        conn.close()
+
+class GenerationRequest(BaseModel):
+    user_id: int
+    query: str
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to the AI Learning Assistant API!"}
+
+@app.post("/generate/flashcards")
+async def generate_flashcards(data: GenerationRequest):
+    try:
+        response = await generate_completions.get_completions(
+            data.query,
+            config.flashcard_mode_instructions
+        )
+        return JSONResponse(
+            content={
+                "data": response,
+                "type": "flashcards",
+                "status": "success"
+            },
+            status_code=200
+        )
     except Exception as e:
-        print(f"An error occurred: {e}") # Basic error handling
+        raise HTTPException(status_code=500, detail=str(e))
+
 
-# 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__":
-    asyncio.run(main())
+@app.post("/generate/exercises")
+async def generate_exercises(data: GenerationRequest):
+    try:
+        response = await generate_completions.get_completions(
+            data.query,
+            config.exercise_mode_instructions
+        )
+        # adjust the response similar to generate_flashcards
+        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:
+        response = await generate_completions.get_completions(
+            data.query,
+            config.simulation_mode_instructions
+        )
+        # adjust the response similar to generate_flashcards
+        return JSONResponse(
+            content={
+                "data": response,
+                "type": "simulation",
+                "status": "success"
+            },
+            status_code=200
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/utils.py

@@ -1,22 +0,0 @@
-import os
-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

backend/utils/generate_completions.py

@@ -0,0 +1,58 @@
+from openai import AsyncOpenAI, OpenAI
+import asyncio
+import json
+from typing import AsyncIterator
+from typing import Union, List, Dict
+from dotenv import load_dotenv
+import os
+load_dotenv()
+
+# Initialize the async client
+client = AsyncOpenAI(
+    base_url=os.getenv("BASE_URL"),
+    api_key=os.getenv("API_KEY"),
+)
+
+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

docker-compose.yml

@@ -6,7 +6,7 @@ services:
     volumes:
       - ./output:/code/output
     environment:
-      - GEMINI_API_KEY=${GEMINI_API_KEY}
+      - API_KEY=${API_KEY}
       - OLLAMA_API_KEY=${OLLAMA_API_KEY}
       - API_PORT=${API_PORT}
     env_file:
@@ -16,4 +16,4 @@ services:
       watch:
         - action: sync
           path: .
-          target: /code
+          target: /code