Update app/main.py

app/main.py

@@ -7,7 +7,7 @@ from peft import PeftModel
 from starlette.middleware.cors import CORSMiddleware
 
 # === Setup FastAPI ===
-app = FastAPI(title="Apollo AI Backend - Qwen2-0.5B", version="4.0.0-TRULY-FIXED")
+app = FastAPI(title="Apollo AI Backend - Fixed", version="5.0.0")
 
 # === CORS ===
 app.add_middleware(
@@ -24,12 +24,12 @@ BASE_MODEL = "Qwen/Qwen2-0.5B-Instruct"
 ADAPTER_PATH = "adapter"
 
 # === Load Model ===
-print("🔧 Loading tokenizer for Qwen2-0.5B...")
+print("🔧 Loading tokenizer...")
 tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
 if tokenizer.pad_token is None:
     tokenizer.pad_token = tokenizer.eos_token
 
-print("🧠 Loading Qwen2-0.5B base model...")
+print("🧠 Loading base model...")
 base_model = AutoModelForCausalLM.from_pretrained(
     BASE_MODEL,
     trust_remote_code=True,
@@ -37,240 +37,170 @@ base_model = AutoModelForCausalLM.from_pretrained(
     device_map="cpu"
 )
 
-print("🔗 Applying LoRA adapter to Qwen2-0.5B...")
+print("🔗 Loading adapter...")
 model = PeftModel.from_pretrained(base_model, ADAPTER_PATH)
 model.eval()
+print("✅ Model ready!")
 
-print("✅ Qwen2-0.5B model ready!")
-
-def create_conversation_prompt(messages: list, is_force_mode: bool) -> str:
-    """Create a conversation prompt with clear mode instructions"""
+def build_simple_prompt(messages: list, force_mode: bool = False) -> str:
+    """Create a clean, simple prompt"""
     
-    if is_force_mode:
-        system_prompt = """You are a helpful programming assistant. Give direct, complete answers with examples. Do not ask questions back to the user. Provide clear explanations and working code when relevant.
-When asked about Python functions, provide:
-1. What the function does
-2. Clear examples with output
-3. Common use cases
-Be direct and informative."""
+    # Simple system prompts
+    if force_mode:
+        system = "You are a helpful coding assistant. Give clear, direct answers with examples when asked."
     else:
-        system_prompt = """You are a programming teacher focused on helping students learn through discovery. Guide students with questions and hints rather than giving direct answers. 
-When asked about concepts:
-1. Ask what they think might happen
-2. Encourage them to try things out
-3. Guide them to discover patterns
-4. Ask follow-up questions to deepen understanding
-Help them learn by thinking, not by giving answers directly."""
+        system = "You are a coding teacher. Help students learn by asking guiding questions instead of giving direct answers."
     
     # Build conversation
-    conversation = f"<|im_start|>system\n{system_prompt}<|im_end|>\n"
+    prompt = f"<|im_start|>system\n{system}<|im_end|>\n"
     
-    # Add conversation history (last 4 messages for context)
-    recent_messages = messages[-4:] if len(messages) > 4 else messages
+    # Add only the last few messages for context
+    recent_messages = messages[-3:] if len(messages) > 3 else messages
     
     for msg in recent_messages:
-        role = msg.get("role", "")
+        role = msg.get("role", "user")
         content = msg.get("content", "")
-        conversation += f"<|im_start|>{role}\n{content}<|im_end|>\n"
+        prompt += f"<|im_start|>{role}\n{content}<|im_end|>\n"
     
-    conversation += "<|im_start|>assistant\n"
-    return conversation
+    prompt += "<|im_start|>assistant\n"
+    return prompt
 
-def generate_response(messages: list, is_force_mode: bool = False, max_tokens: int = 200, temperature: float = 0.7) -> str:
-    """Generate response using the AI model"""
+def generate_clean_response(messages: list, force_mode: bool = False, max_tokens: int = 200) -> str:
+    """Generate a clean response"""
     try:
-        # Create conversation prompt
-        prompt = create_conversation_prompt(messages, is_force_mode)
-        
-        print(f"🎯 Generating {'FORCE (Direct)' if is_force_mode else 'MENTOR (Questions)'} response")
-        print(f"🔍 Mode flag: {is_force_mode}")
-        
-        # Adjust parameters based on mode
-        if is_force_mode:
-            generation_temp = 0.3  # More focused for direct answers
-            generation_tokens = min(max_tokens, 300)
-        else:
-            generation_temp = 0.5  # More creative for questions
-            generation_tokens = min(max_tokens, 250)
-        
-        # Tokenize input
-        inputs = tokenizer(prompt, return_tensors="pt", max_length=1500, truncation=True)
+        # Build prompt
+        prompt = build_simple_prompt(messages, force_mode)
+        
+        print(f"🎯 Mode: {'FORCE' if force_mode else 'MENTOR'}")
+        print(f"📝 Prompt length: {len(prompt)} chars")
+        
+        # Tokenize
+        inputs = tokenizer(
+            prompt, 
+            return_tensors="pt", 
+            max_length=1000, 
+            truncation=True
+        )
         
-        # Generate response
+        # Generate
         with torch.no_grad():
             outputs = model.generate(
                 inputs.input_ids,
-                max_new_tokens=generation_tokens,
-                temperature=generation_temp,
+                max_new_tokens=max_tokens,
+                temperature=0.4 if force_mode else 0.6,
                 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,
-                no_repeat_ngram_size=3
+                repetition_penalty=1.1
             )
         
-        # Decode response
-        full_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        # Decode
+        full_output = tokenizer.decode(outputs[0], skip_special_tokens=True)
         
-        # Extract only the new generated part
-        response = full_response[len(prompt):].strip()
+        # Extract only the assistant's response
+        response = full_output[len(prompt):].strip()
         
-        # Clean up response
+        # Clean up
         response = response.replace("<|im_end|>", "").strip()
         
-        # Remove conversation artifacts
+        # Remove any leftover formatting
         lines = response.split('\n')
         clean_lines = []
         for line in lines:
             line = line.strip()
-            if not line.startswith(('<|im_start|>', '<|im_end|>', 'system:', 'user:', 'assistant:')):
+            if line and not line.startswith(('<|im_start|>', '<|im_end|>')):
                 clean_lines.append(line)
         
-        response = '\n'.join(clean_lines).strip()
+        final_response = '\n'.join(clean_lines).strip()
         
-        # Take first paragraph if too long
-        if len(response) > max_tokens * 4:
-            paragraphs = response.split('\n\n')
-            response = paragraphs[0] if paragraphs else response[:max_tokens * 4]
-        
-        print(f"✅ Generated response: {response[:100]}...")
-        
-        # Simple validation - no template injection
-        if not response or len(response) < 10:
-            if is_force_mode:
-                return "I need more specific information to provide a direct answer. Could you clarify your question?"
+        # Validate response
+        if len(final_response) < 5:
+            if force_mode:
+                return "I need more details to give you a specific answer."
             else:
-                return "That's a great question to explore! What do you think might be the answer? Try experimenting and see what you discover!"
+                return "What do you think the answer might be? Try exploring it step by step."
+        
+        # Truncate if too long
+        if len(final_response) > max_tokens * 5:
+            sentences = final_response.split('. ')
+            truncated = '. '.join(sentences[:3]) + '.' if len(sentences) > 3 else final_response
+            final_response = truncated
         
-        return response
+        print(f"✅ Response: {final_response[:100]}...")
+        return final_response
         
     except Exception as e:
-        print(f"❌ Generation error: {e}")
-        if is_force_mode:
-            return "I encountered an error generating a direct response. Please try rephrasing your question."
-        else:
-            return "Interesting challenge! What approach do you think might work here? Let's explore this together."
+        print(f"❌ Error: {e}")
+        return "I encountered an issue. Could you try rephrasing your question?"
 
 # === Routes ===
 @app.get("/")
 def root():
     return {
-        "message": "🤖 Apollo AI Backend v4.0-TRULY-FIXED - Qwen2-0.5B",
-        "model": "Qwen/Qwen2-0.5B-Instruct with LoRA", 
+        "message": "🤖 Apollo AI Backend - Fixed",
         "status": "ready",
-        "modes": {
-            "mentor": "Guides learning with questions - REALLY FIXED",
-            "force": "Provides direct answers - REALLY FIXED"
-        },
-        "fixes": "Removed all template responses, pure AI generation"
+        "version": "5.0.0"
     }
 
 @app.get("/health")
 def health():
-    return {
-        "status": "healthy", 
-        "model_loaded": True, 
-        "model_size": "0.5B",
-        "version": "4.0-TRULY-FIXED"
-    }
+    return {"status": "healthy", "model_loaded": True}
 
 @app.post("/v1/chat/completions")
 async def chat_completions(request: Request):
-    # Validate API key
+    # Auth check
     auth_header = request.headers.get("Authorization", "")
     if not auth_header.startswith("Bearer "):
-        return JSONResponse(
-            status_code=401, 
-            content={"error": "Missing or invalid Authorization header"}
-        )
+        return JSONResponse(status_code=401, content={"error": "Missing Authorization"})
 
     token = auth_header.replace("Bearer ", "").strip()
     if token != API_KEY:
-        return JSONResponse(
-            status_code=401, 
-            content={"error": "Invalid API key"}
-        )
+        return JSONResponse(status_code=401, content={"error": "Invalid API key"})
 
-    # Parse request body
+    # Parse request
     try:
         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.7), 1.0))
