llm_handling.py

import os
import logging
import json
from typing import List, Dict, Tuple, Optional, Any, Iterator
import shutil
import re
import time
import requests
import zipfile
import tempfile
import gdown

import torch
from sentence_transformers import SentenceTransformer
from pypdf import PdfReader
import docx as python_docx

from llama_index.core.llms import ChatMessage
from llama_index.llms.groq import Groq as LlamaIndexGroqClient

from langchain_groq import ChatGroq
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.prompts import ChatPromptTemplate
from langchain.schema import Document, BaseRetriever
from langchain.callbacks.manager import CallbackManagerForRetrieverRun
from langchain.schema.runnable import RunnablePassthrough, RunnableParallel
from langchain.schema.output_parser import StrOutputParser
from langchain.text_splitter import RecursiveCharacterTextSplitter
# MODIFIED: Import the new prompt
from system_prompts import PROMPTS

logger = logging.getLogger(__name__)
if not logger.handlers:
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    )

# --- Configuration Constants ---
GROQ_API_KEY = os.getenv('BOT_API_KEY')
if not GROQ_API_KEY:
    logger.critical("CRITICAL: BOT_API_KEY environment variable not found. Services will fail.")

FALLBACK_LLM_MODEL_NAME = os.getenv("GROQ_FALLBACK_MODEL", "llama-3.1-70b-versatile")
# ADDED: New constant for the auxiliary model
AUXILIARY_LLM_MODEL_NAME = os.getenv("GROQ_AUXILIARY_MODEL", "llama3-8b-8192")
_MODULE_BASE_DIR = os.path.dirname(os.path.abspath(__file__))
RAG_FAISS_INDEX_SUBDIR_NAME = "faiss_index"
RAG_STORAGE_PARENT_DIR = os.getenv("RAG_STORAGE_DIR", os.path.join(_MODULE_BASE_DIR, "faiss_storage"))
RAG_SOURCES_DIR = os.getenv("SOURCES_DIR", os.path.join(_MODULE_BASE_DIR, "sources"))
RAG_CHUNKED_SOURCES_FILENAME = "pre_chunked_sources.json"
os.makedirs(RAG_SOURCES_DIR, exist_ok=True)
os.makedirs(RAG_STORAGE_PARENT_DIR, exist_ok=True)
RAG_EMBEDDING_MODEL_NAME = os.getenv("RAG_EMBEDDING_MODEL", "all-MiniLM-L6-v2")
RAG_EMBEDDING_USE_GPU = os.getenv("RAG_EMBEDDING_GPU", "False").lower() == "true"
RAG_LLM_MODEL_NAME = os.getenv("RAG_LLM_MODEL", "llama-3.1-70b-versatile")
RAG_LLM_TEMPERATURE = float(os.getenv("RAG_TEMPERATURE", 0.0))
RAG_LOAD_INDEX_ON_STARTUP = os.getenv("RAG_LOAD_INDEX", "True").lower() == "true"
RAG_DEFAULT_RETRIEVER_K = int(os.getenv("RAG_RETRIEVER_K", 3))
GDRIVE_SOURCES_ENABLED = os.getenv("GDRIVE_SOURCES_ENABLED", "False").lower() == "true"
GDRIVE_FOLDER_ID_OR_URL = os.getenv("GDRIVE_FOLDER_URL")

# --- Text Extraction Helper Function ---
def extract_text_from_file(file_path: str, file_type: str) -> Optional[str]:
    logger.info(f"Extracting text from {file_type.upper()} file: {os.path.basename(file_path)}")
    try:
        if file_type == 'pdf':
            reader = PdfReader(file_path)
            return "".join(page.extract_text() + "\n" for page in reader.pages if page.extract_text())
        elif file_type == 'docx':
            doc = python_docx.Document(file_path)
            return "\n".join(para.text for para in doc.paragraphs if para.text)
        elif file_type == 'txt':
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                return f.read()
        logger.warning(f"Unsupported file type for text extraction: {file_type}")
        return None
    except Exception as e:
        logger.error(f"Error extracting text from {os.path.basename(file_path)}: {e}", exc_info=True)
        return None

FAISS_RAG_SUPPORTED_EXTENSIONS = {'pdf': 'pdf', 'docx': 'docx', 'txt': 'txt'}

