routes file cleanup and related changes in orchestrators

multi_llm_chatbot_backend/app/api/routes.py

@@ -3,10 +3,12 @@ from fastapi import APIRouter, Body, HTTPException
 import httpx
 from app.llm.llm_client import LLMClient
 from app.llm.gemini_client import GeminiClient
+from app.llm.short_ollama_client import ShortResponseOllamaClient
 from app.models.persona import Persona
 from app.core.orchestrator import ChatOrchestrator
 from app.core.seamless_orchestrator import SeamlessOrchestrator
 from app.core.context import GlobalSessionContext
+from app.models.default_personas import get_default_personas
 from pydantic import BaseModel
 from typing import Optional, List
 from fastapi import UploadFile, File
@@ -36,102 +38,6 @@ def create_llm_client(provider: str = None) -> LLMClient:
     else:
         raise ValueError(f"Unknown provider: {provider}")
 
-# Improved LLM client with better short response handling for Ollama
-class ShortResponseOllamaClient(LLMClient):
-    def __init__(self, model_name: str = "llama3.2:1b"):
-        self.model_name = model_name
-    
-    async def generate(self, system_prompt: str, context: List[dict]) -> str:
-        # Build cleaner context - only include recent relevant messages
-        recent_context = context[-3:] if len(context) > 3 else context
-        
-        # Create a focused prompt
-        prompt_parts = [system_prompt]
-        
-        # Add only the user's current question
-        for msg in recent_context:
-            if msg['role'] == 'user':
-                prompt_parts.append(f"Student Question: {msg['content']}")
-                break  # Only use the most recent user message
-        
-        prompt_parts.append("Your Response:")
-        prompt = "\n\n".join(prompt_parts)
-        
-        payload = {
-            "model": self.model_name,
-            "prompt": prompt,
-            "stream": False,
-            "options": {
-                "temperature": 0.7,
-                "top_p": 0.9,
-                "top_k": 40,
-                "num_predict": 80,  # Reduced from 200 to force shorter responses
-                "repeat_penalty": 1.1,
-                "stop": ["\n\n", "Student:", "Question:", "Response:"]  # Stop tokens
-            }
-        }
-
-        try:
-            async with httpx.AsyncClient(timeout=25.0) as client:
-                response = await client.post("http://localhost:11434/api/generate", json=payload)
-                response.raise_for_status()
-                result = response.json().get("response", "[No response]").strip()
-                
-                # Enhanced cleanup
-                result = self._clean_response(result)
-                
-                # Validate response quality
-                if len(result) < 20 or self._is_poor_quality(result):
-                    return self._get_fallback_response()
-                
-                return result
-                
-        except Exception as e:
-            return "I'm having trouble generating a response right now. Please try again."
-    
-    def _clean_response(self, response: str) -> str:
-        """Clean up common response issues"""
-        # Remove common prefixes
-        prefixes_to_remove = [
-            "Here are 2-3 sentence", "Here's an expansion", "Assistant:",
-            "Dr. Methodist:", "Dr. Theorist:", "Dr. Pragmatist:",
-            "Methodist Advisor:", "Theorist Advisor:", "Pragmatist Advisor:",
-        ]
-        
-        for prefix in prefixes_to_remove:
-            if response.startswith(prefix):
-                response = response[len(prefix):].strip()
-        
-        # Remove trailing incomplete sentences
-        sentences = response.split('.')
-        if len(sentences) > 1 and len(sentences[-1].strip()) < 10:
-            response = '.'.join(sentences[:-1]) + '.'
-        
-        # Remove excessive academic fluff
-        fluff_patterns = [
-            "conceptual insights:", "actionable advice:", "my inquisitive student",
-            "excellent question", "thank you for", "assistant!"
-        ]
-        
-        for pattern in fluff_patterns:
-            response = response.replace(pattern, "").strip()
-        
-        return response
-    
-    def _is_poor_quality(self, response: str) -> bool:
-        """Check if response quality is poor"""
-        poor_indicators = [
-            "Thank you, Dr." in response,  # AI confusion about identity
-            "Assistant:" in response,
-            len(response.split()) > 100,  # Too verbose
-            response.count("?") > 3,  # Too many questions
-        ]
-        return any(poor_indicators)
-    
-    def _get_fallback_response(self) -> str:
-        """Return a simple fallback when quality is poor"""
-        return "I'd be happy to help with that. Could you provide more specific details about what you're looking for?"
-
 # Initialize with default provider
 llm = create_llm_client()
 chat_orchestrator = ChatOrchestrator()
@@ -139,63 +45,9 @@ seamless_orchestrator = SeamlessOrchestrator(llm=llm)
 
 session_context = GlobalSessionContext()
 
