Update app/main.py

app/main.py

@@ -5,10 +5,9 @@ from fastapi.responses import JSONResponse
 from transformers import AutoModelForCausalLM, AutoTokenizer
 from peft import PeftModel
 from starlette.middleware.cors import CORSMiddleware
-import re
 
 # === Setup FastAPI ===
-app = FastAPI(title="Apollo AI Backend - Qwen2-0.5B Optimized", version="2.1.0")
+app = FastAPI(title="Apollo AI Backend - Qwen2-0.5B", version="3.0.0")
 
 # === CORS ===
 app.add_middleware(
@@ -42,527 +41,102 @@ print("🔗 Applying LoRA adapter to Qwen2-0.5B...")
 model = PeftModel.from_pretrained(base_model, ADAPTER_PATH)
 model.eval()
 
-print("✅ Qwen2-0.5B model ready with optimized settings!")
+print("✅ Qwen2-0.5B model ready!")
 
-def analyze_conversation_context(messages: list) -> dict:
+def create_conversation_prompt(messages: list, is_force_mode: bool) -> str:
     """
-    Enhanced conversation analysis to understand context and user progress.
+    Create a simple conversation prompt with appropriate system instruction
     """
-    context = {
-        "conversation_history": [],
-        "user_messages": [],
-        "assistant_messages": [],
-        "topics": [],
-        "current_topic": None,
-        "user_attempted_code": False,
-        "user_stuck": False,
-        "repeated_questions": 0,
-        "question_type": "general",
-        "learning_progression": "beginner"
-    }
-    
-    # Get last 6 messages (3 user + 3 assistant)
-    recent_messages = messages[-6:] if len(messages) > 6 else messages
-    
-    for msg in recent_messages:
-        context["conversation_history"].append({
-            "role": msg.get("role"),
-            "content": msg.get("content", "")
-        })
-        
-        if msg.get("role") == "user":
-            content = msg.get("content", "").lower()
-            context["user_messages"].append(msg.get("content", ""))
-            
-            # Detect question types
-            if "what" in content and ("print" in content or "output" in content):
-                context["question_type"] = "basic_concept"
-                context["current_topic"] = "print_function"
-            elif "output" in content and "print" in content:
-                context["question_type"] = "prediction"
-                context["current_topic"] = "print_output"
-            elif "calculator" in content or "create" in content:
-                context["question_type"] = "project_request"
-                context["current_topic"] = "calculator"
-            elif "function" in content:
-                context["question_type"] = "concept_inquiry"
-                context["current_topic"] = "functions"
-            elif "variable" in content:
-                context["question_type"] = "concept_inquiry"
-                context["current_topic"] = "variables"
-            elif "error" in content or "not working" in content or "tried" in content:
-                context["user_attempted_code"] = True
-                context["question_type"] = "debugging"
-            
-            # Check for repeated similar questions
-            if len(context["user_messages"]) >= 2:
-                recent_questions = context["user_messages"][-2:]
-                similarity_keywords = ["what", "how", "print", "output", "function"]
-                common_words = 0
-                for keyword in similarity_keywords:
-                    if keyword in recent_questions[0].lower() and keyword in recent_questions[1].lower():
-                        common_words += 1
-                if common_words >= 2:
-                    context["repeated_questions"] += 1
-                    
-        elif msg.get("role") == "assistant":
-            context["assistant_messages"].append(msg.get("content", ""))
-    
-    # Determine learning progression
-    if len(context["user_messages"]) > 2:
-        context["learning_progression"] = "intermediate"
-    if context["user_attempted_code"]:
-        context["learning_progression"] = "hands_on"
-    
-    return context
-
-def generate_mentor_response(user_message: str, context: dict) -> str:
-    """
-    Generate context-aware mentor responses that guide learning through questions.
-    """
-    user_lower = user_message.lower()
-    question_type = context.get("question_type", "general")
-    current_topic = context.get("current_topic", None)
-    user_attempted = context.get("user_attempted_code", False)
-    conversation_length = len(context.get("user_messages", []))
-    
-    print(f"🎓 Mentor mode - Question type: {question_type}, Topic: {current_topic}, Attempted: {user_attempted}")
-    
-    # Handle basic concept questions about print()
-    if "what" in user_lower and "print" in user_lower:
-        if "use" in user_lower or "does" in user_lower:
-            return """What do you think the word "print" suggests? 🤔
-
-In everyday life, when we print something, we make it visible on paper. What do you think `print()` might do in Python?
-
-**Think about:**
-- Where would Python show information to you?
-- If you wanted to see the result of your code, how would Python display it?
-
-Try to guess what happens when you run `print("hello")`!"""
-        
-        return """Good question! Let's think step by step:
-
-**What does "print" mean in real life?** 
-When you print a document, you make it visible, right?
-
-**In Python, where do you think the output would appear?**
-- On your screen? 
-- In a file?
-- Somewhere else?
-
-What do you think `print()` is designed to do? Take a guess! 🤔"""
-
-    # Handle output prediction questions
-    if ("output" in user_lower or "result" in user_lower) and "print" in user_lower:
-        if current_topic == "print_function" or "print" in user_lower:
-            return """Great follow-up question! You're thinking like a programmer! 🎯
-
-**Before I tell you, let's think:**
-1. What's inside those quotation marks?
-2. When Python sees `print("something")`, what do you think it does with that "something"?
-
-**Try to predict:**
-- Will it show exactly what's in the quotes?
-- Will it change it somehow?
-- Where will you see the result?
-
-What's your prediction? Then try running it and see if you're right! 🔍"""
-    
-    # Handle calculator project requests
-    if "calculator" in user_lower and ("create" in user_lower or "make" in user_lower):
-        if conversation_length == 1:  # First time asking
-            return """Excellent project choice! Let's break this down step by step 🧮
-
-**Think about using a calculator in real life:**
-1. What's the first thing you need to input?
-2. What operation do you want to perform?
-3. What's the second number?
-4. What should happen next?
-
-**Start simple:** How would you get just ONE number from the user in Python? What function do you think gets user input? 🤔
-
-Once you figure that out, we'll build on it!"""
-        else:  # Follow-up on calculator
-            return """Great! You're building on what you know! 🔨
-
-**Next step thinking:**
-- You can get user input ✓
-- Now how do you perform math operations?
-- What if the user wants addition? Subtraction? 
-
-**Challenge:** Can you think of a way to let the user CHOOSE which operation they want?
-
-Hint: How does your code make decisions? What happens "IF" the user picks "+"? 🤔"""
-    
-    # Handle debugging/error situations  
-    if user_attempted and ("error" in user_lower or "not working" in user_lower or "tried" in user_lower):
-        return """I love that you're experimenting! That's how you learn! 🔧
-
-**Debugging steps:**
-1. What exactly did you type?
-2. What happened when you ran it?
-3. What did you expect to happen?
-4. Are there any red error messages?
-
-**Common issues to check:**
-- Did you use parentheses `()` correctly?
-- Are your quotation marks matched?
-- Did you spell everything correctly?
-
-Share what you tried and what error you got - let's debug it together! 🐛"""
-    
-    # Handle function-related questions
-    if "function" in user_lower:
-        if current_topic == "print_function":
-            return """Perfect! You're asking the right questions! 🎯
-
-**Let's think about functions:**
-- What's a function in math? (like f(x) = x + 2)
-- It takes input and gives output, right?
-
-**In Python:**
-- `print()` is a function
-- What goes inside the parentheses `()` is the input
-- What do you think the output is?
-
-**Try this thinking exercise:**
-If `print()` is like a machine, what does it do with whatever you put inside? 🤖"""
-    
-    # Handle variable questions
-    if "variable" in user_lower:
-        return """Variables are like labeled boxes! 📦
-
-**Think about it:**
-- How do you remember someone's name?
-- How do you store something for later?
-
-**In Python:**
-- How would you tell Python to "remember" a number?
-- What symbol might connect a name to a value?
-
-Try to guess: `age __ 25` - what goes in the blank? 🤔"""
-    
-    # Handle repeated questions (user might be stuck)
-    if context.get("repeated_questions", 0) > 0:
-        return """I notice you're asking similar questions - that's totally fine! Learning takes time! 📚
-
-**Let's try a different approach:**
-1. What specific part is confusing you?
-2. Have you tried running any code yet?
-3. What happened when you tried?
-
-**Suggestion:** Start with something super simple:
-- Open Python
-- Type one line of code
-- See what happens
-
-What's the smallest thing you could try right now? 🚀"""
-    
-    # Generic mentor response with context awareness
-    if conversation_length > 0:
-        return """I can see you're building on our conversation! That's great! 🎯
-
-**Let's break down your question:**
-- What specifically do you want to understand?
-- Are you trying to predict what will happen?
-- Or are you looking to build something?
-
-**Think step by step:**
-What's the smallest piece of this problem you could solve first? 🧩"""
-    
-    # Default mentor response
-    return """Interesting question! Let's think through this together! 🤔
-
-**Questions to consider:**
-- What are you trying to accomplish?
-- What do you already know about this topic?
-- What's the first small step you could take?
-
-Break it down into smaller pieces - what would you try first? 🚀"""
-
-def generate_force_response(user_message: str, context: dict) -> str:
-    """
-    Generate direct, complete answers for force mode.
-    """
-    user_lower = user_message.lower()
-    current_topic = context.get("current_topic", None)
-    
-    print(f"⚡ Force mode - Topic: {current_topic}")
-    
-    # Direct answer for print() function questions
-    if "what" in user_lower and "print" in user_lower:
-        if "use" in user_lower or "does" in user_lower or "function" in user_lower:
-            return """`print()` is a built-in Python function that displays output to the console/screen.
-
-**Purpose:** Shows text, numbers, or variables to the user.
-
-**Syntax:** `print(value)`
-
-**Examples:**
-```python
-print("Hello World")    # Outputs: Hello World
-print(42)              # Outputs: 42
-print(3 + 5)           # Outputs: 8
-```
-
-**What it does:** Takes whatever you put inside the parentheses and displays it on the screen."""
-    
-    # Direct answer for output prediction
-    if ("output" in user_lower or "result" in user_lower) and "print" in user_lower:
-        # Check if they're asking about a specific print statement
-        if '"ais"' in user_message or "'ais'" in user_message:
-            return """The output of `print("ais")` will be exactly:
-
-```
-ais
-```
-
-**Explanation:** The `print()` function displays whatever text is inside the quotation marks, without the quotes themselves. So `"ais"` becomes just `ais` on the screen."""
-        
-        elif "hello" in user_lower:
-            return """The output of `print("Hello World")` will be:
-
-```
-Hello World
-```
-
-The text inside the quotes appears on the screen without the quotation marks."""
-        
-        return """The output depends on what's inside the `print()` function:
-
-**Examples:**
-- `print("text")` → displays: `text`
-- `print(123)` → displays: `123`  
-- `print(2 + 3)` → displays: `5`
-
-The `print()` function shows the value without quotes (for strings) or evaluates expressions first."""
-    
-    # Direct answer for calculator project
-    if "calculator" in user_lower and ("create" in user_lower or "make" in user_lower):
-        return """Here's a complete working calculator:
-
-```python
-# Simple Calculator
-print("=== Simple Calculator ===")
-
-# Get input from user
-num1 = float(input("Enter first number: "))
-operator = input("Enter operator (+, -, *, /): ")
-num2 = float(input("Enter second number: "))
-
-# Perform calculation
-if operator == '+':
-    result = num1 + num2
-elif operator == '-':
-    result = num1 - num2
-elif operator == '*':
-    result = num1 * num2
-elif operator == '/':
-    if num2 != 0:
-        result = num1 / num2
+    if is_force_mode:
+        system_prompt = "You are a helpful coding assistant. Give direct, clear answers with code examples when needed. Be concise and practical."
     else:
-        result = "Error: Cannot divide by zero"
-else:
-    result = "Error: Invalid operator"
-
-# Display result
-print(f"Result: {result}")
-```
-
-**How it works:**
-1. Gets two numbers from user using `input()` and converts to `float()`
-2. Gets the operator (+, -, *, /)
-3. Uses `if/elif` statements to perform the correct operation
-4. Displays the result using `print()`"""
+        system_prompt = "You are a teacher helping a student learn programming. Don't give direct answers. Instead, ask guiding questions to help them think and discover the solution themselves. Guide them step by step with questions like 'What do you think...?' or 'How would you...?'"
     
-    # Direct answer for functions
-    if "function" in user_lower and ("what" in user_lower or "define" in user_lower):
-        return """Functions in Python are reusable blocks of code that perform specific tasks.
-
-**Defining a function:**
-```python
-def function_name(parameters):
-    # code here
-    return result
-```
-
-**Example:**
-```python
-def greet(name):
-    return f"Hello, {name}!"
-
-def add_numbers(a, b):
-    return a + b
-
-# Calling functions
-message = greet("Alice")     # Returns "Hello, Alice!"
-sum_result = add_numbers(5, 3)  # Returns 8
-```
-
-**Key points:**
-- Use `def` keyword to define functions
-- Functions can take parameters (inputs)
-- Use `return` to send back a result
-- Call functions by using their name with parentheses"""
-    
-    # Direct answer for variables
-    if "variable" in user_lower:
-        return """Variables in Python store data values using the assignment operator `=`.
-
-**Syntax:** `variable_name = value`
-
-**Examples:**
-```python
-name = "John"           # String variable
-age = 25               # Integer variable
-height = 5.8           # Float variable
-is_student = True      # Boolean variable
-```
-
-**Rules:**
-- Variable names can contain letters, numbers, and underscores
-- Must start with a letter or underscore
-- Case-sensitive (`age` and `Age` are different)
-- Use descriptive names (`user_age` not `x`)
-
-**Using variables:**
-```python
-print(name)           # Outputs: John
-print(age + 5)        # Outputs: 30
-```"""
-    
-    # Direct answer for input function
-    if "input" in user_lower and ("function" in user_lower or "how" in user_lower):
-        return """`input()` function gets text from the user.
-
-**Syntax:** `variable = input("prompt message")`
-
-**Examples:**
-```python
-name = input("Enter your name: ")
-age = input("Enter your age: ")
-print(f"Hello {name}, you are {age} years old")
-```
-
-**Important:** `input()` always returns a string. For numbers, convert:
-```python
-age = int(input("Enter age: "))        # For whole numbers
-price = float(input("Enter price: "))  # For decimals
-```
-
-**Common pattern:**
-```python
-user_input = input("Your choice: ")
-print(f"You entered: {user_input}")
-```"""
+    # Build conversation
+    conversation = f"System: {system_prompt}\n\n"
     
-    # Generic force response for unmatched questions
-    return """I need a more specific question to provide a direct answer. 
-
-**Try asking:**
-- "What does print() do in Python?"
-- "How do I create variables?"
-- "Show me how to make a calculator"
-- "What is the output of print('hello')?"
-
-Please rephrase your question more specifically."""
-
-def extract_clean_answer(full_response: str, formatted_prompt: str, user_message: str, context: dict, is_force_mode: bool) -> str:
-    """
-    FIXED: Clean response extraction with proper mode handling and context awareness.
-    """
-    if not full_response or len(full_response.strip()) < 5:
-        # Fallback to context-aware responses
-        if is_force_mode:
-            return generate_force_response(user_message, context)
-        else:
-            return generate_mentor_response(user_message, context)
+    # Add last 6 messages (3 pairs) for context
+    recent_messages = messages[-6:] if len(messages) > 6 else messages
     
-    print(f"🔍 Raw response length: {len(full_response)}")
-    print(f"🔍 Mode: {'FORCE' if is_force_mode else 'MENTOR'}")
-    print(f"🔍 Context: {context.get('question_type', 'unknown')} - {context.get('current_topic', 'general')}")
+    for msg in recent_messages:
+        role = msg.get("role", "")
+        content = msg.get("content", "")
+        if role == "user":
+            conversation += f"Student: {content}\n"
+        elif role == "assistant":
+            conversation += f"Assistant: {content}\n"
     
-    # ALWAYS use context-aware predefined responses - they handle conversation flow properly
-    if is_force_mode:
-        predefined_response = generate_force_response(user_message, context)
-        print("✅ Using context-aware FORCE response")
-        return predefined_response
-    else:
-        predefined_response = generate_mentor_response(user_message, context)
-        print("✅ Using context-aware MENTOR response")
-        return predefined_response
+    conversation += "Assistant:"
+    return conversation
 
 def generate_response(messages: list, is_force_mode: bool = False, max_tokens: int = 200, temperature: float = 0.7) -> str:
     """
-    FIXED: Enhanced generation with proper conversation history and guaranteed mode compliance.
+    Generate response using the actual AI model
     """
     try:
-        # Enhanced conversation context analysis
-        context = analyze_conversation_context(messages)
-        print(f"📊 Enhanced context analysis: {context}")
+        # Create conversation prompt
+        prompt = create_conversation_prompt(messages, is_force_mode)
+        
+        print(f"🎯 Generating {'FORCE' if is_force_mode else 'MENTOR'} response")
+        print(f"📝 Prompt length: {len(prompt)}")
+        
+        # Tokenize input
+        inputs = tokenizer(prompt, return_tensors="pt", max_length=1024, truncation=True)
+        
+        # Generate response
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs.input_ids,
+                max_new_tokens=max_tokens,
+                temperature=temperature,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                top_p=0.9,
+                repetition_penalty=1.1
+            )
         