# --- FAISS RAG System ---
class FAISSRetrieverWithScore(BaseRetriever):
    vectorstore: FAISS
    k: int = RAG_DEFAULT_RETRIEVER_K

    def _get_relevant_documents(
        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
    ) -> List[Document]:
        docs_and_scores = self.vectorstore.similarity_search_with_score(query, k=self.k)
        relevant_docs = []
        for doc, score in docs_and_scores:
            doc.metadata["retrieval_score"] = float(score)
            relevant_docs.append(doc)
        return relevant_docs

class KnowledgeRAG:
    def __init__(
        self,
        index_storage_dir: str,
        embedding_model_name: str,
        groq_model_name_for_rag: str,
        use_gpu_for_embeddings: bool,
        groq_api_key_for_rag: str,
        temperature: float,
    ):
        self.logger = logging.getLogger(__name__ + ".KnowledgeRAG")
        self.index_storage_dir = index_storage_dir
        self.embedding_model_name = embedding_model_name
        self.groq_model_name = groq_model_name_for_rag
        self.temperature = temperature

        device = "cuda" if use_gpu_for_embeddings and torch.cuda.is_available() else "cpu"
        self.logger.info(f"Initializing Hugging Face embedding model: {self.embedding_model_name} on device: {device}")
        try:
            self.embeddings = HuggingFaceEmbeddings(
                model_name=self.embedding_model_name,
                model_kwargs={"device": device},
                encode_kwargs={"normalize_embeddings": True}
            )
        except Exception as e:
            self.logger.critical(f"Failed to load embedding model: {e}", exc_info=True)
            raise

        self.logger.info(f"Initializing Langchain ChatGroq LLM for RAG: {self.groq_model_name}")
        if not groq_api_key_for_rag:
            raise ValueError("Groq API Key for RAG is missing.")
        try:
            self.llm = ChatGroq(
                temperature=self.temperature,
                groq_api_key=groq_api_key_for_rag,
                model_name=self.groq_model_name
            )
        except Exception as e:
            self.logger.critical(f"Failed to initialize Langchain ChatGroq LLM: {e}", exc_info=True)
            raise

        self.vector_store: Optional[FAISS] = None
        self.retriever: Optional[FAISSRetrieverWithScore] = None
        self.rag_chain = None
        self.processed_source_files: List[str] = []

    def build_index_from_source_files(self, source_folder_path: str, k: int = RAG_DEFAULT_RETRIEVER_K):
        all_docs_for_vectorstore: List[Document] = []
        processed_files_this_build: List[str] = []
        pre_chunked_json_path = os.path.join(self.index_storage_dir, RAG_CHUNKED_SOURCES_FILENAME)

        if os.path.exists(pre_chunked_json_path):
            self.logger.info(f"Loading documents from pre-chunked file: {pre_chunked_json_path}")
            try:
                with open(pre_chunked_json_path, 'r', encoding='utf-8') as f:
                    chunk_data_list = json.load(f)
                source_filenames = set()
                for chunk_data in chunk_data_list:
                    doc = Document(page_content=chunk_data.get("page_content", ""), metadata=chunk_data.get("metadata", {}))
                    all_docs_for_vectorstore.append(doc)
                    if 'source_document_name' in doc.metadata:
                        source_filenames.add(doc.metadata['source_document_name'])
                processed_files_this_build = sorted(list(source_filenames))
            except Exception as e:
                self.logger.error(f"Error processing pre-chunked JSON, falling back to raw files: {e}")
                all_docs_for_vectorstore.clear()

        if not all_docs_for_vectorstore:
            self.logger.info(f"Processing raw files from '{source_folder_path}' to build index.")
            text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
            for filename in os.listdir(source_folder_path):
                file_path = os.path.join(source_folder_path, filename)
                file_ext = filename.split('.')[-1].lower()
                if os.path.isfile(file_path) and file_ext in FAISS_RAG_SUPPORTED_EXTENSIONS:
                    text_content = extract_text_from_file(file_path, file_ext)
                    if text_content:
                        chunks = text_splitter.split_text(text_content)
                        for i, chunk_text in enumerate(chunks):
                            metadata = {"source_document_name": filename, "chunk_index": i}
                            all_docs_for_vectorstore.append(Document(page_content=chunk_text, metadata=metadata))
                        processed_files_this_build.append(filename)

        if not all_docs_for_vectorstore:
            self.logger.warning(f"No processable PDF/DOCX/TXT documents found in '{source_folder_path}'. RAG index will only contain other sources if available.")


        self.processed_source_files = processed_files_this_build
        
        # This print statement is kept for console visibility on startup/rebuild
        print("\n--- Document Files Used for RAG Index ---")
        if self.processed_source_files:
            for filename in self.processed_source_files:
                print(f"- {filename}")
        else:
            print("No PDF/DOCX/TXT source files were processed for the RAG index.")
        print("---------------------------------------\n")

        if not all_docs_for_vectorstore:
            self.logger.warning("No documents to build FAISS index from. Skipping FAISS build.")
            return

        self.logger.info(f"Creating FAISS index from {len(all_docs_for_vectorstore)} document chunks...")
        self.vector_store = FAISS.from_documents(all_docs_for_vectorstore, self.embeddings)
        faiss_index_path = os.path.join(self.index_storage_dir, RAG_FAISS_INDEX_SUBDIR_NAME)
        self.vector_store.save_local(faiss_index_path)
        self.logger.info(f"FAISS index built and saved to '{faiss_index_path}'.")
        self.retriever = FAISSRetrieverWithScore(vectorstore=self.vector_store, k=k)
        self.setup_rag_chain()

    def load_index_from_disk(self, k: int = RAG_DEFAULT_RETRIEVER_K):
        faiss_index_path = os.path.join(self.index_storage_dir, RAG_FAISS_INDEX_SUBDIR_NAME)
        if not os.path.isdir(faiss_index_path):
            raise FileNotFoundError(f"FAISS index directory not found at '{faiss_index_path}'.")

        self.logger.info(f"Loading FAISS index from: {faiss_index_path}")
        self.vector_store = FAISS.load_local(
            folder_path=faiss_index_path,
            embeddings=self.embeddings,
            allow_dangerous_deserialization=True
        )
        self.retriever = FAISSRetrieverWithScore(vectorstore=self.vector_store, k=k)
        self.setup_rag_chain()

    def format_docs(self, docs: List[Document]) -> str:
        """
        Formatea los documentos recuperados en una cadena de texto para el prompt,
        incluyendo el nombre del archivo de origen.
        """
        formatted_chunks = []
        for doc in docs:
            source_document_name = doc.metadata.get('source_document_name', 'Desconocido')
            chunk_content = doc.page_content
            formatted_chunks.append(f"Documento: {source_document_name}\nTexto: {chunk_content}")
        
        return "\n\n---\n\n".join(formatted_chunks)
    def setup_rag_chain(self):
        if not self.retriever or not self.llm:
            raise RuntimeError("Retriever and LLM must be initialized.")
        
        prompt = ChatPromptTemplate.from_template(RAG_SYSTEM_PROMPT)

        self.rag_chain = (
            RunnableParallel(
                context=(self.retriever | self.format_docs),
                question=RunnablePassthrough()
            )
            | prompt
            | self.llm
            | StrOutputParser()
        )
        self.logger.info("RAG LCEL chain set up successfully with dental assistant persona.")
    # Dentro de la clase KnowledgeRAG, modifica el método invoke
    def invoke(self, query: str, lang: str = "es", top_k: Optional[int] = None) -> Dict[str, Any]: # MODIFICADO: Añadido 'lang'
        if not self.retriever or not self.llm: # Mantén esta parte
            self.logger.warning("RAG system not fully initialized. Cannot invoke.")
            return {"answer": "The provided bibliography does not contain specific information on this topic.", "source": "system_error", "cited_source_details": []}
    
        if not query or not query.strip(): # Mantén esta parte
            return {"answer": "Please provide a valid question.", "source": "system_error", "cited_source_details": []}
    
        k_to_use = top_k if top_k is not None and top_k > 0 else self.retriever.k
        self.logger.info(f"Processing RAG query with k={k_to_use}: '{query[:100]}...'")
    
        original_k = self.retriever.k
        if k_to_use != original_k:
            self.retriever.k = k_to_use
        
        try:
            retrieved_docs = self.retriever.get_relevant_documents(query)
            if not retrieved_docs: # Mantén esta parte
                return {"answer": "The provided bibliography does not contain specific information on this topic.", "source": "no_docs_found", "cited_source_details": []}
    
            # MODIFICADO: Ahora format_docs solo formatea, no añade el idioma.
            context_str = self.format_docs(retrieved_docs)
            
            # AÑADIDO: Selecciona el prompt correcto según el idioma.
            # Usa un fallback si el idioma no está en el diccionario.
            selected_lang = lang if lang in PROMPTS["rag_prompt"] else "es"
            prompt_template = ChatPromptTemplate.from_template(PROMPTS["rag_prompt"][selected_lang])
            
            # AÑADIDO: Reconstruye la cadena RAG con el prompt dinámico.
            rag_chain = (
                RunnableParallel(
                    context=RunnablePassthrough(), # El contexto ya está formateado
                    question=RunnablePassthrough()
                )
                | prompt_template
                | self.llm
                | StrOutputParser()
            )
            
            # MODIFICADO: Invoca la cadena recién creada y pasa el contexto
            llm_answer = rag_chain.invoke(
                {"context": context_str, "question": query}
            )
            
            # Mantén el resto de la lógica para el logging y el retorno...
            print(f"\n--- RAG INVOKE ---")
            print(f"QUESTION: {query}")
            print(f"CONTEXT:\n{context_str}")
            print(f"LLM_ANSWER: {llm_answer}")
            print(f"--------------------\n")
    
            structured_sources = [{
                "source_document_name": doc.metadata.get('source_document_name', 'Unknown'),
                "chunk_index": doc.metadata.get('chunk_index', 'N/A'),
                "retrieval_score": doc.metadata.get("retrieval_score"),
            } for doc in retrieved_docs]
    
            if "the provided bibliography does not contain specific information" in llm_answer.lower():
                 final_answer = llm_answer
                 source_tag = "no_answer_in_bibliography"
            else:
                 final_answer = f"{llm_answer}" # Mantén tu lógica para formatear la respuesta
                 source_tag = "bibliography_based"
    
            return {
                "query": query,
                "answer": final_answer.strip(),
                "source": source_tag,
                "cited_source_details": structured_sources,
            }
    
        except Exception as e: # Mantén este bloque
            self.logger.error(f"Error during RAG query processing: {e}", exc_info=True)
            return {"answer": "An error occurred while processing your request.", "source": "system_error", "cited_source_details": []}
        finally: # Mantén este bloque
            if k_to_use != original_k:
                self.retriever.k = original_k
    
    def stream(self, query: str, top_k: Optional[int] = None) -> Iterator[str]:
        if not self.rag_chain:
            self.logger.error("RAG system not fully initialized for streaming.")
            yield "Error: RAG system is not ready."
            return

        k_to_use = top_k if top_k is not None and top_k > 0 else self.retriever.k
        self.logger.info(f"Processing RAG stream with k={k_to_use}: '{query[:100]}...'")

        original_k = self.retriever.k
        if k_to_use != original_k:
            self.retriever.k = k_to_use
        
        try:
            # Check for docs first to avoid streaming "no info" message
            retrieved_docs = self.retriever.get_relevant_documents(query)
            if not retrieved_docs:
                yield "The provided bibliography does not contain specific information on this topic."
                return
            
            # MODIFIED: Added full logging for streaming as per user request
            context_str = self.format_docs(retrieved_docs)
            print(f"\n--- RAG STREAM ---")
            print(f"QUESTION: {query}")
            print(f"CONTEXT:\n{context_str}")
            print(f"STREAMING LLM_ANSWER...")
            print(f"--------------------\n")
                
            yield from self.rag_chain.stream(query, config={"context": context_str})
        except Exception as e:
            self.logger.error(f"Error during RAG stream processing: {e}", exc_info=True)
            yield "An error occurred while processing your request."
        finally:
            if k_to_use != original_k:
                self.retriever.k = original_k


