merge into main

multi_llm_chatbot_backend/app/api/routes.py

@@ -1,5 +1,6 @@
 import os
 from fastapi import APIRouter, Body, HTTPException, Header, UploadFile, File, Request
+from fastapi import Query
 from typing import Optional, List
 import httpx
 from app.llm.llm_client import LLMClient
@@ -13,6 +14,11 @@ from app.models.default_personas import get_default_personas
 from app.utils.document_extractor import extract_text_from_file
 from app.utils.file_limits import is_within_upload_limit
 from pydantic import BaseModel
+
+from fastapi.responses import StreamingResponse
+from fastapi import Query
+from app.utils.file_export import export_chat_as_file
+
 import hashlib
 import logging
 
@@ -423,6 +429,33 @@ async def upload_document(file: UploadFile = File(...), request: Request = None)
         logger.error(f"Error processing document upload: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error processing document: {str(e)}")
 
+
+@router.get("/export-chat")
+async def export_chat(request: Request, format: str = Query(..., regex="^(txt|pdf|docx)$")):
+    """
+    Export the current chat context as a downloadable file in txt, pdf, or docx format.
+    """
+    try:
+        session_id = get_or_create_session_for_request(request)
+        session = session_manager.get_session(session_id)
+
+        if not session.messages:
+            return {"error": "No messages to export in current session."}
+
+        # Generate the file using utility
+        file_stream, filename, media_type = export_chat_as_file(session.messages, format)
+
+        return StreamingResponse(
+            file_stream,
+            media_type=media_type,
+            headers={"Content-Disposition": f"attachment; filename={filename}"}
+        )
+
+    except Exception as e:
+        logger.error(f"Error exporting chat: {str(e)}")
+        return {"error": "Failed to export chat.", "detail": str(e)}
+
+
 # Add new endpoint to get document statistics
 @router.get("/document-stats")
 async def get_document_stats(request: Request):
@@ -596,6 +629,32 @@ async def debug_personas(request: Request):
             "error": str(e)
         }
 
