remove redundant code

multi_llm_chatbot_backend/app/api/routes_old.py

@@ -1,404 +0,0 @@
-import os
-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
-from app.utils.document_extractor import extract_text_from_file
-from app.core.orchestrator import answer_with_persona_context
-from app.utils.chroma_client import add_persona_doc
-import hashlib
-from app.utils.file_limits import is_within_upload_limit
-
-router = APIRouter()
-
-# Provider management
-current_provider = "gemini"
-available_providers = ["ollama", "gemini"]
-
-def create_llm_client(provider: str = None) -> LLMClient:
-    """Create LLM client based on provider"""
-    if provider is None:
-        provider = current_provider
-        
-    if provider == "gemini":
-        try:
-            return GeminiClient(model_name=os.getenv("GEMINI_MODEL"))
-        except ValueError as e:
-            # Fallback to Ollama if Gemini API key is not available
-            print(f"Gemini API key not found, falling back to Ollama: {e}")
-            return ShortResponseOllamaClient(model_name="llama3.2:1b")
-    elif provider == "ollama":
-        return ShortResponseOllamaClient(model_name="llama3.2:1b")
-    else:
-        raise ValueError(f"Unknown provider: {provider}")
-
-# Initialize with default provider
-llm = create_llm_client()
-chat_orchestrator = ChatOrchestrator()
-seamless_orchestrator = SeamlessOrchestrator(llm=llm)
-
-session_context = GlobalSessionContext()
-
-# Initialize personas
-DEFAULT_PERSONAS = get_default_personas(llm)
-
-for persona in DEFAULT_PERSONAS:
-    chat_orchestrator.register_persona(persona)
-
-# Data models
-class UserInput(BaseModel):
-    user_input: str
-
-class PersonaInput(BaseModel):
-    id: str
-    name: str
-    system_prompt: str
-
-class ChatMessage(BaseModel):
-    user_input: str
-    session_id: Optional[str] = None
-    response_length: Optional[str] = "medium"
-
-class ReplyToAdvisor(BaseModel):
-    user_input: str
-    advisor_id: str
-    original_message_id: Optional[str] = None
-
-class ProviderSwitch(BaseModel):
-    provider: str
-
-# Helper functions for response validation
-def _is_valid_response(response: str, persona_id: str) -> bool:
-    """Validate response quality"""
-    if len(response) < 2 or len(response) > 5000:
-        return False
-    
-    # Check for AI confusion indicators
-    confusion_indicators = [
-        f"Thank you, Dr. {persona_id.title()}",
-        "Assistant:",
-        f"Dr. {persona_id.title()} Advisor:",
-        "excellent discussion, Assistant"
-    ]
-    
-    return not any(indicator in response for indicator in confusion_indicators)
-
-def _get_persona_fallback(persona_id: str) -> str:
-    """Get persona-specific fallback responses"""
-    fallbacks = {
-        "methodologist": "Focus on ensuring your methodology aligns with your research question. What specific method are you considering?",
-        "theorist": "Consider the theoretical framework underlying your approach. What assumptions guide your thinking?",
-        "pragmatist": "Let's break this down into actionable steps. What's the most important thing you need to decide today?"
-    }
-    return fallbacks.get(persona_id, "I'd be happy to help. Could you provide more details?")
-
-# Provider management endpoints
-@router.get("/current-provider")
-async def get_current_provider():
-    return {
-        "current_provider": current_provider,
-        "available_providers": available_providers,
-        "model_info": {
-            "name": llm.model_name if hasattr(llm, 'model_name') else "gemini-2.0-flash",
-            "provider": current_provider
-        }
-    }
-
-@router.post("/switch-provider")
-async def switch_provider(provider_data: ProviderSwitch):
-    global current_provider, llm
-    
-    if provider_data.provider not in available_providers:
-        raise HTTPException(
-            status_code=400, 
-            detail=f"Unknown provider: {provider_data.provider}. Available: {available_providers}"
-        )
-    
-    try:
-        # Update current provider
-        current_provider = provider_data.provider
-        
-        # Create new LLM client
-        new_llm = create_llm_client(current_provider)
-        llm = new_llm
-        
-        # Update all personas with new LLM
-        new_personas = get_default_personas(new_llm)
-        chat_orchestrator.personas.clear()
-        for persona in new_personas:
-            chat_orchestrator.register_persona(persona)
-        
-        # Update seamless orchestrator
-        seamless_orchestrator.llm = new_llm
-        
-        return {
-            "message": f"Successfully switched to {current_provider}",
-            "current_provider": current_provider,
-            "model_info": {
-                "name": new_llm.model_name if hasattr(new_llm, 'model_name') else "gemini-2.0-flash",
-                "provider": current_provider
-            }
-        }
-        
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to switch to {provider_data.provider}: {str(e)}"
-        )
-
-# Sequential advisor responses endpoint
-@router.post("/chat-sequential")
-async def chat_sequential(message: ChatMessage):
-    """Generate advisor responses with improved quality controls"""
-    
-    try:
-        orchestrator_result = await seamless_orchestrator.process_message(message.user_input)
-
-        if orchestrator_result["status"] == "orchestrator_asking":
-            return {
-                "type": "orchestrator_question",
-                "responses": [{
-                    "persona": "PhD Advisor Assistant",
-                    "response": orchestrator_result["orchestrator_question"]
-                }],
-                "collected_info": orchestrator_result["collected_info"]
-            }
-
-        elif orchestrator_result["status"] == "ready_for_advisors":
-            enhanced_context = orchestrator_result["enhanced_context"]
-            
-            # Clear previous advisor responses to avoid confusion
-            session_context.clear()
-            session_context.append("user", message.user_input)
-            session_context.append("orchestrator", enhanced_context)
-
-            advisor_order = chat_orchestrator.get_response_order()
-            print("Advisor Order:")
-            print(advisor_order)
-            responses = []
-            
-            for persona_id in advisor_order:
-                try:
-                    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):
-                        responses.append({
-                            "persona": persona.name,
-                            "persona_id": persona_id,
-                            "response": reply,
-                        })
-                    else:
-                        # Fallback response for invalid responses
-                        responses.append({
-                            "persona": persona.name,
-                            "persona_id": persona_id,
-                            "response": _get_persona_fallback(persona_id),
-                        })
-
-                    session_context.append(persona_id, reply)
-                    
-                except Exception as e:
-                    print(f"Error generating response for {persona_id}: {e}")
-                    responses.append({
-                        "persona": chat_orchestrator.personas[persona_id].name,
-                        "persona_id": persona_id,
-                        "response": _get_persona_fallback(persona_id),
-                    })
-
-            print("Response Block: " )
-            print(responses)
-            return {
-                "type": "sequential_responses",
-                "responses": responses,
-                "collected_info": orchestrator_result["collected_info"]
-            }
-            
-    except Exception as e:
-        print(f"Error in chat_sequential: {e}")
-        return {
-            "type": "error",
-            "responses": [{
-                "persona": "System",
-                "response": "I'm having trouble processing your request. Could you please try again?"
-            }]
-        }
-
-
-# Individual advisor endpoint with context
-@router.post("/chat/{persona_id}")
-async def chat_with_specific_advisor(persona_id: str, input: UserInput):
-    """Chat with a specific advisor"""
-    try:
-        if persona_id not in chat_orchestrator.personas:
-            raise HTTPException(status_code=404, detail=f"Persona '{persona_id}' not found")
-
-        session_context.append("user", input.user_input)
-        persona = chat_orchestrator.personas[persona_id]
-        context = session_context.full_log.copy()
-        reply = await persona.respond(context, response_length="medium")
-        session_context.append(persona_id, reply)
-
-        return {
-            "persona": persona.name,
-            "persona_id": persona_id,
-            "response": reply
-        }
-    except HTTPException:
-        raise
-    except Exception as e:
-        print(f"Error in chat_with_specific_advisor: {e}")
-        return {
-            "persona": "System",
-            "response": "I'm having trouble generating a response right now. Please try again."
-        }
-
-# Reply to specific advisor endpoint
-@router.post("/reply-to-advisor")
-async def reply_to_advisor(reply: ReplyToAdvisor):
-    """Reply to a specific advisor and get response only from that advisor"""
-    
-    try:
-        if reply.advisor_id not in chat_orchestrator.personas:
-            raise HTTPException(status_code=404, detail=f"Advisor '{reply.advisor_id}' not found")
-
-        # Add user reply to context
-        session_context.append("user", reply.user_input)
-
-        # Get response from specific advisor
-        persona = chat_orchestrator.personas[reply.advisor_id]
-        
-        # Generate response
-        reply_response = await persona.respond(session_context.full_log, response_length="medium")
-        session_context.append(reply.advisor_id, reply_response)
-        
-        return {
-            "type": "advisor_reply",
-            "persona": persona.name,
-            "persona_id": reply.advisor_id,
-            "response": reply_response,
-            "original_message_id": reply.original_message_id
-        }
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        print(f"Error in reply_to_advisor: {e}")
-        return {
-            "type": "error",
-            "persona": "System",
-            "response": "I'm having trouble generating a reply right now. Please try again."
-        }
-
-# Reset session
-@router.post("/reset-session")
-async def reset_session():
-    try:
-        seamless_orchestrator.reset()
-        session_context.clear()
-        return {"status": "reset", "message": "Session reset successfully"}
-    except Exception as e:
-        print(f"Error resetting session: {e}")
-        return {"status": "error", "message": "Failed to reset session"}
-
-# Context inspection
-@router.get("/context")
-def get_context():
-    return session_context.full_log
-
-# Legacy model switching endpoint (now redirects to provider switching)
-@router.post("/switch-model")
-async def switch_model(model_name: str = Body(...)):
-    # For backward compatibility, try to map model names to providers
-    if "gemini" in model_name.lower():
-        return await switch_provider(ProviderSwitch(provider="gemini"))
-    else:
-        return await switch_provider(ProviderSwitch(provider="ollama"))
-
-@router.get("/current-model")
-async def get_current_model():
-    # For backward compatibility
-    model_name = llm.model_name if hasattr(llm, 'model_name') else "gemini-2.0-flash"
-    return {
-        "model": model_name,
-        "provider": current_provider
-    }
-
-@router.post("/upload-document")
-async def upload_document(file: UploadFile = File(...)):
-    # Validate file type
-    if file.content_type not in [
-        "application/pdf",
-        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-        "text/plain"
-    ]:
-        raise HTTPException(status_code=400, detail="Unsupported file type.")
-
-    try:
-        # Read file bytes
-        file_bytes = await file.read()
-
-        # Check file size limit
-        if not is_within_upload_limit("default", file_bytes, session_context):
-            raise HTTPException(status_code=400, detail="Upload exceeds session document size limit (10 MB).")
-
-        # Extract and validate text
-        content = extract_text_from_file(file_bytes, file.content_type)
-        if not content.strip():
-            raise HTTPException(status_code=400, detail="Document is empty or unreadable.")
-
-        # Track file size and name
-        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)
-
-        return {"message": "Document uploaded and added to context successfully."}
-
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error processing document: {str(e)}")
-
-# Debug endpoint
-@router.get("/debug/personas")
-async def debug_personas():
-    return {
-        "personas": {
-            pid: {
-                "name": persona.name,
-                "prompt": persona.system_prompt[:100] + "..."
-            } for pid, persona in chat_orchestrator.personas.items()
-        },
-        "context_length": len(session_context.full_log),
-        "current_provider": current_provider
-    }
-
-class PersonaQuery(BaseModel):
-    question: str
-    persona: str
-
-@router.post("/ask/")
-async def ask_question(query: PersonaQuery):
-    response = await answer_with_persona_context(query.question, query.persona)
-    
-    # Store Q&A in vector DB
-    combined_text = f"Q: {query.question}\nA: {response}"
-    doc_id = hashlib.md5(combined_text.encode()).hexdigest()  # Create a unique doc ID
-    
-    add_persona_doc(combined_text, query.persona, doc_id)
-
-    return {"response": response}
-
-@router.get("/uploaded-files")
-def get_uploaded_filenames():
-    return {"files": session_context.uploaded_files}