# --- Groq Fallback Bot ---
class GroqBot:
    def __init__(self):
        self.logger = logging.getLogger(__name__ + ".GroqBot")
        if not GROQ_API_KEY:
            self.client = None
            self.logger.critical("GroqBot not initialized: BOT_API_KEY is missing.")
            return
        try:
            self.client = LlamaIndexGroqClient(model=FALLBACK_LLM_MODEL_NAME, api_key=GROQ_API_KEY)
            self.system_prompt = FALLBACK_SYSTEM_PROMPT
        except Exception as e:
            self.logger.error(f"Failed to initialize LlamaIndexGroqClient for Fallback Bot: {e}", exc_info=True)
            self.client = None

    def stream_response(self, context: dict) -> Iterator[str]:
        if not self.client:
            yield "The system is currently unable to process this request."
            return

        current_query = context.get('current_query', '')
        chat_history = context.get('chat_history', [])
        qa_info = context.get('qa_related_info', '')

        messages = [ChatMessage(role="system", content=self.system_prompt)]
        if chat_history:
            messages.extend([ChatMessage(**msg) for msg in chat_history])
        if qa_info:
            messages.append(ChatMessage(role="system", content=f"**Potentially Relevant Q&A Information from other sources:**\n{qa_info}"))
        messages.append(ChatMessage(role="user", content=f"**Current User Query:**\n{current_query}"))
        
        # MODIFIED: Added full logging as per user request
        # The conversion to dict is necessary because ChatMessage is not directly JSON serializable
        messages_for_print = [msg.dict() for msg in messages]
        print(f"\n--- FALLBACK STREAM ---")
        print(f"MESSAGES SENT TO LLM:\n{json.dumps(messages_for_print, indent=2)}")
        print(f"STREAMING LLM_ANSWER...")
        print(f"-----------------------\n")

        try:
            response_stream = self.client.stream_chat(messages)
            for r_chunk in response_stream:
                yield r_chunk.delta
        except Exception as e:
            self.logger.error(f"Groq API error in get_response (Fallback): {e}", exc_info=True)
            yield "I am currently unable to process this request due to a technical issue."

