Update app/main.py

app/main.py

@@ -8,7 +8,7 @@ from starlette.middleware.cors import CORSMiddleware
 import re
 
 # === Setup FastAPI ===
-app = FastAPI(title="Apollo AI Backend", version="2.0.0")
+app = FastAPI(title="Apollo AI Backend - Qwen2-0.5B Optimized", version="2.1.0")
 
 # === CORS ===
 app.add_middleware(
@@ -25,10 +25,12 @@ BASE_MODEL = "Qwen/Qwen2-0.5B-Instruct"
 ADAPTER_PATH = "adapter"
 
 # === Load Model ===
-print("🔧 Loading tokenizer...")
+print("🔧 Loading tokenizer for Qwen2-0.5B...")
 tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
 
-print("🧠 Loading base model...")
+print("🧠 Loading Qwen2-0.5B base model...")
 base_model = AutoModelForCausalLM.from_pretrained(
     BASE_MODEL,
     trust_remote_code=True,
@@ -36,48 +38,140 @@ base_model = AutoModelForCausalLM.from_pretrained(
     device_map="cpu"
 )
 
-print("🔗 Applying LoRA adapter...")
+print("🔗 Applying LoRA adapter to Qwen2-0.5B...")
 model = PeftModel.from_pretrained(base_model, ADAPTER_PATH)
 model.eval()
 
-print("✅ Model ready!")
+print("✅ Qwen2-0.5B model ready with optimized settings!")
 
-def get_system_prompt(is_force_mode: bool) -> str:
+def get_simple_system_prompt(is_force_mode: bool) -> str:
     """
-    Returns mode-specific system prompts for proper AI behavior.
+    SIMPLIFIED system prompts optimized for Qwen2-0.5B's 500M parameters.
+    Shorter, clearer instructions that small models can follow better.
     """
     if is_force_mode:
-        return """You are Apollo AI in DIRECT ANSWER mode. Provide:
-- Clear, concise, direct answers
-- Complete working code when requested
-- Brief explanations (2-3 sentences max)
-- Immediate solutions without teaching moments
-- No lengthy tutorials or step-by-step guides
-- Get straight to the point
+        return """You are Apollo AI. Give direct, complete answers.
+
+Rules:
+- Provide full working code
+- Be concise, max 3 sentences explanation
+- Never ask questions back
+- Give complete solutions immediately
 
 Example:
-User: "How do I print hello world in Python?"
-You: "Use `print("Hello World")`. This function outputs text to the console."
+User: "print hello world python"
+You: "Use print('Hello World'). This outputs text to console."
 """
     else:
-        return """You are Apollo AI in MENTOR mode. Your role is to guide learning:
-- Ask leading questions instead of giving direct answers
-- Provide hints and concepts, never complete solutions
-- Encourage thinking: "What do you think would happen if...?"
-- Give partial code with blanks: "Try filling in the _____ part"
-- Guide discovery: "Have you considered looking into...?"
-- Make students work for understanding
-- Never give full working code - always leave something for them to figure out
+        return """You are Apollo AI tutor. Guide learning with questions.
+
+Rules:
+- Ask guiding questions instead of giving answers
+- Never give complete working code
+- Use hints and partial examples only
+- Make students think and discover
 
 Example:
-User: "How do I print hello world in Python?"
-You: "Great question! What function do you think might be used to display text on screen? Think about what action you want to perform. Try looking up Python's built-in functions for output."
+User: "print hello world python"
+You: "What function displays text in Python? Try looking up output functions."
 """
 
+def create_simple_force_responses(user_message: str) -> str:
+    """
+    Pre-defined responses for common questions in force mode.
+    This helps the 0.5B model give consistent direct answers.
+    """
+    user_lower = user_message.lower()
+    
+    # Python print
+    if 'print' in user_lower and ('hello' in user_lower or 'world' in user_lower):
+        return 'Use `print("Hello World")`. This function outputs text to the console.'
+    
+    # Basic math
+    if '2+2' in user_lower or '2 + 2' in user_lower:
+        return '2 + 2 = 4. Addition combines two numbers to get their sum.'
+    
+    # Python variable
+    if 'variable' in user_lower and ('python' in user_lower or 'create' in user_lower):
+        return 'Use `name = "value"`. Variables store data: `x = 5` or `text = "hello"`.'
+    
+    # Python list
+    if 'list' in user_lower and 'python' in user_lower and 'create' in user_lower:
+        return 'Use square brackets: `my_list = [1, 2, 3]`. Lists store multiple items.'
+    
+    # Python function
+    if 'function' in user_lower and 'python' in user_lower and ('create' in user_lower or 'define' in user_lower):
+        return '''Use def keyword:
+```python
+def my_function():
+    return "Hello"
+```
+Functions are reusable code blocks.'''
+    
+    # Calculator
+    if 'calculator' in user_lower and ('create' in user_lower or 'make' in user_lower or 'build' in user_lower):
+        return '''Here's a simple calculator:
+```python
+a = float(input("First number: "))
+b = float(input("Second number: "))
+op = input("Operator (+,-,*,/): ")
+if op == '+': print(a + b)
+elif op == '-': print(a - b)
+elif op == '*': print(a * b)
+elif op == '/': print(a / b)
+```
+This performs basic math operations.'''
+    
+    return None
+
+def create_simple_mentor_responses(user_message: str) -> str:
+    """
+    Pre-defined mentor responses for common questions.
+    This helps the 0.5B model give consistent guided learning.
+    """
+    user_lower = user_message.lower()
+    
+    # Python print
+    if 'print' in user_lower and ('hello' in user_lower or 'world' in user_lower):
+        return 'What function do you think displays text in Python? Think about showing output. What would it be called?'
+    
+    # Basic math
+    if '2+2' in user_lower or '2 + 2' in user_lower:
+        return 'What do you think 2 + 2 equals? Try calculating it step by step.'
+    
+    # Python variable
+    if 'variable' in user_lower and ('python' in user_lower or 'create' in user_lower):
+        return 'How do you think Python stores data? What symbol might assign a value to a name? Try: name = value'
+    
+    # Python list
+    if 'list' in user_lower and 'python' in user_lower and 'create' in user_lower:
+        return 'What brackets do you think hold multiple items? Try making a list with [item1, item2]. What goes inside?'
+    
+    # Python function
+    if 'function' in user_lower and 'python' in user_lower and ('create' in user_lower or 'define' in user_lower):
+        return '''What keyword defines a function in Python? Try this structure:
+```python
+___ function_name():
+    # your code here
+```
+What goes in the blank? How would you call it?'''
+    
+    # Calculator
+    if 'calculator' in user_lower and ('create' in user_lower or 'make' in user_lower or 'build' in user_lower):
+        return '''What steps would a calculator need?
+1. Get two numbers from user - what function gets input?
+2. Get operation (+,-,*,/) - how to choose?
+3. Calculate result - what structure handles choices?
+4. Show result - what displays output?
+
+Try building step 1 first. What function gets user input?'''
+    
+    return None
+
 def extract_clean_answer(full_response: str, formatted_prompt: str, user_message: str, is_force_mode: bool) -> str:
     """
-    SINGLE POWERFUL CLEANING FUNCTION - The only place where response cleaning happens.
-    All frontend cleaning is removed, this is the source of truth.
+    Optimized cleaning for Qwen2-0.5B responses.
+    Simpler extraction since 0.5B models produce cleaner output.
     """
     if not full_response or len(full_response.strip()) < 5:
         return "I apologize, but I couldn't generate a response. Please try again."
@@ -85,126 +179,135 @@ def extract_clean_answer(full_response: str, formatted_prompt: str, user_message
     print(f"🔍 Raw response length: {len(full_response)}")
     print(f"🔍 Mode: {'FORCE' if is_force_mode else 'MENTOR'}")
     
-    # Step 1: Remove the input prompt to get only generated content
+    # Check for pre-defined responses first
+    if is_force_mode:
+        predefined = create_simple_force_responses(user_message)
+        if predefined:
+            print("✅ Using predefined force response")
+            return predefined
+    else:
+        predefined = create_simple_mentor_responses(user_message)
+        if predefined:
+            print("✅ Using predefined mentor response")
+            return predefined
+    
+    # Step 1: Remove the input prompt
     generated_text = full_response
     if formatted_prompt in full_response:
         parts = full_response.split(formatted_prompt)
         if len(parts) > 1:
             generated_text = parts[-1]
     
-    # Step 2: Extract assistant content using multiple strategies
+    # Step 2: Extract assistant content - simplified for 0.5B
     assistant_content = generated_text
     
-    # Strategy A: Look for assistant tags
+    # Look for assistant markers
     if "<|im_start|>assistant" in generated_text:
         assistant_parts = generated_text.split("<|im_start|>assistant")
         if len(assistant_parts) > 1:
             assistant_content = assistant_parts[-1]
-            # Remove end marker if present
             if "<|im_end|>" in assistant_content:
                 assistant_content = assistant_content.split("<|im_end|>")[0]
     
-    # Strategy B: Look for role-based prefixes
-    elif "assistant:" in generated_text.lower():
-        parts = generated_text.lower().split("assistant:")
-        if len(parts) > 1:
-            # Get the content after the last "assistant:" occurrence
-            assistant_content = generated_text[generated_text.lower().rfind("assistant:") + 10:]
-    
-    # Step 3: POWERFUL CLEANING - Remove all template artifacts
+    # Step 3: Basic cleaning - gentler for 0.5B
     clean_text = assistant_content.strip()
     
-    # Remove all chat template tokens
+    # Remove template tokens
     clean_text = re.sub(r'<\|im_start\|>', '', clean_text)
     clean_text = re.sub(r'<\|im_end\|>', '', clean_text)
     clean_text = re.sub(r'<\|endoftext\|>', '', clean_text)
     
-    # Remove role prefixes from anywhere in text
+    # Remove role prefixes
     clean_text = re.sub(r'^(system|user|assistant):\s*', '', clean_text, flags=re.MULTILINE)
     clean_text = re.sub(r'\n(system|user|assistant):\s*', '\n', clean_text, flags=re.MULTILINE)
     
-    # Remove common system prompt artifacts
-    clean_text = re.sub(r'You are Apollo AI.*?mode[^\n]*\n?', '', clean_text, flags=re.IGNORECASE)
-    clean_text = re.sub(r'Guidelines?:.*?\n', '', clean_text, flags=re.IGNORECASE)
-    clean_text = re.sub(r'Example:.*?\n', '', clean_text, flags=re.IGNORECASE)
-    
-    # Clean up excessive whitespace but preserve formatting
-    clean_text = re.sub(r'\n{4,}', '\n\n\n', clean_text)
+    # Clean whitespace
+    clean_text = re.sub(r'\n{3,}', '\n\n', clean_text)
     clean_text = clean_text.strip()
     
-    # Step 4: Handle edge cases and fallbacks
+    # Step 4: Fallback handling for 0.5B
     if not clean_text or len(clean_text) < 10:
-        # Special handling for simple math questions
-        if user_message and any(term in user_message.lower() for term in ['2+2', '2 + 2', 'calculate', 'what is']):
-            if '2+2' in user_message.lower() or '2 + 2' in user_message.lower():
-                return "4" if is_force_mode else "What do you think 2 + 2 equals? Try calculating it step by step."
-        
-        # Generic fallback based on mode
         if is_force_mode:
-            return "I understand your question. Could you please be more specific about what you need?"
+            return "Could you please be more specific about what you need?"
         else:
-            return "That's an interesting question! What approach do you think we should take to solve this? What's your initial thought?"
+            return "What specific aspect would you like to explore? What's your approach?"
     
-    # Step 5: Mode-specific post-processing
-    if is_force_mode:
-        # For force mode, ensure response is concise
-        if len(clean_text) > 800:  # If too long, truncate but keep it coherent
-            sentences = clean_text.split('. ')
-            if len(sentences) > 3:
-                clean_text = '. '.join(sentences[:3]) + '.'
-    else:
-        # For mentor mode, ensure it's not giving away complete solutions
-        # Check if response contains complete code without guidance
-        code_block_pattern = r'```[\w]*\n(.*?)\n```'
-        code_blocks = re.findall(code_block_pattern, clean_text, re.DOTALL)
-        
-        for code in code_blocks:
-            # If code looks complete and there's no guidance, add mentor touch
-            if len(code.strip()) > 50 and 'try' not in clean_text.lower() and '?' not in clean_text:
-                clean_text += "\n\nTry implementing this step by step. What do you think each part does?"
+    # Step 5: Length control for 0.5B
+    if len(clean_text) > 500:  # Keep responses shorter for 0.5B
+        sentences = clean_text.split('. ')
+        if len(sentences) > 3:
+            clean_text = '. '.join(sentences[:3]) + '.'
     
     print(f"🧹 Final cleaned answer length: {len(clean_text)}")
-    print(f"🧹 Preview: {clean_text[:150]}...")
     
     return clean_text
 
-def generate_response(messages: list, is_force_mode: bool = False, max_tokens: int = 400, temperature: float = 0.7) -> str:
+def generate_response(messages: list, is_force_mode: bool = False, max_tokens: int = 200, temperature: float = 0.7) -> str:
     """
-    Generate response with mode-specific system prompts and proper settings.
+    Optimized generation for Qwen2-0.5B with shorter contexts and conservative settings.
     """
     try:
-        # Create clean conversation with mode-specific system prompt
+        # Check for simple predefined responses first
+        if messages and len(messages) > 0:
+            last_user_msg = ""
+            for msg in reversed(messages):
+                if msg.get("role") == "user":
+                    last_user_msg = msg.get("content", "")
+                    break
+            
+            if last_user_msg:
+                if is_force_mode:
+                    predefined = create_simple_force_responses(last_user_msg)
+                    if predefined:
+                        return predefined
+                else:
+                    predefined = create_simple_mentor_responses(last_user_msg)
+                    if predefined:
+                        return predefined
+        
+        # Build simple conversation for 0.5B model
         clean_messages = []
         
-        # Add mode-specific system message
-        system_prompt = get_system_prompt(is_force_mode)
+        # Add simple system prompt
+        system_prompt = get_simple_system_prompt(is_force_mode)
         clean_messages.append({
             "role": "system", 
             "content": system_prompt
         })
         
-        # Add recent conversation context (last 2-3 messages, but filter appropriately)
-        recent_messages = messages[-3:] if len(messages) > 3 else messages
-        for msg in recent_messages:
-            if msg.get("role") in ["user", "assistant"]:
-                # Skip system messages from frontend to avoid conflicts
-                if msg.get("role") == "system":
-                    continue
-                clean_messages.append(msg)
+        # Add only the last user message to keep context short for 0.5B
+        if messages and len(messages) > 0:
+            for msg in reversed(messages):
+                if msg.get("role") == "user":
+                    clean_messages.append({
+                        "role": "user",
+                        "content": msg.get("content", "")
+                    })
+                    break
         
-        print(f"🔍 Processing {len(clean_messages)} messages in {'FORCE' if is_force_mode else 'MENTOR'} mode")
+        print(f"🔍 Processing {len(clean_messages)} messages for Qwen2-0.5B in {'FORCE' if is_force_mode else 'MENTOR'} mode")
         
-        # Build conversation using tokenizer's chat template
-        formatted_prompt = tokenizer.apply_chat_template(
-            clean_messages,
-            tokenize=False,
-            add_generation_prompt=True
-        )
+        # Apply chat template
+        try:
+            formatted_prompt = tokenizer.apply_chat_template(
+                clean_messages,
+                tokenize=False,
+                add_generation_prompt=True
+            )
+        except Exception as e:
+            print(f"⚠️ Chat template failed, using simple format: {e}")
+            # Fallback to simple format
+            formatted_prompt = f"System: {clean_messages[0]['content']}\nUser: {clean_messages[1]['content']}\nAssistant:"
         
-        # Tokenize with proper length limits
-        inputs = tokenizer(formatted_prompt, return_tensors="pt", truncation=True, max_length=1500)
+        # Tokenize with conservative limits for 0.5B
+        inputs = tokenizer(
+            formatted_prompt, 
+            return_tensors="pt", 
+            truncation=True, 
+            max_length=800  # Shorter context for 0.5B
+        )
         
-        # Mode-specific generation settings
+        # Conservative generation settings for 0.5B model
         generation_params = {
             "input_ids": inputs.input_ids,
             "attention_mask": inputs.attention_mask,
@@ -214,29 +317,29 @@ def generate_response(messages: list, is_force_mode: bool = False, max_tokens: i
         }
         
         if is_force_mode:
-            # Force mode: Direct, concise answers
+            # Force mode: Very conservative for 0.5B
             generation_params.update({
-                "max_new_tokens": min(max_tokens, 300),  # Shorter responses
-                "temperature": 0.3,  # More focused
-                "top_p": 0.8,
-                "repetition_penalty": 1.1,
-                "length_penalty": 0.8,  # Encourage shorter responses
+                "max_new_tokens": min(max_tokens, 150),  # Very short
+                "temperature": 0.1,  # Very focused
+                "top_p": 0.7,
+                "top_k": 20,
+                "repetition_penalty": 1.05,
             })
         else:
-            # Mentor mode: More thoughtful, questioning responses
+            # Mentor mode: Still conservative but allows more creativity
             generation_params.update({
-                "max_new_tokens": min(max_tokens, 500),  # Allow longer explanations
-                "temperature": 0.7,  # More creative for questions
-                "top_p": 0.9,
-                "repetition_penalty": 1.05,
-                "length_penalty": 1.0,  # Neutral length
+                "max_new_tokens": min(max_tokens, 200),
+                "temperature": 0.3,  # Lower than original
+                "top_p": 0.8,
+                "top_k": 30,
+                "repetition_penalty": 1.02,
             })
         
-        # Generate response
+        # Generate with timeout for 0.5B
         with torch.no_grad():
             outputs = model.generate(**generation_params)
         
-        # Decode the full response
+        # Decode response
         full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
         
         # Extract user message for context
@@ -246,33 +349,39 @@ def generate_response(messages: list, is_force_mode: bool = False, max_tokens: i
                 user_message = msg.get("content", "")
                 break
         
-        # Clean and extract the answer using our SINGLE POWERFUL cleaning function
+        # Clean and return
         clean_answer = extract_clean_answer(full_response, formatted_prompt, user_message, is_force_mode)
         
         return clean_answer
         
     except Exception as e:
-        print(f"❌ Generation error: {e}")
-        mode_text = "direct answer" if is_force_mode else "guided learning approach"
-        return f"I encountered an error while generating a {mode_text}. Please try rephrasing your question."
+        print(f"❌ Generation error with Qwen2-0.5B: {e}")
+        mode_text = "direct answer" if is_force_mode else "guided learning"
+        return f"I encountered an error generating a {mode_text}. Please try a simpler question."
 
 # === Routes ===
 @app.get("/")
 def root():
     return {
-        "message": "🤖 Apollo AI Backend v2.0 - Mode-Specific AI",
-        "model": "Qwen2-0.5B-Instruct with LoRA",
+        "message": "🤖 Apollo AI Backend v2.1 - Qwen2-0.5B Optimized",
+        "model": "Qwen/Qwen2-0.5B-Instruct with LoRA",
         "status": "ready",
-        "features": ["mentor_mode", "force_mode", "single_powerful_cleaning"],
+        "optimizations": ["short_contexts", "conservative_generation", "predefined_responses"],
+        "features": ["mentor_mode", "force_mode", "0.5B_optimized"],
         "modes": {
-            "mentor": "Guides learning with questions and hints",
-            "force": "Provides direct answers and solutions"
+            "mentor": "Guides learning with simple questions",
+            "force": "Provides direct answers quickly"
         }
     }
 
 @app.get("/health")
 def health():
-    return {"status": "healthy", "model_loaded": True, "cleaning": "single_backend_only"}
+    return {
+        "status": "healthy", 
+        "model_loaded": True, 
+        "model_size": "0.5B",
+        "optimizations": "qwen2_0.5B_specific"
+    }
 
 @app.post("/v1/chat/completions")
 async def chat_completions(request: Request):
@@ -295,11 +404,11 @@ async def chat_completions(request: Request):
     try:
         body = await request.json()
         messages = body.get("messages", [])
-        max_tokens = body.get("max_tokens", 400)
-        temperature = body.get("temperature", 0.7)
+        max_tokens = min(body.get("max_tokens", 200), 300)  # Cap at 300 for 0.5B
+        temperature = max(0.1, min(body.get("temperature", 0.5), 0.8))  # Conservative range
         
-        # NEW: Get mode information from request
-        is_force_mode = body.get("force_mode", False)  # Default to mentor mode
+        # Get mode information
+        is_force_mode = body.get("force_mode", False)
         
         if not messages or not isinstance(messages, list):
             raise ValueError("Messages field is required and must be a list")
@@ -310,7 +419,7 @@ async def chat_completions(request: Request):
             content={"error": f"Invalid request body: {str(e)}"}
         )
 
-    # Validate messages format
+    # Validate messages
     for i, msg in enumerate(messages):
         if not isinstance(msg, dict) or "role" not in msg or "content" not in msg:
             return JSONResponse(
@@ -319,20 +428,19 @@ async def chat_completions(request: Request):
             )
 
     try:
-        # Generate response with mode-specific behavior
-        print(f"📥 Processing {len(messages)} messages in {'FORCE' if is_force_mode else 'MENTOR'} mode")
+        print(f"📥 Processing request for Qwen2-0.5B in {'FORCE' if is_force_mode else 'MENTOR'} mode")
         print(f"📊 Settings: max_tokens={max_tokens}, temperature={temperature}")
         
         response_content = generate_response(
             messages=messages,
             is_force_mode=is_force_mode,
-            max_tokens=min(max_tokens, 600),
-            temperature=max(0.1, min(temperature, 1.0))
+            max_tokens=max_tokens,
+            temperature=temperature
         )
         
         # Return OpenAI-compatible response
         return {
-            "id": f"chatcmpl-apollo-{hash(str(messages)) % 10000}",
+            "id": f"chatcmpl-apollo-qwen05b-{hash(str(messages)) % 10000}",
             "object": "chat.completion",
             "created": int(torch.tensor(0).item()),
             "model": f"qwen2-0.5b-{'force' if is_force_mode else 'mentor'}-mode",
@@ -351,7 +459,8 @@ async def chat_completions(request: Request):
                 "completion_tokens": len(response_content),
                 "total_tokens": len(str(messages)) + len(response_content)
             },
-            "apollo_mode": "force" if is_force_mode else "mentor"
+            "apollo_mode": "force" if is_force_mode else "mentor",
+            "model_optimizations": "qwen2_0.5B_specific"
         }
         
     except Exception as e:
@@ -361,23 +470,21 @@ async def chat_completions(request: Request):
             content={"error": f"Internal server error: {str(e)}"}
         )
 
-# === Test endpoint for debugging modes ===
+# === Test endpoint optimized for 0.5B ===
 @app.post("/test")
 async def test_generation(request: Request):
-    """Test endpoint for debugging both modes"""
+    """Test endpoint for debugging both modes with 0.5B optimizations"""
     try:
         body = await request.json()
         prompt = body.get("prompt", "How do I print hello world in Python?")
-        max_tokens = body.get("max_tokens", 300)
+        max_tokens = min(body.get("max_tokens", 200), 300)
         test_both_modes = body.get("test_both_modes", True)
         
         results = {}
         
         # Test mentor mode
-        messages_mentor = [
-            {"role": "user", "content": prompt}
-        ]
-        mentor_response = generate_response(messages_mentor, is_force_mode=False, max_tokens=max_tokens, temperature=0.7)
+        messages_mentor = [{"role": "user", "content": prompt}]
+        mentor_response = generate_response(messages_mentor, is_force_mode=False, max_tokens=max_tokens, temperature=0.3)
         results["mentor_mode"] = {
             "response": mentor_response,
             "length": len(mentor_response),
@@ -386,10 +493,8 @@ async def test_generation(request: Request):
         
         if test_both_modes:
             # Test force mode
-            messages_force = [
-                {"role": "user", "content": prompt}
-            ]
-            force_response = generate_response(messages_force, is_force_mode=True, max_tokens=max_tokens, temperature=0.3)
+            messages_force = [{"role": "user", "content": prompt}]
+            force_response = generate_response(messages_force, is_force_mode=True, max_tokens=max_tokens, temperature=0.1)
             results["force_mode"] = {
                 "response": force_response,
                 "length": len(force_response),
@@ -399,8 +504,9 @@ async def test_generation(request: Request):
         return {
             "prompt": prompt,
             "results": results,
-            "status": "success",
-            "cleaning": "single_backend_only"
+            "model": "Qwen2-0.5B-Instruct",
+            "optimizations": "0.5B_specific",
+            "status": "success"
         }
         
     except Exception as e:
@@ -411,7 +517,8 @@ async def test_generation(request: Request):
 
 if __name__ == "__main__":
     import uvicorn
-    print("🚀 Starting Apollo AI Backend v2.0...")
-    print("📊 Features: Mode-specific prompts, Single powerful cleaning")
-    print("🎯 Modes: Mentor (guides learning) vs Force (direct answers)")
+    print("🚀 Starting Apollo AI Backend v2.1 - Qwen2-0.5B Optimized...")
+    print("🧠 Model: Qwen/Qwen2-0.5B-Instruct (500M parameters)")
+    print("⚡ Optimizations: Short contexts, conservative generation, predefined responses")
+    print("🎯 Modes: Mentor (simple questions) vs Force (direct answers)")
     uvicorn.run(app, host="0.0.0.0", port=7860)