manavgup
diff --git a/‎backend/core/config.py‎
Lines changed: 5 additions & 1 deletion b/‎backend/core/config.py‎
Lines changed: 5 additions & 1 deletion
diff --git a/‎backend/rag_solution/generation/providers/watsonx.py‎
Lines changed: 10 additions & 3 deletions b/‎backend/rag_solution/generation/providers/watsonx.py‎
Lines changed: 10 additions & 3 deletions
diff --git a/‎backend/rag_solution/retrieval/reranker.py‎
Lines changed: 139 additions & 5 deletions b/‎backend/rag_solution/retrieval/reranker.py‎
Lines changed: 139 additions & 5 deletions
diff --git a/‎backend/rag_solution/schemas/conversation_schema.py‎
Lines changed: 11 additions & 11 deletions b/‎backend/rag_solution/schemas/conversation_schema.py‎
Lines changed: 11 additions & 11 deletions
diff --git a/‎backend/rag_solution/services/conversation_service.py‎
Lines changed: 5 additions & 5 deletions b/‎backend/rag_solution/services/conversation_service.py‎
Lines changed: 5 additions & 5 deletions
diff --git a/‎backend/rag_solution/services/pipeline_service.py‎
Lines changed: 15 additions & 3 deletions b/‎backend/rag_solution/services/pipeline_service.py‎
Lines changed: 15 additions & 3 deletions
diff --git a/‎backend/rag_solution/services/user_provider_service.py‎
Lines changed: 3 additions & 0 deletions b/‎backend/rag_solution/services/user_provider_service.py‎
Lines changed: 3 additions & 0 deletions
@@ -153,7 +153,7 @@ class Settings(BaseSettings):
 
     # Reranking settings
     enable_reranking: Annotated[bool, Field(default=True, alias="ENABLE_RERANKING")]
-    reranker_type: Annotated[str, Field(default="llm", alias="RERANKER_TYPE")]  # Options: llm, simple
+    reranker_type: Annotated[str, Field(default="llm", alias="RERANKER_TYPE")]  # Options: llm, simple, cross-encoder
     reranker_top_k: Annotated[
         int | None, Field(default=5, alias="RERANKER_TOP_K")
     ]  # Default 5 for optimal quality/speed
@@ -162,6 +162,10 @@ class Settings(BaseSettings):
     reranker_prompt_template_name: Annotated[
         str, Field(default="reranking", alias="RERANKER_PROMPT_TEMPLATE_NAME")
     ]  # Template name for reranking prompts
+    # Cross-encoder reranker settings (production-grade, ~100ms vs 20-30s for LLM)
+    cross_encoder_model: Annotated[
+        str, Field(default="cross-encoder/ms-marco-MiniLM-L-6-v2", alias="CROSS_ENCODER_MODEL")
+    ]  # Fast cross-encoder for reranking
 
     # Podcast Generation settings
     # Environment: "development" uses FastAPI BackgroundTasks + local filesystem
 
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 import time
 from collections.abc import Generator, Sequence
 from typing import Any