# ADDED: New function for formatting QA answers
def get_answer_from_context(question: str, context: str, system_prompt: str) -> str:
    """
    Calls the LLM with a specific question and context from a QA source (CSV/XLSX).
    """
    logger.info(f"Formatting answer for question '{question[:50]}...' using QA context.")
    try:
        # Use the auxiliary model for this task for speed and cost-efficiency
        formatter_llm = ChatGroq(
            temperature=0.1,
            groq_api_key=GROQ_API_KEY,
            model_name=AUXILIARY_LLM_MODEL_NAME
        )
        
        prompt_template = ChatPromptTemplate.from_template(system_prompt)
        
        chain = prompt_template | formatter_llm | StrOutputParser()
        
        # MODIFIED: Added full logging as per user request
        print(f"\n--- QA FORMATTER ---")
        print(f"QUESTION: {question}")
        print(f"CONTEXT:\n{context}")

        response = chain.invoke({
            "context": context,
            "question": question
        })

        print(f"LLM_ANSWER: {response}")
        print(f"--------------------\n")
        
        return response.strip()
        
    except Exception as e:
        logger.error(f"Error in get_answer_from_context: {e}", exc_info=True)
        return "Sorry, I was unable to formulate an answer based on the available information."


# --- Initialization and Interface Functions ---
def get_id_from_gdrive_input(url_or_id: str) -> Optional[str]:
    if not url_or_id: return None
    patterns = [r"/folders/([a-zA-Z0-9_-]+)", r"/d/([a-zA-Z0-9_-]+)", r"id=([a-zA-Z0-9_-]+)"]
    for pattern in patterns:
        match = re.search(pattern, url_or_id)
        if match: return match.group(1)
    if "/" not in url_or_id and "=" not in url_or_id and len(url_or_id) > 15:
        return url_or_id
    return None

