Update space

README.md

@@ -1,12 +1,13 @@
 ---
-title: Gbd
+title: Recipe Thesis Agent
 emoji: 💬
 colorFrom: yellow
 colorTo: purple
 sdk: gradio
-sdk_version: 5.0.1
+sdk_version: 5.23.2
 app_file: app.py
 pinned: false
+python_version: 3.12
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).

app.py

@@ -1,64 +1,876 @@
+# -*- coding: utf-8 -*-
+import os
+import pandas as pd
+import time
+import logging
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
+from typing import Optional, List, Dict # Keep typing
+# from functools import lru_cache # Keep commented out
+import random
+import shutil
+import re # Used for parsing recipe directions
+
+# --- LangChain Imports ---
+# Core
+from langchain_core.documents import Document
+from langchain_core.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+# LLMs (using Google GenAI wrapper)
+from langchain_google_genai import ChatGoogleGenerativeAI
+# Vector Stores / Embeddings
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import Chroma
+# --- Other Imports ---
+from datasets import load_dataset # Keep specific exception handling removed
+import pyarrow # Keep explicit import
+
+# Attempt to load python-dotenv for easier local API key management (optional)
+try:
+    from dotenv import load_dotenv
+    load_dotenv() # Load variables from .env file if it exists
+    DOTENV_AVAILABLE = True
+except ImportError:
+    DOTENV_AVAILABLE = False
+
+# ==============================================================================
+# Logging Configuration
+# ==============================================================================
+logging.basicConfig(
+    level=logging.INFO, # INFO level is usually sufficient for running
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 )
+logger = logging.getLogger('recipe_system')
+
+# ==============================================================================
+# Conditional Imports & Feature Flags
+# ==============================================================================
+# --- Vector Search Imports Check ---
+VECTOR_IMPORTS_AVAILABLE = False
+try:
+    if HuggingFaceEmbeddings and Chroma and Document and load_dataset and pyarrow:
+         VECTOR_IMPORTS_AVAILABLE = True
+    logger.info("Vector search dependencies check: OK.")
+except NameError:
+    logger.error("Import check failed for vector search dependencies.")
+    VECTOR_IMPORTS_AVAILABLE = False
+# --- LLM (LangChain Google GenAI) Imports Check ---
+LANGCHAIN_LLM_AVAILABLE = False
+GOOGLE_API_KEY = None
+try:
+    if ChatGoogleGenerativeAI and PromptTemplate and StrOutputParser:
+        GOOGLE_API_KEY = os.environ.get('GOOGLE_API_KEY')
+        if not GOOGLE_API_KEY:
+            logger.warning("GOOGLE_API_KEY environment variable not found.")
+            if DOTENV_AVAILABLE: logger.info("Checked environment and .env file (if present).")
+            else: logger.info("Checked environment variables.")
+            LANGCHAIN_LLM_AVAILABLE = False
+        else:
+            logger.info("GOOGLE_API_KEY found. LangChain LLM dependencies appear available.")
+            LANGCHAIN_LLM_AVAILABLE = True
+except NameError:
+    logger.error("Import check failed for LangChain LLM (Gemini) components.")
+    logger.error("<<<<< Please ensure 'langchain-google-genai' is installed (in requirements.txt) >>>>>")
+    LANGCHAIN_LLM_AVAILABLE = False
+
+if not VECTOR_IMPORTS_AVAILABLE: logger.warning("Vector database imports failed - vector search disabled.")
+if not LANGCHAIN_LLM_AVAILABLE: logger.warning("LangChain LLM setup incomplete - LLM features disabled.")
+# --- End Import Check ---
+
+# ==============================================================================
+# Constants
+# ==============================================================================
+VECTOR_DB_PATH = "./recipe_vectordb" # Example path for persistence (not implemented yet)
+DATASET_NAME = "corbt/all-recipes"
+RECIPES_CSV_PATH = "recipes_data.csv"
+GEMINI_MODEL_NAME = "models/gemini-1.5-flash-latest"
+
+# ==============================================================================
+# Recipe Recommendation System Class (Includes Agentic Routing)
+# ==============================================================================
+class RecipeRecommendationSystem:
+    """
+    Manages recipe data loading, parsing, indexing (vector or text), searching,
+    and optional LLM query expansion & RAG using LangChain. Includes enhanced logging
+    and minimal agentic routing.
+    """
+    def __init__(self):
+        self.is_initialized = False
+        self.initialization_error = None
+        self.embeddings = None
+        self.vector_db = None
+        self.recipes_df = None
+        self.sample_size = 1000
+        self.backup_recipes = self._get_backup_recipes()
+        self.lc_llm: Optional[ChatGoogleGenerativeAI] = None
+        self.use_vector_search = VECTOR_IMPORTS_AVAILABLE
+        self.use_llm = LANGCHAIN_LLM_AVAILABLE
+        logger.info(f"System instance created. Vector search: {self.use_vector_search}, LLM (LangChain Gemini): {self.use_llm}")
+
+    def _load_llm(self):
+        if not self.use_llm:
+            logger.info("LLM features disabled or dependencies missing.")
+            return False
+        if self.lc_llm:
+            logger.info("LangChain LLM wrapper already configured.")
+            return True
+        try:
+            logger.info(f"Configuring LangChain Gemini LLM wrapper for model: {GEMINI_MODEL_NAME}...")
+            self.lc_llm = ChatGoogleGenerativeAI(
+                model=GEMINI_MODEL_NAME, google_api_key=GOOGLE_API_KEY, temperature=0.7
+            )
+            logger.info("LangChain Gemini LLM wrapper configured successfully.")
+            return True
+        except Exception as e:
+            logger.exception(f"Error configuring LangChain Gemini LLM wrapper: {e}")
+            self.lc_llm = None
+            self.use_llm = False
+            self.initialization_error = (self.initialization_error or "") + f" | LangChain LLM Config Failed: {e}"
+            return False
+
+    def initialize(self, force_reload=False, sample_size=1000):
+        start_time = time.time()
+        logger.info(f"Initialize called. Force reload: {force_reload}, Sample size: {sample_size}")
+        llm_ready = not self.use_llm or (self.lc_llm is not None)
+
+        if (self.is_initialized and not force_reload and self.sample_size == sample_size and
+                self.recipes_df is not None and not self.recipes_df.empty and llm_ready):
+            search_mode_ok = (self.use_vector_search and self.vector_db is not None) or \
+                             (not self.use_vector_search and self.vector_db is None)
+            if search_mode_ok:
+                logger.info(f"System already initialized ({'Vector' if self.use_vector_search else 'Text'} Search, LLM: {llm_ready}). Skipping.")
+                return True
+
+        self.sample_size = sample_size
+        logger.info(f"{'Reloading' if self.is_initialized or force_reload else 'Initializing'} system...")
+        self.is_initialized = False
+        self.initialization_error = None
+        self.vector_db = None # Reset DB on initialize/reload
+        self.recipes_df = None # Reset DF
+        if force_reload: self.lc_llm = None # Reset LLM wrapper too if forcing
+
+        llm_load_success = self._load_llm()
+        if not llm_load_success: logger.warning("LLM configuration failed. LLM features will be disabled.")
+
+        should_attempt_vector = VECTOR_IMPORTS_AVAILABLE
+        init_success = False
+        if should_attempt_vector:
+            logger.info("Attempting vector search initialization...")
+            # Note: Persistence logic would go here - check if VECTOR_DB_PATH exists and load if !force_reload
+            create_success = self._create_new_db() # Currently always creates new
+            if create_success:
+                logger.info("Vector DB creation successful.")
+                self.use_vector_search = True
+                init_success = True
+            else:
+                error_msg = self.initialization_error or "DB creation failed"
+                logger.error(f"{error_msg}. Falling back to text search.")
+                self.recipes_df = pd.DataFrame(self.backup_recipes).reset_index()
+                self.use_vector_search = False; self.vector_db = None
+                if self.recipes_df is not None and not self.recipes_df.empty:
+                    logger.info(f"Loaded {len(self.recipes_df)} backup recipes for fallback.")
+                    init_success = True
+                else: logger.error("Failed to load backup recipes during fallback.")
+        else: # Fallback if vector imports missing
+            logger.info("Vector dependencies unavailable. Initializing with text search fallback.")
+            self.recipes_df = pd.DataFrame(self.backup_recipes).reset_index()
+            self.use_vector_search = False; self.vector_db = None
+            if self.recipes_df is not None and not self.recipes_df.empty:
+                logger.info(f"Loaded {len(self.recipes_df)} backup recipes.")
+                init_success = True
+            else: logger.error("Failed to load backup recipes.")
+
+        elapsed = time.time() - start_time
+        if init_success and self.recipes_df is not None and not self.recipes_df.empty:
+            self.is_initialized = True
+            search_type = "vector" if self.use_vector_search else "text (fallback)"
+            llm_status = "active" if self.use_llm and self.lc_llm else "inactive"
+            logger.info(f"Init finished in {elapsed:.2f}s. Search: {search_type}. LLM: {llm_status}. Recipes: {len(self.recipes_df)}.")
+            return True
+        else: # Handle overall init failure
+            if not self.initialization_error: self.initialization_error = "Init failed (unknown reason)"
+            logger.error(f"Initialization failed: {self.initialization_error}")
+            self.is_initialized = False
+            return False
+
+    def _create_new_db(self):
+        """ Creates vector DB and populates self.recipes_df. Includes enhanced logging."""
+        try:
+            # --- 1. Load Raw Data ---
+            logger.info(f"Loading dataset '{DATASET_NAME}' from Hugging Face...")
+            try:
+                # Consider adding cache_dir argument if needed: cache_dir="./hf_cache"
+                dataset = load_dataset(DATASET_NAME, split='train')
+                recipes_raw_df = dataset.to_pandas()
+                logger.info(f"Loaded and converted {len(recipes_raw_df)} recipes.")
+                assert 'input' in recipes_raw_df.columns, "Missing 'input' column"
+            except Exception as e:
+                logger.exception(f"Dataset load failed: {e}")
+                self.initialization_error = f"Dataset load failed: {e}"
+                return False
+
+            # --- 2. Sample Data ---
+            logger.debug("Checking sample size...")
+            if 0 < self.sample_size < len(recipes_raw_df): # Ensure sample_size is positive
+                logger.info(f"Sampling {self.sample_size} recipes...")
+                recipes_sampled_df = recipes_raw_df.sample(
+                    self.sample_size, random_state=42
+                ).reset_index(drop=True).copy()
+            else:
+                logger.info(f"Using all {len(recipes_raw_df)} loaded recipes (or invalid sample size).")
+                recipes_sampled_df = recipes_raw_df.reset_index(drop=True).copy()
+            logger.debug(f"DataFrame shape for processing: {recipes_sampled_df.shape}")
+
+            # --- 3. Initialize Embeddings ---
+            if not self.embeddings:
+                logger.info("Initializing embeddings model (sentence-transformers/all-MiniLM-L6-v2)...")
+                # Consider adding cache_folder argument if needed
+                self.embeddings = HuggingFaceEmbeddings(
+                    model_name="sentence-transformers/all-MiniLM-L6-v2"
+                )
+                logger.info("Embeddings model initialized.")
+            else:
+                logger.info("Embeddings model already initialized.")
+
+            # --- 4. Parse 'input' Column & Create LangChain Documents ---
+            logger.info(f"Starting parsing loop for {len(recipes_sampled_df)} recipes...")
+            documents: List[Document] = []
+            processed_data = []
+            skipped = 0
+            log_interval = max(1, len(recipes_sampled_df) // 10) # Log more frequently if needed
+
+            for idx, row in recipes_sampled_df.iterrows():
+                if (idx + 1) % log_interval == 0:
+                    logger.debug(f"Parsing progress: {idx + 1}/{len(recipes_sampled_df)}")
+                try:
+                    inp = row.get('input','')
+                    lines = [ln.strip() for ln in inp.splitlines()] if isinstance(inp, str) else []
+                    if not lines: skipped += 1; continue
+                    title = lines[0] if lines else f'Untitled Recipe {idx}'
+                    ingreds = []; directs = []; in_i = False; in_d = False # Reset flags for each recipe
+
+                    for line in lines[1:]:
+                        line_strip = line.strip()
+                        line_lower = line_strip.lower()
+                        # State machine for parsing sections
+                        if line_lower == 'ingredients:': in_i = True; in_d = False; continue
+                        elif line_lower == 'directions:': in_d = True; in_i = False; continue
+                        # If inside a section, append
+                        if in_i: ingreds.append(line_strip.lstrip('- '))
+                        elif in_d: directs.append(re.sub(r"^\s*[\d\W]+\.?\s*", "", line_strip)) # Clean step numbers/bullets
+                        # Don't reset flags on empty lines within sections
+
+                    i_str = "\n".join(ingreds).strip()
+                    d_str = "\n".join(directs).strip()
+
+                    if not title or not i_str or not d_str: skipped += 1; continue # Skip if essential parts missing
+
+                    processed_data.append({
+                        'title': title, 'ingredients': i_str, 'instructions': d_str,
+                        'description': '', 'rating': None # Add placeholders
+                    })
+                    meta = { "doc_id": int(idx), "title": title, "ingredients": i_str, "instructions": d_str }
+                    # Create document content combining key fields
+                    doc_content = f"Title: {title}\n\nIngredients:\n{i_str}\n\nInstructions:\n{d_str}"
+                    documents.append(Document(page_content=doc_content, metadata=meta))
+                except Exception as e:
+                    logger.warning(f"Error parsing row index {idx}: {e}. Title: '{title if 'title' in locals() else 'N/A'}'. Skipping.", exc_info=False)
+                    skipped += 1
+
+            logger.info(f"Parsing complete. Docs created: {len(documents)}, Data rows: {len(processed_data)}, Skipped: {skipped}")
+            if not documents:
+                self.initialization_error = "No valid documents were created after parsing."
+                return False
+
+            # --- 5. Store Parsed DataFrame & Save CSV ---
+            self.recipes_df = pd.DataFrame(processed_data)
+            if self.recipes_df.empty:
+                self.initialization_error = "Parsed DataFrame is empty after processing."
+                return False
+            try:
+                logger.info(f"Saving {len(self.recipes_df)} parsed recipes to CSV: {RECIPES_CSV_PATH}...")
+                self.recipes_df.to_csv(RECIPES_CSV_PATH, index=False)
+                logger.info("CSV saved.")
+            except Exception as e:
+                logger.warning(f"Could not save parsed recipes CSV: {e}")
+
+            # --- 6. Create IN-MEMORY Chroma DB ---
+            logger.info(f"Creating Chroma DB with {len(documents)} documents...")
+            try:
+                # Persistence logic would involve using persist_directory and Chroma(persist_directory=...) on reload
+                self.vector_db = Chroma.from_documents(
+                    documents=documents,
+                    embedding=self.embeddings
+                )
+                logger.info("Chroma DB created successfully.")
+                if self.recipes_df is None or self.recipes_df.empty: # Sanity check
+                     raise RuntimeError("Critical Error: recipes_df lost after DB creation")
+                return True
+            except Exception as e:
+                logger.exception(f"Chroma DB creation failed: {e}")
+                self.initialization_error = f"Chroma DB creation failed: {e}"
+                self.vector_db = None
+                return False
+        except Exception as e: # Catch any other unexpected error
+            logger.exception(f"Outer error in _create_new_db: {e}")
+            self.initialization_error = f"Outer DB creation error: {str(e)}"
+            self.recipes_df = None; self.vector_db = None
+            return False
+
+    def _expand_query_with_llm(self, query: str) -> Optional[str]:
+        """Uses LCEL chain with Gemini to expand search query."""
+        if not self.use_llm or not self.lc_llm: return None
+        start_time = time.time(); logger.info(f"LCEL Chain: Expanding query: '{query}'")
+        try:
+            template = "Expand this recipe search query with related terms: {query}"
+            prompt = PromptTemplate.from_template(template)
+            output_parser = StrOutputParser()
+            expansion_chain = prompt | self.lc_llm | output_parser
+            expanded_query = expansion_chain.invoke({"query": query})
+            elapsed = time.time() - start_time
+            logger.info(f"LCEL Chain: Original: '{query}' -> Expanded: '{expanded_query}' ({elapsed:.2f}s)")
+            if not expanded_query or expanded_query.lower().strip() == query.lower().strip():
+                logger.info("LCEL expansion resulted in empty or identical query."); return None
+            return expanded_query.strip()
+        except Exception as e: logger.exception(f"LCEL expansion error: {e}"); return None
+
+    def _get_routing_decision(self, query: str) -> str:
+        """Uses the LLM to decide whether a query is better for RAG or Text Search."""
+        if not self.use_llm or not self.lc_llm:
+            logger.warning("Router: LLM off. Defaulting to RAG.")
+            return "RAG"
+        logger.info(f"Router: Getting decision for query: '{query}'")
+        start_time = time.time()
+        routing_template = """You are a request router for a recipe system. Determine the best approach:
+1. 'RAG': For specific questions about recipes (ingredients, instructions, properties like "is it vegetarian?").
+2. 'TEXT_SEARCH': For general searches by name or keywords (e.g., "chocolate chip cookies", "tomato soup").
+Respond ONLY 'RAG' or 'TEXT_SEARCH'. Query: {query} Approach:"""
+        routing_prompt = PromptTemplate.from_template(routing_template)
+        output_parser = StrOutputParser()
+        try:
+            routing_chain = routing_prompt | self.lc_llm | output_parser
+            decision = routing_chain.invoke({"query": query}).strip().upper()
+            elapsed = time.time() - start_time
+            if decision in ["RAG", "TEXT_SEARCH"]: logger.info(f"Router: Decision '{decision}' ({elapsed:.2f}s)."); return decision
+            else: logger.warning(f"Router: Bad response '{decision}'. Defaulting RAG."); return "RAG"
+        except Exception as e: logger.exception(f"Router error: {e}. Defaulting RAG."); return "RAG"
+
+    def search_recipes(self, query, num_results=3):
+        """Searches recipes using LLM-routed approach."""
+        log_prefix = f"Search(Q='{query}', N={num_results})"
+        logger.info(f"{log_prefix}: Called. Init: {self.is_initialized}...")
+        if not self.is_initialized: return "System not initialized."
+        if self.recipes_df is None or self.recipes_df.empty: return "No recipe data."
+
+        original_query = query; search_query = query
+        expanded_query_used = False; llm_expansion_note = ""
+
+        # Optional Expansion
+        if self.use_llm:
+            expanded_query = self._expand_query_with_llm(original_query)
+            if expanded_query:
+                search_query = expanded_query; expanded_query_used = True
+                llm_expansion_note = f" (LLM expanded to: \"{search_query}\")"
+                logger.info(f"{log_prefix}: Using expanded query '{search_query}'")
+            else: logger.info(f"{log_prefix}: Using original query '{original_query}'")
+        else: logger.info(f"{log_prefix}: LLM expansion off. Using original query.")
+
+        search_start = time.time(); final_result = ""; search_method_used = "unknown"
+
+        # Routing
+        routing_decision = self._get_routing_decision(original_query)
+        logger.info(f"{log_prefix}: Router path: {routing_decision}")
+
+        try:
+            # --- RAG Path ---
+            if routing_decision == "RAG":
+                search_method_used = "vector (RAG chosen)"
+                if self.use_vector_search and self.vector_db is not None:
+                    try: # Attempt RAG
+                        logger.info(f"{log_prefix}: Retrieving docs (Q: '{search_query}')")
+                        retriever = self.vector_db.as_retriever(search_kwargs={'k': num_results})
+                        retrieved_docs: List[Document] = retriever.invoke(search_query)
+                        logger.info(f"{log_prefix}: Found {len(retrieved_docs)} docs.")
+                        if retrieved_docs and self.lc_llm:
+                            logger.info(f"{log_prefix}: Running RAG chain.")
+                            def format_docs(docs): return "\n\n---\n\n".join([f"Doc {i+1} (Title: {doc.metadata.get('title','N/A')}):\n{doc.page_content}" for i, doc in enumerate(docs)])
+                            context_string = format_docs(retrieved_docs)
+                            # Refined RAG prompt for better instructions
+                            rag_template_qa = """You are a helpful Recipe Assistant. Your goal is to answer the user's query based *only* on the provided recipe Context. Be factual and concise. Follow these specific instructions:
+1.  **Analyze the Query:** Is it a specific question about a recipe (e.g., "how long to bake", "ingredients for X", "is Y vegetarian?") or a general search term (e.g., "chicken soup", "easy dessert")?
+2.  **Answer Based ONLY on Context:**
+    * If the query is a specific question AND the Context contains a clear answer, provide that answer directly.
+    * If the query is a specific question BUT the Context contains relevant recipes but NOT the specific answer, state what information IS available in the context related to the question (e.g., "The context includes a recipe for Chocolate Chip Cookies, but doesn't specify the exact baking temperature needed."). DO NOT GUESS or add external knowledge.
+    * If the query is a specific question BUT the retrieved Context seems completely irrelevant, state that you couldn't find relevant information *in the provided documents* to answer the question.
+    * If the query seems like a general search term AND the Context contains relevant recipes, present the recipes found clearly. For each recipe, include: Title, Ingredients, and Instructions. Format them nicely using Markdown.
+    * If the query is a general search term BUT no relevant recipes are found in the Context, state that no matching recipes were found in the provided documents.
+3.  **Formatting:** Use Markdown for readability (like bullet points for ingredients, numbered steps for instructions).
+
+Context:
+{context}
+
+Query: {query}
+Answer:"""
+                            rag_prompt = PromptTemplate.from_template(rag_template_qa)
+                            # Setup RAG chain
+                            rag_chain = (
+                                {"context": lambda x: context_string, "query": RunnablePassthrough()}
+                                | rag_prompt
+                                | self.lc_llm
+                                | StrOutputParser()
+                            )
+                            logger.info(f"{log_prefix}: Invoking RAG chain with original query: '{original_query}'")
+                            final_result = rag_chain.invoke(original_query) # Use original query as the question for the LLM
+                            search_method_used = "vector (RAG executed)"
+                        elif not retrieved_docs:
+                            logger.info(f"{log_prefix}: 0 docs found for RAG. Falling back to text search.")
+                            final_result = "" # Trigger fallback
+                        else: # Docs found, but LLM is inactive
+                            logger.warning(f"{log_prefix}: Docs found, but LLM inactive. Cannot RAG. Falling back to text search.")
+                            final_result = "" # Trigger fallback
+                    except Exception as rag_error:
+                         logger.exception(f"{log_prefix}: Vector retrieval or RAG chain error: {rag_error}")
+                         final_result = "" # Trigger fallback on error
+                else: # RAG path chosen, but vector search is disabled or DB not available
+                    logger.warning(f"{log_prefix}: RAG path chosen, but vector search is disabled or DB failed. Falling back to text search.")
+                    final_result = "" # Trigger fallback
+
+                # Fallback within RAG path if RAG failed or produced no result
+                if not final_result:
+                    logger.info(f"{log_prefix}: Falling back to text search (RAG path failed or yielded no result).")
+                    search_method_used = "text (RAG fallback)"
+                    final_result = self._execute_text_search_and_format(original_query, search_query, num_results, llm_expansion_note, is_fallback=True)
+
+            # --- Text Search Path (Chosen by Router) ---
+            elif routing_decision == "TEXT_SEARCH":
+                search_method_used = "text (router chosen)"
+                logger.info(f"{log_prefix}: Executing text search directly based on router decision.")
+                final_result = self._execute_text_search_and_format(original_query, search_query, num_results, llm_expansion_note, is_fallback=False)
+
+            # --- Handle unexpected router decision ---
+            else:
+                 logger.error(f"{log_prefix}: Invalid router decision '{routing_decision}'. Critical error.")
+                 final_result = f"❌ Internal Error: Invalid routing decision '{routing_decision}'."
+
+            # --- Final Logging and Return ---
+            search_elapsed = time.time() - search_start
+            logger.info(f"{log_prefix}: Completed via '{search_method_used}' path in {search_elapsed:.2f}s.")
+
+            # --- MODIFICATION START ---
+            # Prepare the main response string
+            final_output_string = final_result if final_result else f"😕 No results found for \"{original_query}\"."
 
+            # Create the debug string (add extra newlines for separation)
+            # Use markdown code block for clarity
+            debug_info = f"\n\n---\n`DEBUG: Router={routing_decision}, Method={search_method_used}`"
 
+            # Append debug info to the main response
+            return final_output_string + debug_info
+            # --- MODIFICATION END ---
+
+        except Exception as e: # Catch unexpected outer errors
+            logger.exception(f"{log_prefix}: Unexpected outer error: {e}")
+            # Also add debug info to error messages if possible (or default)
+            error_debug_info = f"\n\n---\n`DEBUG: Router={routing_decision}, Method=ErrorBeforeCompletion`"
+            return f"❌ An unexpected critical error occurred: {str(e)}" + error_debug_info
+
+    # --- Helper for Text Search Execution and Formatting ---
+    def _execute_text_search_and_format(self, original_query, search_query, num_results, llm_expansion_note, is_fallback=False):
+        """
+        Helper to run text search and format results for display.
+        Includes debug info about the execution method in the returned string.
+        """
+        log_prefix = f"Search(Q='{original_query}', N={num_results})" # Re-establish prefix for logging clarity
+        logger.info(f"{log_prefix}: Executing text search logic (Fallback={is_fallback}). Query='{search_query}'")
+        if self.recipes_df is None or self.recipes_df.empty:
+            logger.error(f"{log_prefix}: Text search error: recipes_df missing.")
+            # Add debug info even to error messages if possible
+            method = "text (RAG fallback)" if is_fallback else "text (router chosen)"
+            debug_info = f"\n\n---\n`DEBUG: Method={method}`"
+            return f"❌ Error: Recipe data frame is missing." + debug_info
+
+        text_indices = self._text_search(search_query, num_results) # Use potentially expanded query
+        logger.info(f"{log_prefix}: Text search found indices: {text_indices}")
+        text_results_data = []
+        processed_indices = set()
+        for recipe_id in text_indices:
+            # Validate index before attempting iloc
+            if isinstance(recipe_id, int) and 0 <= recipe_id < len(self.recipes_df) and recipe_id not in processed_indices:
+                try:
+                    recipe_data = self.recipes_df.iloc[recipe_id]
+                    # Ensure necessary keys exist, provide defaults if not
+                    title = recipe_data.get('title', f'Recipe {recipe_id}')
+                    ingredients = str(recipe_data.get('ingredients', 'N/A'))
+                    instructions = str(recipe_data.get('instructions', 'N/A'))
+                    text_results_data.append({'title': title, 'ingredients': ingredients, 'instructions': instructions})
+                    processed_indices.add(recipe_id)
+                except Exception as df_error:
+                    logger.warning(f"Text search DF access error for index {recipe_id}: {df_error}")
+            else:
+                logger.warning(f"Invalid or already processed text index skipped: {recipe_id}")
+
+        # Determine the method string for notes and debug info
+        method = "text (RAG fallback)" if is_fallback else "text (router chosen)"
+        search_note = "(using _text search fallback_)" if is_fallback else "(using _text search_)"
+        debug_info = f"\n\n---\n`DEBUG: Method={method}`" # Debug info based on how this function was called
+
+        if text_results_data:
+            logger.info(f"{log_prefix}: Formatting {len(text_results_data)} text results.")
+            # Start formatted output
+            formatted_output = f"Found {len(text_results_data)} recipe(s) for \"**{original_query}**\"{llm_expansion_note} {search_note}:\n\n---\n\n"
+            # Loop through collected data
+            for i, recipe in enumerate(text_results_data):
+                try:
+                    title = recipe.get('title', 'Untitled Recipe') # Use data from list
+                    formatted_output += f"### {i+1}. {title}\n\n"
+                    ing = recipe.get('ingredients')
+                    inst = recipe.get('instructions')
+                    # Format ingredients if present
+                    if ing and ing != 'N/A':
+                        ing_list = [f"- {line.strip()}" for line in ing.strip().split('\n') if line.strip()]
+                        if ing_list: formatted_output += "**Ingredients:**\n" + "\n".join(ing_list) + "\n\n"
+                    # Format instructions if present
+                    if inst and inst != 'N/A':
+                        inst_list = [f"{num}. {line.strip()}" for num, line in enumerate(inst.strip().split('\n'), 1) if line.strip()]
+                        if inst_list: formatted_output += "**Instructions:**\n" + "\n".join(inst_list) + "\n\n"
+                except Exception as fmt_e:
+                    logger.warning(f"Error formatting text result #{i+1} (Title: '{recipe.get('title', 'N/A')}'): {fmt_e}")
+                    formatted_output += f"*Error formatting recipe {i+1}*\n\n" # Add error note in output
+                # Add separator between recipes
+                if i < len(text_results_data) - 1:
+                    formatted_output += "---\n\n"
+            # Append debug info before returning
+            return formatted_output.strip() + debug_info
+        else:
+            # Handle case where text search yields no results
+            logger.info(f"{log_prefix}: Text search (Fallback={is_fallback}) found 0 results after index processing.")
+            # Append debug info before returning
+            return f"😕 No recipes found matching: \"{original_query}\"." + debug_info
+
+    def _text_search(self, query, num_results=3):
+        """Performs keyword search on self.recipes_df."""
+        if self.recipes_df is None or self.recipes_df.empty: return []
+        try:
+            query_lower = query.lower()
+            # Improved keyword extraction (handles more cases)
+            query_words = set(re.findall(r'\b\w{3,}\b', query_lower))
+            if not query_words: logger.warning(f"Text Search: No valid keywords found in '{query}'."); return []
+
+            scored_recipes = []
+            # Ensure columns exist and handle potential NaN before string operations
+            titles = self.recipes_df.get('title', pd.Series(dtype=str)).fillna('').str.lower()
+            ingredients_col = self.recipes_df.get('ingredients', pd.Series(dtype=str)).fillna('').astype(str).str.lower()
+            # Consider adding instructions to search space? instructions_col = self.recipes_df.get('instructions', pd.Series(dtype=str)).fillna('').astype(str).str.lower()
+            search_texts = titles + " " + ingredients_col # Combine relevant text fields
+
+            for idx, text_content in search_texts.items():
+                score = 0
+                try:
+                    # Basic scoring logic
+                    if query_lower in text_content: score += 20 # Boost exact phrase match
+                    # Word overlap scoring
+                    text_words = set(word for word in re.findall(r'\b\w{3,}\b', text_content))
+                    score += len(query_words.intersection(text_words)) * 5 # Keyword overlap
+                    # Title overlap boost
+                    title_words = set(word for word in re.findall(r'\b\w{3,}\b', titles.get(idx, '')))
+                    score += len(query_words.intersection(title_words)) * 10 # Title keyword overlap boost
+                except Exception as score_err:
+                    # Log scoring errors but continue
+                    logger.warning(f"Scoring error for index {idx}: {score_err}", exc_info=False)
+                if score > 0: scored_recipes.append((idx, score))
+
+            # Sort by score descending
+            scored_recipes.sort(key=lambda x: x[1], reverse=True)
+            # Return top N indices
+            return [idx for idx, score in scored_recipes[:num_results]]
+        except Exception as e:
+            # Log unexpected errors during the search process
+            logger.exception(f"Unexpected error during text search for '{query}': {e}")
+            return []
+
+    @staticmethod
+    def _get_backup_recipes():
+        """ Provides a small, hardcoded list of recipes as a fallback. """
+        return [
+            {"title": "Spaghetti Carbonara", "description": "", "ingredients": "Spaghetti\nEggs\nPancetta or Guanciale\nPecorino Romano cheese\nBlack pepper", "instructions": "Cook spaghetti.\nFry pancetta.\nWhisk eggs and cheese.\nCombine pasta, pancetta fat, egg mixture off heat.\nAdd pasta water if needed.\nServe with pepper.", "rating": None},
+            {"title": "Chocolate Chip Cookies", "description": "", "ingredients": "Butter\nSugar\nBrown Sugar\nEggs\nVanilla Extract\nFlour\nBaking Soda\nSalt\nChocolate Chips", "instructions": "Cream butter and sugars.\nBeat in eggs and vanilla.\nCombine dry ingredients.\nMix wet and dry.\nStir in chocolate chips.\nDrop onto baking sheets.\nBake until golden brown.", "rating": None},
+            {"title": "Chicken Stir Fry", "description": "", "ingredients": "Chicken breast\nBroccoli\nBell peppers\nCarrots\nSoy sauce\nGinger\nGarlic\nSesame oil\nRice", "instructions": "Cut chicken and vegetables.\nStir-fry chicken until cooked.\nAdd vegetables and stir-fry until tender-crisp.\nMix sauce ingredients.\nPour sauce over stir-fry.\nServe with rice.", "rating": None},
+            {"title": "Greek Salad", "description": "", "ingredients": "Cucumber\nTomatoes\nRed onion\nKalamata olives\nFeta cheese\nOlive oil\nRed wine vinegar\nOregano", "instructions": "Chop vegetables.\nCombine vegetables and olives in a bowl.\nCrumble feta cheese over salad.\nWhisk olive oil, vinegar, and oregano for dressing.\nDrizzle dressing over salad.", "rating": None},
+            {"title": "Easy Banana Bread", "description": "", "ingredients": "Ripe bananas\nButter\nSugar\nEgg\nVanilla extract\nFlour\nBaking soda\nSalt", "instructions": "Mash bananas.\nMelt butter.\nMix melted butter, sugar, egg, and vanilla.\nCombine dry ingredients.\nMix wet and dry ingredients until just combined.\nPour into loaf pan.\nBake until a toothpick comes out clean.", "rating": None}
+        ]
+
+# ==============================================================================
+# Gradio Interface Creation (Stateful Chatbot UI - Corrected Outputs/Yields)
+# ==============================================================================
+def create_interface():
+    """Sets up and defines the Gradio web interface using a stateful gr.Chatbot."""
+    recipe_system = RecipeRecommendationSystem()
+    logger.info("Creating Gradio interface with Stateful Chatbot...")
+
+    # --- UI Helper Functions (Corrected outputs for ALL buttons/inputs) ---
+    def ui_init_system(sample_size_value, progress=gr.Progress(track_tqdm=True)):
+        logger.info(f"UI: Init clicked. Sample size: {sample_size_value}")
+        status_msg = "Initializing..."
+        # Outputs: Status, Init Btn, Reload Btn, Send Btn, Msg Input
+        # Yield status + 4 updates (for the 4 components in outputs list below)
+        yield status_msg, gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False)
+        try:
+            success = recipe_system.initialize(force_reload=False, sample_size=int(sample_size_value))
+            if success and recipe_system.is_initialized:
+                num = len(recipe_system.recipes_df) if recipe_system.recipes_df is not None else 0; db = "vector" if recipe_system.use_vector_search else "text"; llm = "active" if recipe_system.use_llm and recipe_system.lc_llm else "inactive"; status_msg = f"✅ Initialized ({num} recipes, {db} search, LLM {llm}). Ready."
+                # Enable all relevant controls -> Yield Status + 4 True updates
+                yield status_msg, gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True)
+            else:
+                status_msg = f"❌ Init failed: {recipe_system.initialization_error}. May use backups."
+                ok = recipe_system.recipes_df is not None and not recipe_system.recipes_df.empty
+                # Enable Init Btn, enable others based on fallback 'ok' -> Yield Status + 1 True + 3 'ok' updates
+                yield status_msg, gr.update(interactive=True), gr.update(interactive=ok), gr.update(interactive=ok), gr.update(interactive=ok)
+        except Exception as e:
+            logger.exception(f"UI initialization error: {e}")
+             # Enable all controls on error to allow retry -> Yield Status + 4 True updates
+            yield f"❌ UI Error: {e}", gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True)
+
+    def ui_reload_system(sample_size_value, progress=gr.Progress(track_tqdm=True)):
+        logger.info(f"UI: Reload clicked. Sample size: {sample_size_value}")
+        status_msg = "Reloading..."
+         # Outputs: Status, Init Btn, Reload Btn, Send Btn, Msg Input
+         # Yield status + 4 updates
+        yield status_msg, gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False)
+        try:
+            success = recipe_system.initialize(force_reload=True, sample_size=int(sample_size_value))
+            if success and recipe_system.is_initialized:
+                num = len(recipe_system.recipes_df) if recipe_system.recipes_df is not None else 0; db = "vector" if recipe_system.use_vector_search else "text"; llm = "active" if recipe_system.use_llm and recipe_system.lc_llm else "inactive"; status_msg = f"✅ Reloaded ({num} recipes, {db} search, LLM {llm}). Ready."
+                 # Enable all -> Yield Status + 4 True updates
+                yield status_msg, gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True)
+            else:
+                status_msg = f"❌ Reload failed: {recipe_system.initialization_error}. May use backups."
+                ok = recipe_system.recipes_df is not None and not recipe_system.recipes_df.empty
+                 # Enable Init Btn, enable others based on fallback 'ok' -> Yield Status + 1 True + 3 'ok' updates
+                yield status_msg, gr.update(interactive=True), gr.update(interactive=ok), gr.update(interactive=ok), gr.update(interactive=ok)
+        except Exception as e:
+            logger.exception(f"UI reload error: {e}")
+              # Enable all controls on error -> Yield Status + 4 True updates
+            yield f"❌ UI Error: {e}", gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True)
+
+    # --- Stateful Chat Interaction Function (Includes fix for ValidationError) ---
+    def respond(message, chat_history_list, num_results_value):
+        """
+        Handles user message, appends to history, calls backend, updates history.
+        Uses 'messages' format (list of dicts with 'role' and 'content').
+        Uses '...' as placeholder instead of None for content.
+        """
+        logger.info(f"UI Chat: Msg='{message}', History Len={len(chat_history_list)}, N={num_results_value}")
+
+        # Input Validation & Initialization Check
+        if not message or not message.strip():
+            logger.warning("Respond function called with empty message.")
+            chat_history_list.append({"role": "user", "content": message})
+            chat_history_list.append({"role": "assistant", "content": "⚠️ Please enter a message."})
+            return chat_history_list, gr.update(value="") # Return history and clear update
+
+        if not recipe_system.is_initialized and (recipe_system.recipes_df is None or recipe_system.recipes_df.empty):
+            logger.warning("Respond function called but system not initialized.")
+            chat_history_list.append({"role": "user", "content": message})
+            chat_history_list.append({"role": "assistant", "content": "⚠️ System not initialized or no data loaded. Please Initialize/Reload."})
+            return chat_history_list, gr.update(value="") # Return history and clear update
+
+        # Append user message and placeholder for bot - yield for immediate display
+        chat_history_list.append({"role": "user", "content": message})
+        chat_history_list.append({"role": "assistant", "content": "..."}) # Placeholder
+        # Yield history to display user message & placeholder, yield empty string "" to clear input
+        yield chat_history_list, ""
+
+        # Call Backend
+        bot_response_content = "Error generating response." # Default
+        try:
+            logger.info("Calling recipe_system.search_recipes...")
+            bot_response_content = recipe_system.search_recipes(message, int(num_results_value))
+            if not bot_response_content: # Handle empty returns
+                bot_response_content = "😕 No specific information found."
+            logger.info("Backend search successful.")
+        except Exception as e:
+            logger.exception(f"Error during backend search call from chat: {e}")
+            bot_response_content = f"❌ Error calling backend: {e}"
+
+        # Update the placeholder in history with the actual response
+        chat_history_list[-1]["content"] = bot_response_content
+
+        # Yield final history state (input box already cleared)
+        yield chat_history_list, ""
+
+    # --- UI Layout ---
+    with gr.Blocks(
+        title="Recipe Chat Agent",
+        theme=gr.themes.Soft(primary_hue=gr.themes.colors.amber, secondary_hue=gr.themes.colors.lime),
+        css=".gradio-container {max-width: 800px !important}"
+    ) as demo:
+        gr.Markdown("# 🍲 Recipe Chat Agent 🎉")
+        gr.Markdown("### Ask questions or search for recipes conversationally!")
+
+        # Define ALL UI Components FIRST
+        with gr.Row():
+            with gr.Column(scale=1):
+                status_display = gr.Textbox("Status: Not initialized.", label="System Status", interactive=False, lines=2)
+            with gr.Column(scale=2):
+                with gr.Accordion("⚙️ Settings & Initialization", open=False):
+                    sample_slider = gr.Slider(minimum=100, maximum=5000, value=1000, step=100, label="Recipes to Load/Sample", info="Affects init time/memory.")
+                    results_slider = gr.Slider(minimum=1, maximum=5, value=3, step=1, label="# Results/Context Docs", info="For RAG context or # Text Results")
+                    with gr.Row():
+                        init_button = gr.Button("🚀 Initialize System", variant="secondary", size="sm") # Interactive state set by load
+                        reload_button = gr.Button("🔄 Reload Data", variant="stop", size="sm") # Interactive state set by load
+
+        with gr.Group(visible=True) as chat_interface_group: # Keep visible
+            chatbot = gr.Chatbot(label="Conversation", bubble_full_width=False, height=500, type='messages') # Use 'messages' type
+            chat_history = gr.State([]) # Initialize state for history list
+            with gr.Row():
+                msg_input = gr.Textbox(label="Your Message:", placeholder="Type your message here...", lines=1, scale=4, container=False) # Interactive state set by load
+                send_button = gr.Button("✉️ Send", variant="primary", scale=1, min_width=100) # Interactive state set by load
+            gr.Examples(
+                examples=[
+                    ["easy weeknight dinner"], ["healthy vegetarian soup"],
+                    ["how long does the banana bread take to bake?"],
+                    ["does the carbonara recipe use cream?"], ["супа со печурки"],
+                    ["find recipes with feta and olives"]
+                ],
+                inputs=msg_input, label="Example Messages"
+            )
+
+        # --- Define ALL Event Listeners AFTER components ---
+        init_button.click(
+            fn=ui_init_system,
+            inputs=[sample_slider],
+            # Outputs: Status, Init Btn, Reload Btn, Send Btn, Msg Input (5 total)
+            outputs=[status_display, init_button, reload_button, send_button, msg_input] # CORRECTED
+        )
+        reload_button.click(
+            fn=ui_reload_system,
+            inputs=[sample_slider],
+            # Outputs: Status, Init Btn, Reload Btn, Send Btn, Msg Input (5 total)
+            outputs=[status_display, init_button, reload_button, send_button, msg_input] # CORRECTED
+        )
+
+        # Connect chat interactions
+        send_button.click(
+            fn=respond,
+            inputs=[msg_input, chat_history, results_slider],
+            outputs=[chatbot, msg_input] # Respond updates chatbot and clears input
+        )
+        msg_input.submit(
+            fn=respond,
+            inputs=[msg_input, chat_history, results_slider],
+            outputs=[chatbot, msg_input] # Respond updates chatbot and clears input
+        )
+
+        # Initial setup on load: Enable ONLY init_button
+        def setup_load_state():
+           # Return updates for: Init, Reload, Send, MsgInput (4 total)
+           # Enable Init, disable others
+           return gr.update(interactive=True), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False) # CORRECTED
+        demo.load(
+            fn=setup_load_state, inputs=None,
+            # Components to update: Init, Reload, Send, MsgInput (4 total)
+            outputs=[init_button, reload_button, send_button, msg_input] # CORRECTED
+        )
+
+    logger.info("Gradio Interface definition complete.")
+    return demo
+
+# ==============================================================================
+# Main Execution Block (Keep as before)
+# ==============================================================================
+# ... (rest of the script including if __name__ == "__main__":) ...
+
+    # --- UI Layout ---
+    with gr.Blocks(
+        title="Recipe Chat Agent",
+        theme=gr.themes.Soft(primary_hue=gr.themes.colors.amber, secondary_hue=gr.themes.colors.lime),
+        css=".gradio-container {max-width: 800px !important}"
+    ) as demo:
+        gr.Markdown("# 🍲 Recipe Chat Agent 🎉")
+        gr.Markdown("### Ask questions or search for recipes conversationally!")
+
+        # Define ALL UI Components FIRST
+        with gr.Row():
+            with gr.Column(scale=1):
+                status_display = gr.Textbox("Status: Not initialized.", label="System Status", interactive=False, lines=2)
+            with gr.Column(scale=2):
+                with gr.Accordion("⚙️ Settings & Initialization", open=False):
+                    sample_slider = gr.Slider(minimum=100, maximum=5000, value=1000, step=100, label="Recipes to Load/Sample", info="Affects init time/memory.")
+                    results_slider = gr.Slider(minimum=1, maximum=5, value=3, step=1, label="# Results/Context Docs", info="For RAG context or # Text Results")
+                    with gr.Row():
+                        init_button = gr.Button("🚀 Initialize System", variant="secondary", size="sm") # Interactive state set by load
+                        reload_button = gr.Button("🔄 Reload Data", variant="stop", size="sm") # Interactive state set by load
+
+        with gr.Group(visible=True) as chat_interface_group: # Keep visible
+            chatbot = gr.Chatbot(label="Conversation", height=500, type='messages') # Use 'messages' type
+            chat_history = gr.State([]) # Initialize state for history list
+            with gr.Row():
+                msg_input = gr.Textbox(label="Your Message:", placeholder="Type your message here...", lines=1, scale=4, container=False) # Interactive state set by load
+                send_button = gr.Button("✉️ Send", variant="primary", scale=1, min_width=100) # Interactive state set by load
+            gr.Examples(
+                examples=[
+                    ["easy weeknight dinner"], ["healthy vegetarian soup"],
+                    ["how long does the banana bread take to bake?"],
+                    ["does the carbonara recipe use cream?"], ["супа со печурки"],
+                    ["find recipes with feta and olives"]
+                ],
+                inputs=msg_input, label="Example Messages"
+            )
+
+        # --- Define ALL Event Listeners AFTER components ---
+        init_button.click(
+            fn=ui_init_system,
+            inputs=[sample_slider],
+            outputs=[status_display, init_button, reload_button, send_button, msg_input]
+        )
+        reload_button.click(
+            fn=ui_reload_system,
+            inputs=[sample_slider],
+            outputs=[status_display, init_button, reload_button, send_button, msg_input]
+        )
+
+        # Connect chat interactions
+        # Use .then() to clear input AFTER respond finishes and updates chatbot
+        # Clears input textbox
+        clear_input = msg_input.submit(
+            fn=respond,
+            inputs=[msg_input, chat_history, results_slider],
+            outputs=[chatbot, msg_input] # Respond updates chatbot and clears input
+        )
+         # Send button also uses respond and clears input
+        send_button.click(
+            fn=respond,
+            inputs=[msg_input, chat_history, results_slider],
+            outputs=[chatbot, msg_input] # Respond updates chatbot and clears input
+        )
+
+
+        # Initial setup on load: Enable ONLY init_button
+        def setup_load_state():
+           # Return updates for: Init, Reload, Send, MsgInput
+           return gr.update(interactive=True), gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False)
+        demo.load(
+            fn=setup_load_state, inputs=None,
+            outputs=[init_button, reload_button, send_button, msg_input]
+        )
+
+    logger.info("Gradio Interface definition complete.")
+    return demo
+
+# ==============================================================================
+# Main Execution Block
+# ==============================================================================
 if __name__ == "__main__":