-        
-        # Get force mode flag
-        is_force_mode = body.get("force_mode", False)
+        max_tokens = min(body.get("max_tokens", 200), 300)
+        force_mode = body.get("force_mode", False)
         
-        print(f"🚨 REQUEST RECEIVED - force_mode: {is_force_mode}")
-        print(f"📝 Last user message: {messages[-1].get('content', '') if messages else 'None'}")
+        print(f"🔥 Request: force_mode={force_mode}, messages={len(messages)}")
         
-        if not messages or not isinstance(messages, list):
-            raise ValueError("Messages field is required and must be a list")
+        if not messages:
+            raise ValueError("Messages required")
             
     except Exception as e:
-        return JSONResponse(
-            status_code=400, 
-            content={"error": f"Invalid request body: {str(e)}"}
-        )
-
-    # 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(
-                status_code=400,
-                content={"error": f"Invalid message format at index {i}"}
-            )
+        return JSONResponse(status_code=400, content={"error": str(e)})
 
     try:
-        print(f"📥 Processing in {'FORCE (Direct Answer)' if is_force_mode else 'MENTOR (Guiding Questions)'} mode")
-        
-        # Generate response - NO POST-PROCESSING
-        response_content = generate_response(
+        # Generate response
+        response_content = generate_clean_response(
             messages=messages,
-            is_force_mode=is_force_mode,
-            max_tokens=max_tokens,
-            temperature=temperature
+            force_mode=force_mode,
+            max_tokens=max_tokens
         )
         
-        print(f"✅ Pure AI response generated: {response_content[:150]}...")
-        
         return {
-            "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'}-truly-fixed",
-            "choices": [
-                {
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": response_content
-                    },
-                    "finish_reason": "stop"
-                }
-            ],
-            "usage": {
-                "prompt_tokens": len(str(messages)),
-                "completion_tokens": len(response_content),
-                "total_tokens": len(str(messages)) + len(response_content)
-            },
-            "apollo_mode": "force_direct" if is_force_mode else "mentor_questions",
-            "pure_ai_response": True
+            "id": f"chatcmpl-{hash(str(messages)) % 10000}",
+            "object": "chat.completion", 
+            "model": f"qwen2-{'force' if force_mode else 'mentor'}",
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": response_content
+                },
+                "finish_reason": "stop"
+            }],
+            "apollo_mode": "force" if force_mode else "mentor"
         }
         
     except Exception as e:
-        print(f"❌ Chat completion error: {e}")
-        return JSONResponse(
-            status_code=500,
-            content={"error": f"Internal server error: {str(e)}"}
-        )
+        print(f"❌ Chat error: {e}")
+        return JSONResponse(status_code=500, content={"error": str(e)})
 
 if __name__ == "__main__":
     import uvicorn
-    print("🚀 Starting Apollo AI Backend v4.0-TRULY-FIXED")
-    print("🧠 Model: Qwen/Qwen2-0.5B-Instruct (500M parameters)")
-    print("🎯 Mentor Mode: Pure AI questions and guidance")
-    print("⚡ Force Mode: Pure AI direct answers")
-    print("🚫 NO MORE TEMPLATES - Pure AI responses only")
+    print("🚀 Starting Apollo AI Backend v5.0 - FIXED")
     uvicorn.run(app, host="0.0.0.0", port=7860)