multi_llm_chatbot_backend/app/core/orchestrator.py

@@ -1,41 +0,0 @@
-from app.models.persona import Persona
-from typing import List
-from app.utils.chroma_client import query_persona_knowledge
-from app.llm.gemini_client import GeminiClient
-from app.llm.llm_client import LLMClient
-
-class ChatOrchestrator:
-    def __init__(self):
-        self.personas: dict[str, Persona] = {}
-        self.active_personas: List[str] = []  # renamed for clarity
-
-    def register_persona(self, persona: Persona):
-        self.personas[persona.id] = persona
-
-    def set_active_personas(self, ids: List[str]):
-        self.active_personas = [pid for pid in ids if pid in self.personas]
-
-    def get_active_personas(self) -> List[str]:
-        return self.active_personas
-
-    def get_response_order(self) ->List[str]:
-
-        # 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 self.personas
-
-        
-    
-async def answer_with_persona_context(question: str, persona: str) -> str:
-    llm: LLMClient = GeminiClient()
-    context_chunks = query_persona_knowledge(question, persona)
-    context = "\n".join(context_chunks) if context_chunks else "No relevant info found."
-        
-    system_prompt = f"You are a helpful assistant responding as a {persona}."
-    message_context = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": f"Context:\n{context}\n\nQuestion:\n{question}"}
-    ]
-
-    return await llm.generate(system_prompt, message_context)