-        # Get the current user message
-        current_user_message = ""
-        for msg in reversed(messages):
-            if msg.get("role") == "user":
-                current_user_message = msg.get("content", "")
-                break
+        # Decode response
+        full_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
         
-        if not current_user_message:
-            return "I didn't receive a message. Please ask me something!"
+        # Extract only the new generated part
+        response = full_response[len(prompt):].strip()
         
-        print(f"🎯 Processing: '{current_user_message}' in {'FORCE' if is_force_mode else 'MENTOR'} mode")
-        print(f"📚 Conversation length: {len(context.get('conversation_history', []))} messages")
-        print(f"🔍 Question type: {context.get('question_type', 'unknown')}")
-        print(f"📖 Current topic: {context.get('current_topic', 'general')}")
+        # Clean up response
+        response = response.replace("Student:", "").replace("Assistant:", "").strip()
         
-        # ALWAYS use context-aware predefined responses for reliability
-        if is_force_mode:
-            response = generate_force_response(current_user_message, context)
-            print("✅ Generated FORCE mode response")
-        else:
-            response = generate_mentor_response(current_user_message, context)
-            print("✅ Generated MENTOR mode response")
+        # Remove any system mentions
+        if response.startswith("System:"):
+            response = response.split("\n", 1)[-1].strip()
         