@@ -182,13 +183,14 @@ def _get_generation_params(
         if params is None:
             raise ValueError("No LLM parameters found for user")
 
-        # Convert to WatsonX format
+        # Convert to WatsonX format with stop sequences
         return {
             GenParams.DECODING_METHOD: "sample",
             GenParams.MAX_NEW_TOKENS: params.max_new_tokens,
             GenParams.TEMPERATURE: params.temperature,
             GenParams.TOP_K: params.top_k,
             GenParams.TOP_P: params.top_p,
+            GenParams.STOP_SEQUENCES: ["##", "\n\nQuestion:", "\n\n##"],  # Stop at markdown headers or new questions
         }
 
     def generate_text(
@@ -379,8 +381,13 @@ def get_embeddings(self, texts: str | Sequence[str]) -> EmbeddingsList:
             if isinstance(texts, str):
                 texts = [texts]
 
-            logger.debug("Generating embeddings for %d texts", len(texts))
-            logger.debug("Embeddings client: %s", self.embeddings_client)
+            # Debug logging for embeddings generation (limited to first 5 for performance)
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug("Generating embeddings for %d texts", len(texts))
+                for idx, text in enumerate(texts[:5], 1):
+                    logger.debug("Text %d (length: %d chars): %s", idx, len(text), text[:100])
+                if len(texts) > 5:
+                    logger.debug("... and %d more texts", len(texts) - 5)
 
             # Add a configurable delay to prevent rate limiting
             settings = get_settings()
 
@@ -275,11 +275,17 @@ async def _score_batch_async(self, query: str, batch: list[QueryResult]) -> list
         formatted_prompts = self._create_reranking_prompts(query, batch)
 
         try:
-            # Call LLM provider asynchronously
-            responses = await self.llm_provider.generate_text(
-                user_id=self.user_id,
-                prompt=formatted_prompts,
-                template=None,
+            # Call LLM provider (synchronous - run in executor to avoid blocking)
+            import asyncio
+
+            loop = asyncio.get_event_loop()
+            responses = await loop.run_in_executor(
+                None,
+                lambda: self.llm_provider.generate_text(
+                    user_id=self.user_id,
+                    prompt=formatted_prompts,
+                    template=None,
+                ),
             )
 
             # Extract scores from responses
@@ -461,3 +467,131 @@ async def rerank_async(
         Async version of rerank - SimpleReranker doesn't need concurrency, just wraps sync method.
         """
         return self.rerank(query, results, top_k)
+
+
+class CrossEncoderReranker(BaseReranker):
+    """Fast cross-encoder reranker using sentence-transformers.
+
+    Production-grade reranker that uses a cross-encoder model to score
+    query-document pairs. Much faster than LLM-based reranking (~100ms vs 20-30s).
+
+    Models:
+        - cross-encoder/ms-marco-MiniLM-L-12-v2: Best accuracy (12 layers)
+        - cross-encoder/ms-marco-MiniLM-L-6-v2: Faster, good accuracy (6 layers)
+        - cross-encoder/ms-marco-TinyBERT-L-2-v2: Fastest, decent accuracy (2 layers)
+    """
+
+    def __init__(self, model_name: str = "cross-encoder/ms-marco-MiniLM-L-6-v2"):
+        """
+        Initialize cross-encoder reranker.
+
+        Args:
+            model_name: HuggingFace model name for cross-encoder
+        """
+        from sentence_transformers import CrossEncoder
+
+        self.model_name = model_name
+        logger.info("Loading cross-encoder model: %s", model_name)
+        start_time = time.time()
+        self.model = CrossEncoder(model_name)
+        load_time = time.time() - start_time
+        logger.info("Cross-encoder loaded in %.2fs", load_time)
+
+    def rerank(
+        self,
+        query: str,
+        results: list[QueryResult],
+        top_k: int | None = None,
+    ) -> list[QueryResult]:
+        """
+        Rerank results using cross-encoder model.
+
+        Cross-encoders score query-document pairs directly, providing more accurate
+        relevance scoring than bi-encoder cosine similarity. This is the industry
+        standard for production reranking (used by OpenAI, Anthropic, Cohere, etc.).
+
+        Args:
+            query: The search query
+            results: List of QueryResult objects to rerank
+            top_k: Optional number of top results to return (defaults to len(results))
+
+        Returns:
+            Reranked list of QueryResult objects with updated scores
+
+        Raises:
+            ValueError: If model prediction fails
+        """
+        if not results:
+            logger.debug("No results to rerank")
+            return []
+
+        if top_k is None:
+            top_k = len(results)
+
+        logger.debug(
+            "Reranking %d results with cross-encoder (top_k=%d, model=%s)",
+            len(results),
+            top_k,
+            self.model_name,
+        )
+
+        # Create query-document pairs for cross-encoder
+        start_time = time.time()
+        pairs = [[query, result.chunk.text if result.chunk and result.chunk.text else ""] for result in results]
+
+        # Score all pairs with cross-encoder (fast: ~100ms for 20 docs)
+        try:
+            scores = self.model.predict(pairs)
+        except Exception as e:
+            logger.error("Cross-encoder prediction failed: %s", e)
+            raise ValueError(f"Reranking failed for model {self.model_name}: {e}") from e
+
+        rerank_time = time.time() - start_time
+
+        # Combine results with scores (strict=True for safety)
+        scored_results = list(zip(results, scores, strict=True))
+
+        # Sort by cross-encoder scores (descending)
+        sorted_results = sorted(scored_results, key=lambda x: x[1], reverse=True)
+
+        # Update QueryResult scores with cross-encoder scores
+        # Note: QueryResult schema only has chunk, score, embeddings
+        # Collection info is preserved in the chunk object
+        reranked_results = []
+        for result, ce_score in sorted_results:
+            new_result = QueryResult(
+                chunk=result.chunk,
+                score=float(ce_score),  # Convert numpy float to Python float
+                embeddings=result.embeddings,
+            )
+            reranked_results.append(new_result)
+
+        # Return top_k results
+        final_results = reranked_results[:top_k]
+
+        logger.info(
+            "Reranked %d results → %d results in %.3fs (model=%s)",
+            len(results),
+            len(final_results),
+            rerank_time,
+            self.model_name,
+        )
+
+        return final_results
+
+    async def rerank_async(
+        self,
+        query: str,
+        results: list[QueryResult],
+        top_k: int | None = None,
+    ) -> list[QueryResult]:
+        """
+        Async version of rerank.
+
+        Cross-encoder inference is CPU-bound and relatively fast (~100ms),
+        so we run it in an executor to avoid blocking the event loop.
+        """
+        import asyncio
+
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, self.rerank, query, results, top_k)
@@ -4,7 +4,7 @@
 context management, and question suggestions.
 """
 
-from datetime import datetime
+from datetime import UTC, datetime
 from enum import Enum
 from typing import Any
 from uuid import uuid4
@@ -132,9 +132,9 @@ def to_output(  # pylint: disable=too-many-arguments,too-many-positional-argumen
     ) -> "ConversationSessionOutput":
         """Convert input to output schema using Pydantic 2+ model validation."""
         if created_at is None:
-            created_at = datetime.utcnow()
+            created_at = datetime.now(UTC)
         if updated_at is None:
-            updated_at = datetime.utcnow()
+            updated_at = datetime.now(UTC)
 
         # Use model_dump() to get all input data, then update with additional fields
         data = self.model_dump()
@@ -163,8 +163,8 @@ class ConversationSessionOutput(BaseModel):
     max_messages: int = Field(..., description="Maximum number of messages")
     is_archived: bool = Field(default=False, description="Whether the session is archived")
     is_pinned: bool = Field(default=False, description="Whether the session is pinned")
-    created_at: datetime = Field(default_factory=datetime.utcnow, description="Creation timestamp")
-    updated_at: datetime = Field(default_factory=datetime.utcnow, description="Last update timestamp")
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC), description="Creation timestamp")
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(UTC), description="Last update timestamp")
     metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
     message_count: int = Field(default=0, description="Number of messages in the session")
 
@@ -234,7 +234,7 @@ class ConversationMessageInput(BaseModel):
     """Input schema for conversation messages."""
 
     session_id: UUID4 = Field(..., description="ID of the session")
-    content: str = Field(..., min_length=1, max_length=10000, description="Message content")
+    content: str = Field(..., min_length=1, max_length=100000, description="Message content")
     role: MessageRole = Field(..., description="Role of the message sender")
     message_type: MessageType = Field(..., description="Type of message")
     metadata: MessageMetadata | dict[str, Any] | None = Field(default=None, description="Message metadata")
@@ -246,7 +246,7 @@ class ConversationMessageInput(BaseModel):
     def to_output(self, message_id: UUID4, created_at: datetime | None = None) -> "ConversationMessageOutput":
         """Convert input to output schema using Pydantic 2+ model validation."""
         if created_at is None:
-            created_at = datetime.utcnow()
+            created_at = datetime.now(UTC)
 
         # Use model_dump() to get all input data, then update with additional fields
         data = self.model_dump()
@@ -263,7 +263,7 @@ class ConversationMessageOutput(BaseModel):
     content: str = Field(..., description="Message content")
     role: MessageRole = Field(..., description="Role of the message sender")
     message_type: MessageType = Field(..., description="Type of message")
-    created_at: datetime = Field(default_factory=datetime.utcnow, description="Creation timestamp")
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC), description="Creation timestamp")
     metadata: MessageMetadata | None = Field(default=None, description="Message metadata")
     token_count: int | None = Field(default=None, description="Token count for this message")
     execution_time: float | None = Field(default=None, description="Execution time in seconds")