def download_and_unzip_gdrive_folder(folder_id_or_url: str, target_dir: str) -> bool:
    folder_id = get_id_from_gdrive_input(folder_id_or_url)
    if not folder_id:
        logger.error(f"Invalid Google Drive Folder ID or URL: {folder_id_or_url}")
        return False
    
    with tempfile.TemporaryDirectory() as temp_dir:
        try:
            logger.info(f"Attempting to download GDrive folder ID: {folder_id}")
            download_path = gdown.download_folder(id=folder_id, output=temp_dir, quiet=False, use_cookies=False)
            if not download_path or not os.listdir(temp_dir):
                logger.error("gdown failed to download or extract the folder.")
                return False

            source_content_root = temp_dir
            items_in_temp = os.listdir(temp_dir)
            if len(items_in_temp) == 1 and os.path.isdir(os.path.join(temp_dir, items_in_temp[0])):
                source_content_root = os.path.join(temp_dir, items_in_temp[0])
            
            logger.info(f"Moving contents from {source_content_root} to {target_dir}")
            if os.path.exists(target_dir):
                shutil.rmtree(target_dir)
            shutil.copytree(source_content_root, target_dir)
            logger.info(f"Successfully moved GDrive contents to {target_dir}")
            return True
        except Exception as e:
            # MODIFIED: Corrected self.logger to logger
            logger.error(f"Error during GDrive download/processing: {e}", exc_info=True)
            return False