-    demo.launch()
+    logger.info("Application starting...")
+    if not LANGCHAIN_LLM_AVAILABLE: logger.warning("!"*20 + "\nLangChain LLM (Gemini) setup INCOMPLETE...\n" + "!"*20)
+    else: logger.info("LangChain LLM dependencies and API key found.")
+    if not VECTOR_IMPORTS_AVAILABLE: logger.warning("!"*20 + "\nVector search dependencies NOT FOUND...\n" + "!"*20)
+    else: logger.info("Vector search dependencies found.")
+
+    logger.info("Creating Gradio interface...")
+    interface = create_interface()
+
+    logger.info("Launching Gradio interface...")
+    interface.launch(share=False) # Share=False for local testing
+
+    logger.info("Gradio interface closed.")

evaluation.py

@@ -0,0 +1,333 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+import time
+import logging
+from gradio_client import Client
+from sklearn.metrics import (
+    accuracy_score,
+    confusion_matrix,
+    classification_report,
+    precision_recall_fscore_support
+)
+import pandas as pd # Optional: if loading data from file
+
+# --- Configuration ---
+# Option 1: Hardcode your Space ID/URL
+# SPACE_ID = "your-username/your-space-name"
+# Option 2: Get from environment variable (useful if running script ON the space or elsewhere with env set)
+SPACE_ID = "rkostov/thesis-agent" # Add a default placeholder
+# Option 3: Use full URL if needed
+# SPACE_URL = "https://your-username-your-space-name.hf.space"
+
+API_NAME = "/respond" # From view_api output
+NUM_RESULTS = 3 # Default value for the slider input
+SLEEP_BETWEEN_CALLS = 1 # Seconds to wait to avoid rate limiting
+
+# --- Logging Setup ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger('evaluation_script')
+
+# --- Benchmark Dataset ---
+# Full list of ~100 queries with intended routing targets
+# You can modify/expand this list or load from a file (CSV/JSON)
+benchmark_data = [
+    # === RAG - Specific Questions ===
+    # Ingredients & Quantities
+    {'query': 'Does spaghetti carbonara use cream?', 'intended_target': 'RAG'},
+    {'query': 'What kind of cheese is in the Greek Salad recipe?', 'intended_target': 'RAG'},
+    {'query': 'Is there onion in the banana bread?', 'intended_target': 'RAG'},
+    {'query': 'List ingredients for chocolate chip cookies.', 'intended_target': 'RAG'},
+    {'query': 'How much butter for the chocolate chip cookies?', 'intended_target': 'RAG'},
+    {'query': 'Does the stir fry recipe contain peanuts?', 'intended_target': 'RAG'},
+    {'query': 'What oil is recommended for the stir fry?', 'intended_target': 'RAG'},
+    {'query': 'Are eggs required for the carbonara?', 'intended_target': 'RAG'},
+    {'query': 'Tell me the spices in the default chicken recipe.', 'intended_target': 'RAG'},
+    {'query': 'Any garlic in the greek salad?', 'intended_target': 'RAG'},
+    {'query': 'What type of flour is used in the banana bread?', 'intended_target': 'RAG'},
+    {'query': 'How many eggs in the carbonara?', 'intended_target': 'RAG'},
+    {'query': 'Does the banana bread use baking soda or baking powder?', 'intended_target': 'RAG'},
+    {'query': 'Are fresh tomatoes needed for the greek salad?', 'intended_target': 'RAG'},
+    {'query': 'What cut of chicken for the stir fry?', 'intended_target': 'RAG'},
+    # Instructions & Timing
+    {'query': 'How long do I bake the chocolate chip cookies?', 'intended_target': 'RAG'},
+    {'query': 'What temperature to bake cookies?', 'intended_target': 'RAG'},
+    {'query': 'What is the first step for the chicken stir fry?', 'intended_target': 'RAG'},
+    {'query': 'How do you make the dressing for the Greek Salad?', 'intended_target': 'RAG'},
+    {'query': 'Tell me how to cook spaghetti carbonara.', 'intended_target': 'RAG'},
+    {'query': 'Summarize the banana bread instructions.', 'intended_target': 'RAG'},
+    {'query': 'How many steps are there to make the cookies?', 'intended_target': 'RAG'},
+    {'query': 'What do I do after frying the pancetta in carbonara?', 'intended_target': 'RAG'},
+    {'query': 'How should I prepare the vegetables for the stir fry?', 'intended_target': 'RAG'},
+    {'query': "What's the final step for the Greek salad?", 'intended_target': 'RAG'},
+    {'query': 'How long does the banana bread need to cool?', 'intended_target': 'RAG'},
+    {'query': 'At what point are the chocolate chips added?', 'intended_target': 'RAG'},
+    {'query': 'How long to cook the chicken in the stir fry?', 'intended_target': 'RAG'},
+    {'query': 'When is the pasta water used in carbonara?', 'intended_target': 'RAG'},
+    {'query': 'Should the feta be crumbled or cubed for the salad?', 'intended_target': 'RAG'},
+    # Properties/Suitability
+    {'query': 'Is the Greek Salad vegetarian?', 'intended_target': 'RAG'},
+    {'query': 'Are the chocolate chip cookies gluten-free?', 'intended_target': 'RAG'},
+    {'query': 'Is the banana bread recipe vegan?', 'intended_target': 'RAG'},
+    {'query': 'Can the carbonara be made ahead of time?', 'intended_target': 'RAG'},
+    {'query': 'Is the chicken stir fry spicy?', 'intended_target': 'RAG'},
+    {'query': 'Approximate prep time for banana bread?', 'intended_target': 'RAG'},
+    {'query': 'Which of the backup recipes are vegetarian?', 'intended_target': 'RAG'},
+    {'query': 'Difficulty level of the carbonara?', 'intended_target': 'RAG'},
+    {'query': 'Does the cookie recipe yield many cookies?', 'intended_target': 'RAG'},
+    {'query': 'Is the stir fry low-carb?', 'intended_target': 'RAG'},
+    # Technique/Tools
+    {'query': 'How do I cream butter and sugar?', 'intended_target': 'RAG'},
+    {'query': "What does 'fold in' mean for the banana bread?", 'intended_target': 'RAG'},
+    {'query': 'What pan size for the banana bread?', 'intended_target': 'RAG'},
+    {'query': 'Do I need a whisk for the carbonara?', 'intended_target': 'RAG'},
+    {'query': "What does 'tender-crisp' mean for stir fry vegetables?", 'intended_target': 'RAG'},
+    {'query': 'How to mash bananas properly?', 'intended_target': 'RAG'},
+    {'query': 'What kind of pan for stir fry?', 'intended_target': 'RAG'},
+    {'query': 'How to chop an onion for the salad?', 'intended_target': 'RAG'},
+    {'query': "What does 'al dente' mean for spaghetti?", 'intended_target': 'RAG'},
+    {'query': 'Why mix wet and dry ingredients separately for cookies?', 'intended_target': 'RAG'},
+
+    # === Text Search - General Queries ===
+    # Recipe Name
+    {'query': 'Spaghetti Carbonara', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Easy Banana Bread', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Chicken Stir Fry', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Greek Salad', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Chocolate Chip Cookies', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Recipe for carbonara', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Show me banana bread', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'cookies', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'salad', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'pasta', 'intended_target': 'TEXT_SEARCH'},
+    # Main Ingredient(s)
+    {'query': 'recipes with chicken breast', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'broccoli soup', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'something with eggs and pancetta', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Find recipes using feta cheese.', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'pasta with eggs', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'banana recipes', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'cookies with chocolate', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'salad with olives', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'dinner with chicken', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'recipes using ripe bananas', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'find recipes with bell peppers', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Pecorino Romano recipes', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'What can I make with butter and sugar?', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Search for recipes with cucumber', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Got extra eggs, what can I make?', 'intended_target': 'TEXT_SEARCH'},
+    # Meal Type/Descriptor
+    {'query': 'quick weeknight dinner', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'healthy dessert', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'vegetarian main course', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'party appetizer', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'easy baking recipes', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'low carb meals', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'comfort food', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'salad recipes', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'budget friendly ideas', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'simple lunch', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'italian pasta', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'something sweet', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'savory dishes', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'recipes for beginners', 'intended_target': 'TEXT_SEARCH'},
+    {'query': '30 minute meals', 'intended_target': 'TEXT_SEARCH'},
+
+    # === Ambiguous Queries (Assigning a default target for evaluation) ===
+    {'query': 'ingredients for healthy vegetarian soup', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'how to make vegetarian lasagna', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'best chocolate chip cookie recipe', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'carbonara no cream', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'information about banana bread', 'intended_target': 'RAG'},
+    {'query': 'Greek salad dressing instructions', 'intended_target': 'RAG'},
+    {'query': 'quick vegetarian pasta', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'tell me about stir fry', 'intended_target': 'RAG'},
+    {'query': 'carbonara recipe details', 'intended_target': 'RAG'},
+    {'query': 'cookie variations', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Can you find a low-sugar banana bread?', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'What are some salads with cucumber?', 'intended_target': 'TEXT_SEARCH'},
+    {'query': 'Talk me through the carbonara recipe', 'intended_target': 'RAG'},
+    {'query': 'Nutritional info for cookies', 'intended_target': 'RAG'}, # RAG likely to fail gracefully
+    {'query': 'Compare carbonara and stir fry', 'intended_target': 'RAG'}, # RAG likely to fail gracefully
+
+    # === Edge Cases ===
+    {'query': 'choclate chip cookis', 'intended_target': 'TEXT_SEARCH'}, # Misspelling
+    {'query': 'soup', 'intended_target': 'TEXT_SEARCH'}, # Broad
+    {'query': 'Does any recipe use saffron?', 'intended_target': 'RAG'}, # Likely Out of Scope Ingredient
+    {'query': 'asdfghjkl', 'intended_target': 'TEXT_SEARCH'}, # Nonsense
+    {'query': 'tell me a joke about cooking', 'intended_target': 'RAG'} # Out of scope Topic
+]
+# --- End Benchmark Dataset ---
+
+
+# --- Helper function to extract routing decision ---
+def extract_routing_decision(response_content):
+    if not isinstance(response_content, str):
+        return "PARSE_ERROR" # Handle non-string content
+    # Pattern to find Router=VALUE within the debug string `DEBUG: Router=VALUE,...`
+    pattern = r"Router=([^,`]+)"
+    match = re.search(pattern, response_content)
+    if match:
+        decision = match.group(1).strip()
+        if decision in ["RAG", "TEXT_SEARCH"]:
+            return decision
+        else:
+            logger.warning(f"Parsed unexpected decision value: {decision}")
+            return "PARSE_ERROR" # Unexpected value
+    else:
+        # Check if Method= only is present (e.g. from text search helper)
+        method_pattern = r"Method=([^`]+)"
+        method_match = re.search(method_pattern, response_content)
+        if method_match:
+            method_used = method_match.group(1).strip()
+            # Infer routing based on method if Router= missing
+            if "text (router chosen)" in method_used:
+                 logger.warning("Router= missing, inferred TEXT_SEARCH from method.")
+                 return "TEXT_SEARCH"
+            elif "text (RAG fallback)" in method_used:
+                 logger.warning("Router= missing, inferred RAG (fallback) from method.")
+                 return "RAG" # It was intended RAG, even if it failed
+            elif "vector (RAG executed)" in method_used:
+                 logger.warning("Router= missing, inferred RAG from method.")
+                 return "RAG"
+        logger.warning(f"Could not parse routing decision or infer from method in response.")
+        return "PARSE_ERROR" # Pattern not found
+
+
+# --- Main Evaluation Logic ---
+if not SPACE_ID:
+    logger.error("Error: SPACE_ID not configured. Set the environment variable or hardcode it.")
+    exit()
+
+logger.info(f"Connecting to Gradio Space: {SPACE_ID}")
+try:
+    # Increase timeout if needed client = Client(SPACE_ID, hf_token=...)
+    client = Client(SPACE_ID)
+    logger.info("Connection successful.")
+except Exception as e:
+    logger.error(f"Failed to connect to Gradio Space: {e}")
+    exit()
+
+# Lists to store labels and predictions
+y_true = [] # Your manual labels ('intended_target')
+y_pred = [] # Agent's actual routing decisions
+
+logger.info(f"Starting evaluation for {len(benchmark_data)} queries...")
+
+for i, item in enumerate(benchmark_data):
+    query = item['query']
+    intended_target = item['intended_target']
+    logger.info(f"Processing query {i+1}/{len(benchmark_data)}: '{query}' (Expected: {intended_target})")
+
+    actual_decision = "API_ERROR" # Default if API call fails
+
+    try:
+        # Make the API call (stateless) - Requires API to accept only message & num_results
+        result = client.predict(
+            message=query,
+            num_results_value=NUM_RESULTS,
+            api_name=API_NAME # Use "/respond"
+            # No chat_history argument here due to API bug
+        )
+
+        # Process the result
+        # Expected result (based on corrected respond): tuple (chat_history_list, "")
+        if isinstance(result, tuple) and len(result) == 2 and isinstance(result[0], list) and result[0]:
+             # Get the last message added (should be the assistant's response)
+             last_message = result[0][-1]
+             if isinstance(last_message, dict) and last_message.get("role") == "assistant":
+                 bot_content = last_message.get("content")
+                 actual_decision = extract_routing_decision(bot_content) # Parse debug info
+             else:
+                 logger.warning(f"Unexpected structure in last message: {last_message}")
+                 actual_decision = "PARSE_ERROR"
+        elif result is None:
+             logger.error(f"API call for query '{query}' returned None.")
+             actual_decision = "API_NONE_RETURN"
+        else:
+             logger.warning(f"Unexpected API result structure: {type(result)} | Content: {result}")
+             actual_decision = "API_STRUCT_ERROR"
+
+    except Exception as e:
+        logger.error(f"API call failed for query '{query}': {e}")
+        actual_decision = "API_ERROR"
+
+    # Append results, ensuring labels are consistent
+    y_true.append(intended_target)
+    y_pred.append(actual_decision)
+
+    logger.info(f" -> Actual Decision: {actual_decision}")
+
+    # Wait briefly to avoid hitting potential rate limits on free Spaces
+    time.sleep(SLEEP_BETWEEN_CALLS)
+
+logger.info("Evaluation loop finished.")
+
+# --- Calculate and Print Metrics ---
+logger.info("\n--- Evaluation Results ---")
+
+# Define the valid labels we expect the parser to return
+valid_labels = ['RAG', 'TEXT_SEARCH']
+filtered_y_true = []
+filtered_y_pred = []
+# Tally errors
+error_codes = ["API_ERROR", "PARSE_ERROR", "API_STRUCT_ERROR", "API_NONE_RETURN"]
+error_counts = {code: 0 for code in error_codes}
+unknown_preds = []
+
+for true_label, pred_label in zip(y_true, y_pred):
+    if pred_label in valid_labels:
+        filtered_y_true.append(true_label)
+        filtered_y_pred.append(pred_label)
+    elif pred_label in error_counts:
+        error_counts[pred_label] += 1
+    else: # Catch any unexpected prediction labels
+         logger.error(f"Encountered unexpected predicted label: {pred_label} for true label: {true_label}")
+         unknown_preds.append(pred_label)
+
+
+total_processed = len(filtered_y_true)
+total_errors = sum(error_counts.values())
+logger.info(f"Total Queries Run: {len(benchmark_data)}")
+logger.info(f"Successfully Parsed Predictions: {total_processed}")
+logger.info(f"API/Parse Errors: {total_errors}")
+for code, count in error_counts.items():
+    if count > 0: logger.info(f"  - {code}: {count}")
+if unknown_preds: logger.warning(f"Unknown predicted labels encountered: {set(unknown_preds)}")
+
+
+if total_processed > 0:
+    # Overall Accuracy
+    accuracy = accuracy_score(filtered_y_true, filtered_y_pred)
+    logger.info(f"\nOverall Routing Accuracy (on {total_processed} successful predictions): {accuracy:.2%}")
+
+    # Confusion Matrix
+    logger.info("\nConfusion Matrix (Rows: Actual/Intended, Columns: Predicted by Agent):")
+    # Ensure consistent labeling for the matrix
+    cm = confusion_matrix(filtered_y_true, filtered_y_pred, labels=valid_labels)
+    logger.info(f"Labels: {valid_labels}")
+    # Print matrix with labels
+    cm_df = pd.DataFrame(cm, index=[f'Actual_{l}' for l in valid_labels], columns=[f'Predicted_{l}' for l in valid_labels])
+    logger.info(f"\n{cm_df}\n")
+    # Explanation (assuming RAG=0, TEXT_SEARCH=1) -> Use labels instead
+    logger.info(f"TN (Actual RAG, Predicted RAG):                 {cm[0][0]}")
+    logger.info(f"FP (Actual RAG, Predicted TEXT_SEARCH):         {cm[0][1]}")
+    logger.info(f"FN (Actual TEXT_SEARCH, Predicted RAG):         {cm[1][0]}")
+    logger.info(f"TP (Actual TEXT_SEARCH, Predicted TEXT_SEARCH): {cm[1][1]}")
+
+
+    # Classification Report (Precision, Recall, F1 per class)
+    logger.info("\nClassification Report:")
+    # Use dict output for easier logging if needed, default string is fine too
+    report = classification_report(
+        filtered_y_true,
+        filtered_y_pred,
+        labels=valid_labels,
+        target_names=valid_labels,
+        zero_division=0 # Report 0 instead of warning for classes with no support/predictions
+    )
+    logger.info(f"\n{report}")
+else:
+    logger.warning("No successful predictions were parsed, cannot calculate metrics.")
+
+logger.info("--- Evaluation Complete ---")

requirements.txt

@@ -1 +1,29 @@
-huggingface_hub==0.25.2
+# requirements.txt - Reflecting original constraints before updates
+
+langchain>=0.1.0,<0.4.0
+langchain-community>=0.0.1,<0.4.0
+langchain-huggingface>=0.0.1,<0.2.0
+nltk>=3.8.1
+pandas>=2.0.0,<3.0.0
+requests>=2.31.0
+gradio==5.23.2         # Note: Recommend latest 4.x like 4.31.0 if available within this range
+chromadb>=0.4.17,<0.7.0
+sentence-transformers>=2.2.2
+transformers>=4.35.0
+torch>=2.0.0
+numpy>=1.24.0
+scikit-learn>=1.3.0
+tqdm>=4.66.1
+pyyaml>=6.0.1
+python-dotenv>=1.0.0
+fastapi>=0.104.0
+uvicorn[standard]>=0.23.2      # Added [standard] for common extras
+datasets>=2.14.0               # Hugging Face datasets library
+huggingface_hub>=0.19.0
+pyarrow                       # No specific version constraint provided initially
+sentencepiece                 # No specific version constraint provided initially
+google-generativeai           # No specific version constraint provided initially
+langchain-google-genai>=0.0.9
+
+# Note: Pip will install the latest versions compatible with these constraints.
+# Using this list might avoid some dependency conflicts compared to using all absolute latest versions.