-        # Validate response matches expected mode behavior
-        if not is_force_mode:
-            # Mentor mode should ask questions or provide guidance
-            has_questions = '?' in response or any(word in response.lower() for word in ['think', 'consider', 'try', 'what', 'how', 'why'])
-            if not has_questions:
-                print("⚠️ Mentor response lacks questions, enhancing...")
-                response += "\n\nWhat do you think? Give it a try! 🤔"
-        else:
-            # Force mode should provide direct answers
-            if len(response) < 30 and 'specific' in response:
-                print("⚠️ Force response too vague, enhancing...")
-                response = generate_force_response(current_user_message, context)
+        print(f"✅ Generated response length: {len(response)}")
         
-        print(f"📤 Final response length: {len(response)}")
-        print(f"📝 Response preview: {response[:100]}...")
+        if not response or len(response) < 10:
+            # Fallback responses
+            if is_force_mode:
+                return "I need more specific information to provide a direct answer. Please clarify your question."
+            else:
+                return "That's an interesting question! What do you think the answer might be? Try to break it down step by step."
         
         return response
         
     except Exception as e:
         print(f"❌ Generation error: {e}")
-        # Context-aware error fallback
         if is_force_mode:
-            return "I encountered an error processing your request. Please try rephrasing your question more specifically."
+            return "I encountered an error. Please try rephrasing your question."
         else:
-            return "I had trouble processing that. What specific aspect would you like to explore? Can you break down your question into smaller parts? 🤔"
+            return "I had trouble processing that. Can you tell me what you're trying to understand?"
 
 # === Routes ===
 @app.get("/")
 def root():
     return {
-        "message": "🤖 Apollo AI Backend v2.1 - Context-Aware Qwen2-0.5B",
+        "message": "🤖 Apollo AI Backend v3.0 - Qwen2-0.5B",
         "model": "Qwen/Qwen2-0.5B-Instruct with LoRA", 
         "status": "ready",
-        "optimizations": ["context_aware", "conversation_history", "progressive_guidance", "guaranteed_mode_compliance"],
-        "features": ["mentor_mode", "force_mode", "context_analysis", "topic_tracking"],
         "modes": {
-            "mentor": "Guides learning with contextual questions and conversation awareness",
-            "force": "Provides direct answers based on conversation context and history"
+            "mentor": "Guides learning with questions",
+            "force": "Provides direct answers"
         }
     }
 
@@ -571,8 +145,7 @@ def health():
     return {
         "status": "healthy", 
         "model_loaded": True, 
-        "model_size": "0.5B",
-        "optimizations": "context_aware_with_guaranteed_mode_compliance"
+        "model_size": "0.5B"
     }
 
 @app.post("/v1/chat/completions")