def initialize_and_get_rag_system(force_rebuild: bool = False) -> Optional[KnowledgeRAG]:
    if not GROQ_API_KEY:
        logger.error("RAG system cannot be initialized without BOT_API_KEY.")
        return None

    if GDRIVE_SOURCES_ENABLED and GDRIVE_FOLDER_ID_OR_URL:
        logger.info("Google Drive sources enabled. Downloading...")
        if os.path.isdir(RAG_SOURCES_DIR):
            logger.info(f"Clearing existing RAG sources directory: {RAG_SOURCES_DIR}")
            shutil.rmtree(RAG_SOURCES_DIR)
            os.makedirs(RAG_SOURCES_DIR)
        
        download_successful = download_and_unzip_gdrive_folder(GDRIVE_FOLDER_ID_OR_URL, RAG_SOURCES_DIR)
        if not download_successful:
            logger.error("Failed to download sources from Google Drive. Using local files if available.")

    faiss_index_path = os.path.join(RAG_STORAGE_PARENT_DIR, RAG_FAISS_INDEX_SUBDIR_NAME)
    if force_rebuild and os.path.exists(RAG_STORAGE_PARENT_DIR):
        logger.info(f"Force Rebuild: Deleting existing index storage directory at '{RAG_STORAGE_PARENT_DIR}'")
        shutil.rmtree(RAG_STORAGE_PARENT_DIR)
        os.makedirs(RAG_STORAGE_PARENT_DIR)

    try:
        rag_instance = KnowledgeRAG(
            index_storage_dir=RAG_STORAGE_PARENT_DIR,
            embedding_model_name=RAG_EMBEDDING_MODEL_NAME,
            groq_model_name_for_rag=RAG_LLM_MODEL_NAME,
            use_gpu_for_embeddings=RAG_EMBEDDING_USE_GPU,
            groq_api_key_for_rag=GROQ_API_KEY,
            temperature=RAG_LLM_TEMPERATURE,
        )
        
        should_build = True
        if RAG_LOAD_INDEX_ON_STARTUP and not force_rebuild:
            try:
                rag_instance.load_index_from_disk(k=RAG_DEFAULT_RETRIEVER_K)
                logger.info("RAG index loaded successfully from disk.")
                should_build = False
            except FileNotFoundError:
                logger.warning("Index not found on disk. Will attempt to build.")
            except Exception as e:
                logger.error(f"Error loading index: {e}. Will attempt to rebuild.", exc_info=True)

        if should_build:
            logger.info("Building new RAG index from source data...")
            rag_instance.build_index_from_source_files(
                source_folder_path=RAG_SOURCES_DIR,
                k=RAG_DEFAULT_RETRIEVER_K
            )
        
        return rag_instance

    except Exception as e:
        logger.critical(f"FATAL: Failed to initialize RAG system: {e}", exc_info=True)
        return None

groq_bot_instance = GroqBot()

# ADDED: New function to handle auxiliary model calls (This function is no longer used, replaced by get_answer_from_context)
def get_auxiliary_chat_response(messages: List[Dict]) -> str:
    """
    Handles requests for auxiliary tasks like generating titles or follow-up questions.
    Uses a separate, smaller model for efficiency.
    """
    logger.info(f"Routing auxiliary request to model: {AUXILIARY_LLM_MODEL_NAME}")
    try:
        # Initialize a dedicated client for this call to use the specific auxiliary model
        aux_client = ChatGroq(
            temperature=0.2, # A bit more creative than RAG, but still grounded
            groq_api_key=GROQ_API_KEY,
            model_name=AUXILIARY_LLM_MODEL_NAME
        )
        response = aux_client.invoke(messages)
        return response.content
    except Exception as e:
        logger.error(f"Error with auxiliary model call: {e}", exc_info=True)
        return "Could not generate suggestions."