multi_llm_chatbot_backend/app/llm/gemini_client.py

@@ -1,155 +0,0 @@
-import httpx
-import os
-from typing import List
-from app.llm.llm_client import LLMClient
-
-class GeminiClient(LLMClient):
-    def __init__(self, model_name: str = None):
-        if model_name is None:
-            model_name = os.getenv("GEMINI_MODEL", "gemini-2.0-flash-exp")
-        
-        self.model_name = model_name
-        self.api_key = os.getenv("GEMINI_API_KEY")
-        print("DEBUG: GEMINI_API_KEY =", os.getenv("GEMINI_API_KEY"))
-        if not self.api_key:
-            raise ValueError("GEMINI_API_KEY environment variable is required")
-        
-        self.base_url = "https://generativelanguage.googleapis.com/v1beta/models"
-    
-    async def generate(self, system_prompt: str, context: List[dict], temperature: float, max_tokens: int) -> str:
-        # Build focused context - only include recent relevant messages
-        recent_context = context[-3:] if len(context) > 3 else context
-        
-        # Format messages for Gemini API
-        formatted_messages = []
-        
-        # Add system instruction as initial conversation
-        if system_prompt:
-            formatted_messages.append({
-                "role": "user",
-                "parts": [{"text": system_prompt}]
-            })
-            formatted_messages.append({
-                "role": "model", 
-                "parts": [{"text": "I understand. I'll follow these instructions."}]
-            })
-        
-        # Add only the user's current question
-        for msg in recent_context:
-            if msg['role'] == 'user':
-                formatted_messages.append({
-                    "role": "user",
-                    "parts": [{"text": msg['content']}]
-                })
-                break  # Only use most recent user message
-        
-        payload = {
-            "contents": formatted_messages,
-            "generationConfig": {
-                "temperature": temperature,
-                "topK": 40,
-                "topP": 0.9,
-                "maxOutputTokens": max_tokens,  # Reduced from default to ensure concise responses
-                "stopSequences": ["Student:", "Question:", "\n\nStudent:", "\n\nQuestion:"]
-            },
-            "safetySettings": [
-                {
-                    "category": "HARM_CATEGORY_HARASSMENT",
-                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-                },
-                {
-                    "category": "HARM_CATEGORY_HATE_SPEECH", 
-                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-                },
-                {
-                    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-                },
-                {
-                    "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
-                    "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-                }
-            ]
-        }
-
-        try:
-            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.raise_for_status()
-                
-                result = response.json()
-                
-                # Extract text from Gemini response
-                if "candidates" in result and len(result["candidates"]) > 0:
-                    candidate = result["candidates"][0]
-                    if "content" in candidate and "parts" in candidate["content"]:
-                        parts = candidate["content"]["parts"]
-                        if len(parts) > 0 and "text" in parts[0]:
-                            text = parts[0]["text"].strip()
-                            
-                            # Clean up response
-                            text = self._clean_response(text)
-                            
-                            # Validate response quality
-                            if len(text) < 20 or self._is_poor_quality(text):
-                                print("Poor Response Quality from Gemini")
-                                return self._get_fallback_response()
-                            
-                            return text
-                
-                print("Candidate Issue")
-                return self._get_fallback_response()
-                
-        except httpx.HTTPError as e:
-            print(f"HTTP error calling Gemini API: {e}")
-            return "I'm having trouble connecting to generate a response. Please try again."
-        except Exception as e:
-            print(f"Error calling Gemini API: {e}")
-            return "I'm having trouble generating a response right now. Please try again."
-    
-    def _clean_response(self, response: str) -> str:
-        """Clean up Gemini responses"""
-        # Remove common prefixes that indicate AI confusion
-        prefixes_to_remove = [
-            "Dr. Methodologist:", "Dr. Theorist:", "Dr. Pragmatist:",
-            "Methodologist Advisor:", "Theorist Advisor:", "Pragmatist Advisor:",
-            "As Dr.", "Here's my response:", "Response:", "Assistant:",
-            "Here are 2-3 sentence", "Here's an expansion of the advice:",
-        ]
-        
-        for prefix in prefixes_to_remove:
-            if response.startswith(prefix):
-                response = response[len(prefix):].strip()
-        
-        # Remove excessive academic fluff
-        fluff_patterns = [
-            "conceptual insights:", "actionable advice:", "my inquisitive student",
-            "excellent question", "thank you for", "assistant!", "excellent discussion"
-        ]
-        
-        for pattern in fluff_patterns:
-            response = response.replace(pattern, "").strip()
-        
-        # Remove trailing incomplete sentences
-        sentences = response.split('.')
-        if len(sentences) > 1 and len(sentences[-1].strip()) < 10:
-            response = '.'.join(sentences[:-1]) + '.'
-        
-        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()) > 700,  # Too verbose
-            response.count("?") > 3,  # Too many questions
-            "excellent discussion, Assistant" in response,
-        ]
-        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?"

