updated gemini context management

multi_llm_chatbot_backend/app/core/context_manager.py

@@ -141,24 +141,46 @@ class ContextManager:
     def _format_for_gemini(self, messages: List[dict], system_prompt: str) -> List[dict]:
         """
         Format messages for Gemini API (uses user/model roles with parts structure)
+        FIXED VERSION - Better handles system messages and document context
         """
         formatted = []
         
-        # Add system prompt as initial exchange
+        # Process all messages, handling system messages properly
+        system_message_content = ""
+        conversation_messages = []
+        
+        # Add initial system prompt if provided
         if system_prompt:
+            system_message_content = system_prompt
+        
+        for message in messages:
+            role = message['role']
+            content = message['content']
+            
+            if role == 'system':
+                # Accumulate system messages
+                if system_message_content:
+                    system_message_content += "\n\n" + content
+                else:
+                    system_message_content = content
+            else:
+                conversation_messages.append(message)
+        
+        # Add accumulated system content as initial exchange
+        if system_message_content:
             formatted.extend([
                 {
                     "role": "user",
-                    "parts": [{"text": system_prompt}]
+                    "parts": [{"text": system_message_content}]
                 },
                 {
                     "role": "model",
-                    "parts": [{"text": "I understand. I'll follow these instructions."}]
+                    "parts": [{"text": "I understand. I'll follow these instructions and use the document context you've provided."}]
                 }
             ])
         
-        # Convert messages to Gemini format
-        for message in messages:
+        # Convert conversation messages to Gemini format
+        for message in conversation_messages:
             role = message['role']
             content = message['content']
             
@@ -178,7 +200,7 @@ class ContextManager:
                     "role": "user",
                     "parts": [{"text": f"[Context Document] {content}"}]
                 })
-        
+
         return formatted
     
     def _format_for_ollama(self, messages: List[dict], system_prompt: str) -> str:

multi_llm_chatbot_backend/app/core/improved_orchestrator.py

@@ -446,10 +446,10 @@ When analyzing the document context:
     async def _build_enhanced_context_for_persona(self, session, persona, user_message: str, document_context: str) -> List[Dict[str, str]]:
         """
         Build enhanced context that properly integrates document information with conversation history
-        FIXED VERSION - No document hallucination when no documents exist
+        FIXED VERSION - Ensures document context is properly preserved for both providers
         """
         enhanced_context = []
-    
+
         # Get recent conversation history (last 6 messages for efficiency)
         recent_messages = session.messages[-6:] if len(session.messages) > 6 else session.messages
         
@@ -467,6 +467,7 @@ When analyzing the document context:
     CURRENT SESSION CONTEXT:
     The student has uploaded the following documents: {doc_list}
 
+    DOCUMENT CONTENT:
     {document_context}
 
     IMPORTANT: When the student refers to "my document," "my dissertation," "my proposal," etc., they are referring to one of their uploaded documents. Use the document context above to understand which specific document they mean and reference it by name in your response.
@@ -495,21 +496,15 @@ When analyzing the document context:
                 "role": "system", 
                 "content": system_message
             })
-        
-        # Add recent conversation history
+
+        # Add recent conversation messages (excluding system messages to avoid duplication)
         for message in recent_messages:
-            if message.get('role') in ['user', 'assistant']:
+            if message.get('role') != 'system':
                 enhanced_context.append({
                     "role": message['role'],
                     "content": message['content']
                 })
-        
-        # Add current user message
-        enhanced_context.append({
-            "role": "user",
-            "content": user_message
-        })
-        
+
         return enhanced_context
     
     def _is_valid_response(self, response: str, persona_id: str) -> bool:

multi_llm_chatbot_backend/app/llm/improved_gemini_client.py

@@ -23,6 +23,7 @@ class ImprovedGeminiClient(LLMClient):
     async def generate(self, system_prompt: str, context: List[dict], temperature: float, max_tokens: int) -> str:
         """
         Generate response using improved context management
+        FIXED VERSION - Better debugging and context handling
         """
         try:
             # Use context manager to prepare optimal context window
@@ -35,6 +36,9 @@ class ImprovedGeminiClient(LLMClient):
             logger.debug(f"Context prepared: {len(context_window.messages)} messages, "
                         f"~{context_window.total_tokens} tokens, truncated={context_window.truncated}")
             
+            # DEBUG: Log the actual content being sent to Gemini
+            logger.debug(f"Gemini payload preview: {str(context_window.messages)[:500]}...")
+            
             payload = {
                 "contents": context_window.messages,
                 "generationConfig": {
@@ -50,7 +54,7 @@ class ImprovedGeminiClient(LLMClient):
                         "threshold": "BLOCK_MEDIUM_AND_ABOVE"
                     },
                     {
-                        "category": "HARM_CATEGORY_HATE_SPEECH",
+                        "category": "HARM_CATEGORY_HATE_SPEECH", 
                         "threshold": "BLOCK_MEDIUM_AND_ABOVE"
                     },
                     {
@@ -64,33 +68,41 @@ class ImprovedGeminiClient(LLMClient):
                 ]
             }
             
-            url = f"{self.base_url}/{self.model_name}:generateContent?key={self.api_key}"
-            
             async with httpx.AsyncClient(timeout=30.0) as client:
-                response = await client.post(url, json=payload)
+                response = await client.post(
+                    f"{self.base_url}/{self.model_name}:generateContent",
+                    json=payload,
+                    headers={"x-goog-api-key": self.api_key}
+                )
                 response.raise_for_status()
                 
                 result = response.json()
                 
-                if "candidates" in result and result["candidates"]:
-                    candidate = result["candidates"][0]
-                    if "content" in candidate and "parts" in candidate["content"]:
-                        text = candidate["content"]["parts"][0].get("text", "")
-                        return self._clean_response(text)
+                # Better error handling
+                if "candidates" not in result or not result["candidates"]:
+                    logger.error(f"No candidates in Gemini response: {result}")
+                    return "I apologize, but I'm unable to generate a response right now. Please try again."
                 
-                # Handle safety filter or other issues
-                if "promptFeedback" in result:
-                    feedback = result["promptFeedback"]
-                    logger.warning(f"Gemini prompt feedback: {feedback}")
+                candidate = result["candidates"][0]
                 
-                return "I apologize, but I'm unable to provide a response to that query."
+                if "content" not in candidate or "parts" not in candidate["content"]:
+                    logger.error(f"Invalid candidate structure: {candidate}")
+                    return "I apologize, but I received an unexpected response format. Please try again."
+                
+                text = candidate["content"]["parts"][0].get("text", "").strip()
+                
+                if not text:
+                    logger.warning("Empty response from Gemini")
+                    return "I apologize, but I couldn't generate a meaningful response. Please try rephrasing your question."
+                
+                return self._clean_response(text)
                 
-        except httpx.TimeoutException:
-            logger.error("Gemini API timeout")
-            return "I'm experiencing a delay in processing. Please try again."
         except httpx.HTTPStatusError as e:
             logger.error(f"Gemini API HTTP error: {e.response.status_code} - {e.response.text}")
-            return "I'm having trouble accessing the AI service. Please try again."
+            return "I'm experiencing issues connecting to the AI service. Please try again."
+        except httpx.TimeoutException:
+            logger.error("Gemini API timeout")
+            return "The AI service is taking too long to respond. Please try again."
         except Exception as e:
             logger.error(f"Unexpected error in Gemini client: {str(e)}")
             return "I encountered an unexpected error. Please try again."