-def create_default_personas(llm_client: LLMClient):
-    """Create default personas with improved, concise system prompts"""
-    return [
-        Persona(
-            id="methodist",
-            name="Dr. Methodist",
-            system_prompt="""You are Dr. Methodist, a research methodology expert.
-
-RESPONSE RULES:
-- Maximum 3 sentences
-- Start with your recommendation 
-- Include ONE specific actionable step
-- Use terms like "validity," "operationalize," "sampling frame"
-- Focus on methodological rigor
-
-TONE: Precise, helpful, focused on research design quality.
-
-Example: "Use a cautious tone unless your methodology is exceptionally robust. Strong validity and clear operationalization justify more confident language. Next step: Review your methods section to assess how assertive you can be.""",
-            llm=llm_client
-        ),
-        Persona(
-            id="theorist",
-            name="Dr. Theorist", 
-            system_prompt="""You are Dr. Theorist, a conceptual frameworks expert.
-            RESPONSE RULES:
-            - Maximum 3 sentences
-            - Start with conceptual perspective
-            - Reference theoretical positioning
-            - Ask ONE probing question when relevant
-            - Use terms like "epistemological," "framework," "assumptions"
-
-            TONE: Thoughtful, intellectually rigorous, conceptually focused.
-
-            Example: "Your tone should reflect your epistemological stance—bold if challenging frameworks, cautious if extending theory. Consider your relationship to existing literature. What theoretical assumptions underlie your approach?""",
-            llm=llm_client
-        ),
-        Persona(
-            id="pragmatist",
-            name="Dr. Pragmatist",
-            system_prompt="""You are Dr. Pragmatist, a practical action-focused advisor.
-
-RESPONSE RULES:
-- Maximum 2 sentences
-- Start with clear, actionable advice
-- Focus on immediate next steps
-- Use phrases like "Quick fix:" "Next step:" "Try this:"
-- Prioritize progress over perfection
-
-TONE: Warm, motivational, results-oriented.
-
-Example: "Start cautious and earn the right to be bold as you build your case. Quick fix: Use 'This study suggests...' rather than 'This study proves...'""",
-            llm=llm_client
-        )
-    ]
-
 # Initialize personas
-DEFAULT_PERSONAS = create_default_personas(llm)
+DEFAULT_PERSONAS = get_default_personas(llm)
+
 for persona in DEFAULT_PERSONAS:
     chat_orchestrator.register_persona(persona)
 
@@ -211,6 +63,7 @@ class PersonaInput(BaseModel):
 class ChatMessage(BaseModel):
     user_input: str
     session_id: Optional[str] = None
+    response_length: Optional[str] = "medium"
 
 class ReplyToAdvisor(BaseModel):
     user_input: str
@@ -223,7 +76,7 @@ class ProviderSwitch(BaseModel):
 # Helper functions for response validation
 def _is_valid_response(response: str, persona_id: str) -> bool:
     """Validate response quality"""
-    if len(response) < 20 or len(response) > 500:
+    if len(response) < 2 or len(response) > 5000:
         return False
     
     # Check for AI confusion indicators
@@ -276,7 +129,7 @@ async def switch_provider(provider_data: ProviderSwitch):
         llm = new_llm
         
         # Update all personas with new LLM
-        new_personas = create_default_personas(new_llm)
+        new_personas = get_default_personas(new_llm)
         chat_orchestrator.personas.clear()
         for persona in new_personas:
             chat_orchestrator.register_persona(persona)
@@ -322,19 +175,20 @@ async def chat_sequential(message: ChatMessage):
             
             # Clear previous advisor responses to avoid confusion
             session_context.clear()
-            session_context.append("user", enhanced_context)
+            session_context.append("user", message.user_input)
+            session_context.append("orchestrator", enhanced_context)
 
-            advisor_order = ["methodist", "theorist", "pragmatist"]
+            advisor_order = chat_orchestrator.get_response_order()
+            print("Advisor Order:")
+            print(advisor_order)
             responses = []
             
-            for i, persona_id in enumerate(advisor_order):
+            for persona_id in advisor_order:
                 try:
-                    persona = chat_orchestrator.personas[persona_id]
-                    
-                    # Use clean context for each advisor (no cross-contamination)
-                    clean_context = [{"role": "user", "content": enhanced_context}]
-                    
-                    reply = await persona.respond(clean_context)
+                    persona = chat_orchestrator.personas[persona_id]                    
+                    reply = await persona.respond(session_context.full_log, response_length="medium")
+                    print("Replies:")
+                    print(reply)
                     
                     # Validate response before adding
                     if _is_valid_response(reply, persona_id):
@@ -342,7 +196,6 @@ async def chat_sequential(message: ChatMessage):
                             "persona": persona.name,
                             "persona_id": persona_id,
                             "response": reply,