@@ -406,7 +406,7 @@ class ExportOutput(BaseModel):
     session_data: ConversationSessionOutput = Field(..., description="Session information")
     messages: list[ConversationMessageOutput] = Field(..., description="All messages in session")
     export_format: ExportFormat = Field(..., description="Format of the export")
-    export_timestamp: datetime = Field(default_factory=datetime.utcnow, description="Export timestamp")
+    export_timestamp: datetime = Field(default_factory=lambda: datetime.now(UTC), description="Export timestamp")
     metadata: dict[str, Any] = Field(default_factory=dict, description="Export metadata")
 
 
@@ -463,7 +463,7 @@ class ConversationSummaryOutput(BaseModel):
     important_decisions: list[str] = Field(default_factory=list, description="Important decisions made")
     unresolved_questions: list[str] = Field(default_factory=list, description="Questions still unresolved")
     summary_strategy: SummarizationStrategy = Field(..., description="Strategy used for summarization")
-    created_at: datetime = Field(default_factory=datetime.utcnow, description="Summary creation timestamp")
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC), description="Summary creation timestamp")
     metadata: dict[str, Any] = Field(default_factory=dict, description="Additional summary metadata")
 
     @classmethod
@@ -609,7 +609,7 @@ class ConversationExportOutput(BaseModel):
     messages: list[ConversationMessageOutput] = Field(..., description="Exported messages")
     summaries: list[ConversationSummaryOutput] = Field(default_factory=list, description="Conversation summaries")
     export_format: ExportFormat = Field(..., description="Format of the export")