+@router.get("/debug/ranked-personas")
+async def get_ranked_personas(request: Request, k: int = Query(3, ge=1, le=10)):
+    """
+    Debug endpoint: Get top-k ranked personas based on current session context.
+    Uses LLM to rank based on latest conversation messages.
+    """
+    try:
+        session_id = get_or_create_session_for_request(request)
+        
+        # Call the ranking method
+        top_personas = await chat_orchestrator.get_top_personas(session_id=session_id, k=k)
+        
+        # Include some metadata for debug purposes
+        return {
+            "ranked_personas": top_personas,
+            "available_personas": list(chat_orchestrator.personas.keys()),
+            "session_id": session_id
+        }
+    except Exception as e:
+        logger.error(f"Error in /debug/ranked-personas: {e}")
+        return {
+            "ranked_personas": [],
+            "error": str(e)
+        }
+
+
 @router.post("/chat/{persona_id}")
 async def chat_with_specific_persona(persona_id: str, message: ChatMessage, request: Request):
     """

multi_llm_chatbot_backend/app/core/improved_orchestrator.py

@@ -4,6 +4,9 @@ from app.core.session_manager import ConversationContext, get_session_manager
 from app.core.context_manager import get_context_manager
 from app.core.rag_manager import get_rag_manager
 from app.llm.llm_client import LLMClient
+from app.models.default_personas import is_valid_persona_id
+
+import json
 import logging
 import re
 
@@ -594,4 +597,72 @@ When analyzing the document context:
             return {
                 "error": f"Error processing request: {str(e)}",
                 "persona_id": persona_id
-            }
+            }
+        
+
+    async def get_top_personas(self, session_id: str, k: int = 3) -> List[str]:
+        """
+        Use the LLM to rank personas based on current session context.
+        Falls back to default persona order if LLM fails or returns invalid data.
+        """
+        try:
+            session = self.session_manager.get_session(session_id)
+
+            if not self.personas:
+                logger.warning("No personas registered.")
+                return []
+
+            # Use the LLM from one of the existing persona objects
+            llm = next(iter(self.personas.values())).llm
+
+            # Use recent conversation context (last 5 messages)
+            recent_context = "\n".join(
+                msg['content'] for msg in session.get_recent_messages(5)
+            )
+
+            # Format available persona descriptions
+            persona_descriptions = "\n".join([
+                f"- ID: {p.id}\n  Name: {p.name}\n  Prompt: {p.system_prompt.strip()}"
+                for p in self.personas.values()
+            ])
+
+            prompt = f"""
+                        The user is seeking PhD advice. Based on the conversation below, choose the top {k} most relevant advisors.
+
+                        Respond ONLY with a JSON list of exactly {k} advisor IDs in order of relevance.
+                        Example response: ["methodist", "pragmatist", "theorist"]
+
+                        --- Conversation ---
+                        {recent_context}
+
+                        --- Available Advisors ---
+                        {persona_descriptions}
+                      """.strip()
+
+            llm_response = await llm.generate(
+                system_prompt="You are an assistant that selects the best advisors for a PhD student.",
+                context=[{"role": "user", "content": prompt}],
+                temperature=0.4,
+                max_tokens=150
+            )
+
+            # Step 1: Try direct JSON load
+            try:
+                top_ids = json.loads(llm_response.strip())
+            except json.JSONDecodeError:
+                # Step 2: Fallback: try extracting list of quoted strings
+                top_ids = re.findall(r'"(.*?)"', llm_response)
+                logger.warning(f"Fallback JSON extraction used: {top_ids}")
+
+            # Step 3: Filter valid persona IDs
+            valid_ids = [pid for pid in top_ids if pid in self.personas]
+
+            if len(valid_ids) < k:
+                logger.warning(f"LLM returned insufficient or invalid IDs. Got: {valid_ids}")
+                return list(self.personas.keys())[:k]
+
+            return valid_ids[:k]
+
+        except Exception as e:
+            logger.error(f"Error selecting top personas: {e}")
+            return list(self.personas.keys())[:k]

multi_llm_chatbot_backend/app/utils/file_export.py

@@ -0,0 +1,74 @@
+from io import BytesIO
+from typing import List, Tuple
+from docx import Document
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+
+
+def format_messages_for_export(messages: List[dict]) -> str:
+    """
+    Convert chat messages into a structured exportable string.
+    """
+    return "\n\n".join([f"{m['role']}:\n{m['content'].strip()}" for m in messages])
+
+
+def generate_txt_file(text: str) -> BytesIO:
+    buffer = BytesIO()
+    buffer.write(text.encode("utf-8"))
+    buffer.seek(0)
+    return buffer
+
+
+def generate_docx_file(text: str) -> BytesIO:
+    doc = Document()
+    for block in text.split("\n\n"):
+        doc.add_paragraph(block)
+        doc.add_paragraph("")  # spacing
+
+    buffer = BytesIO()
+    doc.save(buffer)
+    buffer.seek(0)
+    return buffer
+
+
+def generate_pdf_file(text: str) -> BytesIO:
+    buffer = BytesIO()
+    c = canvas.Canvas(buffer, pagesize=letter)
+
+    width, height = letter
+    y = height - 40
+    line_height = 14
+
+    for line in text.splitlines():
+        if y < 40:
+            c.showPage()
+            y = height - 40
+        c.drawString(40, y, line)
+        y -= line_height
+
+    c.save()
+    buffer.seek(0)
+    return buffer
+
+
+def export_chat_as_file(messages: List[dict], format: str) -> Tuple[BytesIO, str, str]:
+    """
+    Export chat messages to the requested file format.
+    Returns: (file_stream, filename, media_type)
+    """
+    text = format_messages_for_export(messages)
+
+    if format == "txt":
+        stream = generate_txt_file(text)
+        return stream, "chat_export.txt", "text/plain"
+
+    elif format == "docx":
+        stream = generate_docx_file(text)
+        return stream, "chat_export.docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+
+    elif format == "pdf":
+        stream = generate_pdf_file(text)
+        return stream, "chat_export.pdf", "application/pdf"
+
+    else:
+        raise ValueError(f"Unsupported export format: {format}")

multi_llm_chatbot_backend/requirements.txt

@@ -7,4 +7,6 @@ python-dotenv
 chromadb
 sentence-transformers
 nltk
-tiktoken
+tiktoken
+reportlab
+docx