multi_llm_chatbot_backend/app/llm/mistral_client.py

@@ -1,27 +0,0 @@
-import httpx
-from typing import List
-from app.llm.llm_client import LLMClient
-
-OLLAMA_URL = "http://localhost:11434/api/generate"
-
-class MistralClient(LLMClient):
-    async def generate(self, system_prompt: str, context: List[dict], temperature: float, max_tokens: int) -> str:
-        # Flatten context into a string
-        formatted = "\n".join(f"{msg['role'].capitalize()}: {msg['content']}" for msg in context)
-        full_prompt = f"{system_prompt}\n\n{formatted}\n\nAssistant:"
-        
-        payload = {
-            "model": "mistral",
-            "prompt": full_prompt,
-            "temperature": temperature,
-            "num_predict": max_tokens,
-            "stream": False
-        }
-
-        try:
-            async with httpx.AsyncClient(timeout=60.0) as client:
-                response = await client.post(OLLAMA_URL, json=payload)
-                response.raise_for_status()
-                return response.json().get("response", "[No response]")
-        except httpx.HTTPError as e:
-            return f"[Error from Mistral: {str(e)}]"

multi_llm_chatbot_backend/app/llm/ollama_client.py

@@ -1,34 +0,0 @@
-import httpx
-from typing import List
-from app.llm.llm_client import LLMClient
-
-OLLAMA_URL = "http://localhost:11434/api/generate"
-
-class OllamaClient(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], temperature: float, max_tokens: int) -> str:
-        # Flatten context into a string
-        formatted = "\n".join(f"{msg['role'].capitalize()}: {msg['content']}" for msg in context)
-        full_prompt = f"{system_prompt}\n\n{formatted}\n\nAssistant:"
-        
-        payload = {
-            "model": self.model_name,
-            "prompt": full_prompt,
-            "stream": False,
-            "options": {
-                "temperature": temperature,
-                "top_p": 0.9,
-                "top_k": 40,
-                "num_predict": max_tokens,  # Limit response length for faster generation
-            }
-        }
-
-        try:
-            async with httpx.AsyncClient(timeout=30.0) as client:  # Reduced timeout
-                response = await client.post(OLLAMA_URL, json=payload)
-                response.raise_for_status()
-                return response.json().get("response", "[No response]")
-        except httpx.HTTPError as e:
-            return f"[Error from {self.model_name}: {str(e)}]"