-                            "order": i
                         })
                     else:
                         # Fallback response for invalid responses
@@ -350,8 +203,9 @@ async def chat_sequential(message: ChatMessage):
                             "persona": persona.name,
                             "persona_id": persona_id,
                             "response": _get_persona_fallback(persona_id),
-                            "order": i
                         })
+
+                    session_context.append(persona_id, reply)
                     
                 except Exception as e:
                     print(f"Error generating response for {persona_id}: {e}")
@@ -359,9 +213,10 @@ async def chat_sequential(message: ChatMessage):
                         "persona": chat_orchestrator.personas[persona_id].name,
                         "persona_id": persona_id,
                         "response": _get_persona_fallback(persona_id),
-                        "order": i
                     })
 
+            print("Response Block: " )
+            print(responses)
             return {
                 "type": "sequential_responses",
                 "responses": responses,
@@ -378,11 +233,6 @@ async def chat_sequential(message: ChatMessage):
             }]
         }
 
-# Main chat endpoint (keep for compatibility)
-@router.post("/chat")
-async def chat_with_orchestrator(message: ChatMessage):
-    """Redirect to sequential endpoint for better UX"""
-    return await chat_sequential(message)
 
 # Individual advisor endpoint with context
 @router.post("/chat/{persona_id}")
@@ -395,7 +245,7 @@ async def chat_with_specific_advisor(persona_id: str, input: UserInput):
         session_context.append("user", input.user_input)
         persona = chat_orchestrator.personas[persona_id]
         context = session_context.full_log.copy()
-        reply = await persona.respond(context)
+        reply = await persona.respond(context, response_length="medium")
         session_context.append(persona_id, reply)
 
         return {
@@ -426,10 +276,9 @@ async def reply_to_advisor(reply: ReplyToAdvisor):
 
         # Get response from specific advisor
         persona = chat_orchestrator.personas[reply.advisor_id]
-        context = session_context.full_log.copy()
         
         # Generate response
-        reply_response = await persona.respond(context)
+        reply_response = await persona.respond(session_context.full_log, response_length="medium")
         session_context.append(reply.advisor_id, reply_response)
         
         return {
@@ -508,7 +357,7 @@ async def upload_document(file: UploadFile = File(...)):
             raise HTTPException(status_code=400, detail="Document is empty or unreadable.")
 
         # Track file size and name
-        session_context.append("user", f"[Uploaded Document Content]\n{content.strip()}")
+        session_context.append("Document", f"[Uploaded Document Content]\n{content.strip()}")
         session_context.uploaded_files.append(file.filename)
         session_context.total_upload_size += len(file_bytes)
 

multi_llm_chatbot_backend/app/core/orchestrator.py

@@ -15,13 +15,9 @@ class ChatOrchestrator:
     def get_active_personas(self) -> List[str]:
         return self.active_personas
 
-    async def process_user_input(self, user_input: str, context: List[dict]):
-        responses = []
+    def get_response_order(self) ->List[str]:
 
-        for pid in self.active_personas:
-            persona = self.personas[pid]
-            reply = await persona.respond(context)
-            responses.append({"persona": persona.name, "response": reply})
-            context.append({"role": persona.id, "content": reply})
+        # I have created this function to be a placeholder for the actual logic of response sequencing
+        # This logic can be replaced with something smarter like a LLM deciding order based on chat context
 
-        return responses
+        return self.personas

multi_llm_chatbot_backend/app/core/seamless_orchestrator.py

@@ -129,7 +129,7 @@ class SeamlessOrchestrator:
         Ask briefly and naturally."""
         
         try:
-            question = await self.llm.generate(system_prompt, [{"role": "user", "content": context}])
+            question = await self.llm.generate(system_prompt, [{"role": "user", "content": context}], temperature=0.5, max_tokens=50)
             return question.strip()
         except Exception as e:
             print(f"Error generating orchestrator question: {e}")

multi_llm_chatbot_backend/app/utils/document_extractor.py

@@ -2,6 +2,7 @@ from io import BytesIO
 import PyPDF2
 import tempfile
 import docx2txt
+import os
 
 def extract_text_from_file(file_bytes: bytes, content_type: str) -> str:
     if content_type == "application/pdf":
@@ -12,7 +13,10 @@ def extract_text_from_file(file_bytes: bytes, content_type: str) -> str:
         with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp:
             tmp.write(file_bytes)
             tmp_path = tmp.name
-        return docx2txt.process(tmp_path)
+        try:
+            return docx2txt.process(tmp_path)
+        finally:
+            os.unlink(tmp_path)  # Clean up temp file
 
     elif content_type == "text/plain":
         return file_bytes.decode("utf-8")