-    export_timestamp: datetime = Field(default_factory=datetime.utcnow, description="Export timestamp")
+    export_timestamp: datetime = Field(default_factory=lambda: datetime.now(UTC), description="Export timestamp")
     total_messages: int = Field(..., ge=0, description="Total number of messages exported")
     total_tokens: int = Field(default=0, ge=0, description="Total tokens in exported content")
     file_size_bytes: int = Field(default=0, ge=0, description="Size of exported file in bytes")
 
@@ -6,7 +6,7 @@
 
 import logging
 import re
-from datetime import datetime, timedelta
+from datetime import UTC, datetime, timedelta
 from typing import Any
 from uuid import UUID
 
@@ -788,7 +788,7 @@ async def get_session_statistics(self, session_id: UUID, user_id: UUID) -> Sessi
             cot_usage_count=cot_usage_count,
             context_enhancement_count=context_enhancement_count,
             created_at=session.created_at,
-            last_activity=datetime.utcnow(),
+            last_activity=datetime.now(UTC),
             metadata={
                 "total_llm_calls": total_llm_calls,
                 "cot_token_count": cot_token_count,
@@ -811,7 +811,7 @@ async def export_session(self, session_id: UUID, user_id: UUID, export_format: s
             "session_data": session,
             "messages": messages,
             "export_format": export_format,
-            "export_timestamp": datetime.utcnow(),
+            "export_timestamp": datetime.now(UTC),
             "metadata": {"cot_integration": True, "context_enhancement": True},
         }
 
@@ -1198,7 +1198,7 @@ def cleanup_expired_sessions(self) -> int:
         """Clean up expired sessions and return count of cleaned sessions."""
 
         # Sessions expire after 7 days of inactivity
-        expiry_date = datetime.utcnow() - timedelta(days=7)
+        expiry_date = datetime.now(UTC) - timedelta(days=7)
 
         expired_sessions = (
             self.db.query(ConversationSession)
@@ -1382,7 +1382,7 @@ async def generate_conversation_summary(self, session_id: UUID, user_id: UUID, s
             "topics": list(topics)[:10],  # Limit to top 10 topics
             "total_tokens": stats.total_tokens,
             "cot_usage_count": stats.cot_usage_count,
-            "generated_at": datetime.utcnow().isoformat(),
+            "generated_at": datetime.now(UTC).isoformat(),
         }
 
     def _generate_brief_summary(
 
@@ -148,7 +148,7 @@ def get_reranker(self, user_id: UUID4) -> BaseReranker | None:
             user_id: User UUID for creating LLM-based reranker
 
         Returns:
-            Reranker instance (LLMReranker or SimpleReranker), or None if disabled
+            Reranker instance (CrossEncoderReranker, LLMReranker or SimpleReranker), or None if disabled
         """
         if not self.settings.enable_reranking:
             return None
@@ -157,10 +157,22 @@ def get_reranker(self, user_id: UUID4) -> BaseReranker | None:
 
         # pylint: disable=import-outside-toplevel
         # Justification: Lazy import to avoid circular dependency
-        from rag_solution.retrieval.reranker import LLMReranker, SimpleReranker
+        from rag_solution.retrieval.reranker import CrossEncoderReranker, LLMReranker, SimpleReranker
         from rag_solution.schemas.prompt_template_schema import PromptTemplateType
 
-        if self.settings.reranker_type == "llm":
+        if self.settings.reranker_type == "cross-encoder":
+            try:
+                logger.debug("Creating cross-encoder reranker for user %s", user_id)
+                reranker = CrossEncoderReranker(model_name=self.settings.cross_encoder_model)
+                logger.debug("Cross-encoder reranker created successfully for user %s", user_id)
+                return reranker
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                # Justification: Fallback to simple reranker for any initialization error
+                logger.warning(
+                    "Failed to create cross-encoder reranker for user %s: %s, using simple reranker", user_id, e
+                )
+                return SimpleReranker()
+        elif self.settings.reranker_type == "llm":
             try:
                 # Get LLM provider
                 provider_config = self.llm_provider_service.get_default_provider()
 
@@ -124,6 +124,9 @@ def _create_default_rag_template(self, user_id: UUID4) -> PromptTemplateOutput:
                 template_type=PromptTemplateType.RAG_QUERY,
                 system_prompt=(
                     "You are a helpful AI assistant specializing in answering questions based on the given context. "
+                    "Answer ONLY the user's question that is provided. "
+                    "Do not generate additional questions or topics. "
+                    "Provide a single, focused, concise answer based on the context.\n\n"
                     "Format your responses using Markdown for better readability:\n"
                     "- Use **bold** for emphasis on key points\n"
                     "- Use bullet points (- or *) for lists\n"