multi_llm_chatbot_backend/app/llm/short_ollama_client.py

@@ -1,101 +0,0 @@
-import httpx
-from typing import List
-from app.llm.llm_client import LLMClient
-
-OLLAMA_URL = "http://localhost:11434/api/generate"
-
-# 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], temperature: float, max_tokens: int) -> 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": temperature,
-                "top_p": 0.9,
-                "top_k": 40,
-                "num_predict": max_tokens,  # 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. Methodologist:", "Dr. Theorist:", "Dr. Pragmatist:",
-            "Methodologist 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?"

phd-advisor-frontend/README.md

@@ -1,70 +0,0 @@
-# Getting Started with Create React App
-
-This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
-
-## Available Scripts
-
-In the project directory, you can run:
-
-### `npm start`
-
-Runs the app in the development mode.\
-Open [http://localhost:3000](http://localhost:3000) to view it in your browser.
-
-The page will reload when you make changes.\
-You may also see any lint errors in the console.
-
-### `npm test`
-
-Launches the test runner in the interactive watch mode.\
-See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
-
-### `npm run build`
-
-Builds the app for production to the `build` folder.\
-It correctly bundles React in production mode and optimizes the build for the best performance.
-
-The build is minified and the filenames include the hashes.\
-Your app is ready to be deployed!
-
-See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
-
-### `npm run eject`
-
-**Note: this is a one-way operation. Once you `eject`, you can't go back!**
-
-If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
-
-Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own.
-
-You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it.
-
-## Learn More
-
-You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
-
-To learn React, check out the [React documentation](https://reactjs.org/).
-
-### Code Splitting
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting)
-
-### Analyzing the Bundle Size
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size)
-
-### Making a Progressive Web App
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app)
-
-### Advanced Configuration
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration)
-
-### Deployment
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
-
-### `npm run build` fails to minify
-
-This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)