@@ -597,7 +170,7 @@ async def chat_completions(request: Request):
         body = await request.json()
         messages = body.get("messages", [])
         max_tokens = min(body.get("max_tokens", 200), 400)
-        temperature = max(0.1, min(body.get("temperature", 0.5), 0.8))
+        temperature = max(0.1, min(body.get("temperature", 0.7), 1.0))
         
         is_force_mode = body.get("force_mode", False)
         
@@ -619,8 +192,8 @@ async def chat_completions(request: Request):
             )
 
     try:
-        print(f"📥 Processing FIXED context-aware request in {'FORCE' if is_force_mode else 'MENTOR'} mode")
-        print(f"📊 Total conversation: {len(messages)} messages")
+        print(f"📥 Processing request in {'FORCE' if is_force_mode else 'MENTOR'} mode")
+        print(f"📊 Total messages: {len(messages)}")
         
         response_content = generate_response(
             messages=messages,
@@ -630,10 +203,10 @@ async def chat_completions(request: Request):
         )
         
         return {
-            "id": f"chatcmpl-apollo-qwen05b-fixed-{hash(str(messages)) % 10000}",
+            "id": f"chatcmpl-apollo-{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'}-contextaware-fixed",
+            "model": f"qwen2-0.5b-{'force' if is_force_mode else 'mentor'}",
             "choices": [
                 {
                     "index": 0,
@@ -649,8 +222,7 @@ 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",
-            "model_optimizations": "context_aware_conversation_with_guaranteed_compliance"
+            "apollo_mode": "force" if is_force_mode else "mentor"
         }
         
     except Exception as e:
@@ -660,60 +232,10 @@ async def chat_completions(request: Request):
             content={"error": f"Internal server error: {str(e)}"}
         )
 
-@app.post("/test")
-async def test_generation(request: Request):
-    """Enhanced test endpoint with conversation context and mode validation"""
-    try:
-        body = await request.json()
-        prompt = body.get("prompt", "What does print() do in Python?")
-        max_tokens = min(body.get("max_tokens", 200), 400)
-        test_both_modes = body.get("test_both_modes", True)
-        
-        # Simulate conversation context
-        messages = [{"role": "user", "content": prompt}]
-        
-        results = {}
-        
-        # Test mentor mode
-        mentor_response = generate_response(messages, is_force_mode=False, max_tokens=max_tokens, temperature=0.4)
-        results["mentor_mode"] = {
-            "response": mentor_response,
-            "length": len(mentor_response),
-            "mode": "mentor",
-            "asks_questions": "?" in mentor_response,
-            "has_guidance_words": any(word in mentor_response.lower() for word in ['think', 'try', 'consider', 'what', 'how'])
-        }
-        
-        if test_both_modes:
-            # Test force mode
-            force_response = generate_response(messages, is_force_mode=True, max_tokens=max_tokens, temperature=0.2)
-            results["force_mode"] = {
-                "response": force_response,
-                "length": len(force_response),
-                "mode": "force",
-                "provides_code": "```" in force_response or "`" in force_response,
-                "is_direct": len(force_response) > 50 and not ("think" in force_response.lower() and "?" in force_response)
-            }
-        
-        return {
-            "prompt": prompt,
-            "results": results,
-            "model": "Qwen2-0.5B-Instruct-Fixed",
-            "optimizations": "context_aware_conversation_with_guaranteed_mode_compliance",
-            "status": "success"
-        }
-        
-    except Exception as e:
-        return JSONResponse(
-            status_code=500,
-            content={"error": str(e)}
-        )
-
 if __name__ == "__main__":
     import uvicorn
-    print("🚀 Starting FIXED Apollo AI Backend v2.1 - Context-Aware Qwen2-0.5B...")
+    print("🚀 Starting Apollo AI Backend v3.0 - Simple & Clean...")
     print("🧠 Model: Qwen/Qwen2-0.5B-Instruct (500M parameters)")
-    print("⚡ Optimizations: Context-aware responses, conversation history, guaranteed mode compliance")
-    print("🎯 Modes: Mentor (guided questions) vs Force (direct answers)")
-    print("🔧 Fixed: Proper mode detection, conversation context, topic tracking")
+    print("🎯 Mentor Mode: Asks guiding questions")
+    print("⚡ Force Mode: Gives direct answers")
     uvicorn.run(app, host="0.0.0.0", port=7860)