Upload 13 files

app.py

@@ -565,14 +565,24 @@ def render_chat_interface():
                 # Show metadata for assistant messages
                 if msg["role"] == "assistant" and "metadata" in msg:
                     meta = msg["metadata"]
+                    
+                    # Show token usage in a box
+                    if "token_usage" in meta:
+                        usage = meta["token_usage"]
+                        st.info(f"📊 **Token Usage**: Input: {usage.get('input', 0)} | Output: {usage.get('output', 0)} | Total: {usage.get('total', 0)}")
+                    
                     if meta.get("query_type"):
                         st.caption(f"Query type: {meta['query_type']}")
+                        
+                    # SQL Query expander
                     if meta.get("sql_query"):
-                        with st.expander("SQL Query"):
+                        with st.expander("🛠️ SQL Query & Details"):
                             st.code(meta["sql_query"], language="sql")
-                    
+                            
+                    # Visualizations
                     if meta.get("sql_results"):
-                        render_visualization(meta["sql_results"], f"hist_{i}")
+                        # Only render viz if we have results
+                        render_visualization(meta["sql_results"], f"viz_{i}")
     
     # Chat input
     if prompt := st.chat_input("Ask about your data..."):
@@ -582,35 +592,49 @@ def render_chat_interface():
         
         # Add user message
         st.session_state.messages.append({"role": "user", "content": prompt})
-        if st.session_state.memory:
-            st.session_state.memory.add_message("user", prompt)
         
-        # Display user message immediately
+        # Calculate memory context for display? No, just render user msg
         with st.chat_message("user"):
             st.markdown(prompt)
         
         # Get response
         with st.spinner("Thinking..."):
-            response = st.session_state.chatbot.chat(
-                prompt, 
-                st.session_state.memory,
-                ignored_tables=list(st.session_state.ignored_tables)
-            )
-            
-            # Save to memory
-            st.session_state.messages.append({
-                "role": "assistant",
-                "content": response.answer,
-                "metadata": {
+            try:
+                # Add memory interaction
+                if st.session_state.memory:
+                    st.session_state.memory.add_message("user", prompt)
+                
+                response = st.session_state.chatbot.chat(
+                    prompt, 
+                    st.session_state.memory,
+                    ignored_tables=list(st.session_state.ignored_tables)
+                )
+                
+                # Create metadata dict
+                metadata = {
                     "query_type": response.query_type,
                     "sql_query": response.sql_query,
-                    "sql_results": response.sql_results
+                    "sql_results": response.sql_results,
+                    "token_usage": response.token_usage
                 }
-            })
-            if st.session_state.memory:
-                st.session_state.memory.add_message("assistant", response.answer)
-            
-            st.rerun()
+                
+                # Save to session state
+                st.session_state.messages.append({
+                    "role": "assistant",
+                    "content": response.answer,
+                    "metadata": metadata
+                })
+                
+                # Save to active memory
+                if st.session_state.memory:
+                    st.session_state.memory.add_message("assistant", response.answer)
+                
+                st.rerun()
+                
+            except Exception as e:
+                st.error(f"An error occurred: {e}")
+                import traceback
+                st.error(traceback.format_exc())
 
 
 def main():

chatbot.py

@@ -32,10 +32,13 @@ class ChatResponse:
     sql_query: Optional[str] = None
     sql_results: Optional[List[Dict]] = None
     error: Optional[str] = None
+    token_usage: Optional[Dict[str, int]] = None
     
     def __post_init__(self):
         if self.sources is None:
             self.sources = []
+        if self.token_usage is None:
+            self.token_usage = {"input": 0, "output": 0, "total": 0}
 
 
 class DatabaseChatbot:
@@ -62,6 +65,8 @@ INTERACTION GUIDELINES:
   Example: "Here are the top 5 products... Would you like to see the top 10?"
 - If the user's question was broad (e.g., "Show me products") and you're showing a limited set, ASK if they want to filter by a specific attribute (e.g., "Would you like to filter by category or price?").
 - If the answer is "0 results" for a "top/best" query, suggest looking at the data generally.
+- IF SUBJECTIVE INFERENCE WAS USED (e.g., inferred "summer" = sandals), EXPLAIN THIS to the user.
+  Example: "I found these products that match 'summer' (based on being Sandals or breathability)..."
 
 YOUR RESPONSE:"""
 
@@ -284,27 +289,42 @@ YOUR RESPONSE:"""
             prompt
         )
         
-        answer = self.llm_client.chat(messages)
+        response = self.llm_client.chat(messages)
         
-        return ChatResponse(answer=answer, query_type="rag",
-                          sources=[{"type": "semantic_search", "context": context[:500]}])
+        usage = {
+            "input": response.input_tokens,
+            "output": response.output_tokens,
+            "total": response.total_tokens
+        }
+        
+        return ChatResponse(answer=response.content, query_type="rag",
+                          sources=[{"type": "semantic_search", "context": context[:500]}],
+                          token_usage=usage)
     
     def _handle_sql(self, query: str, schema_context: str, history: List[Dict], allowed_tables: Optional[List[str]] = None) -> ChatResponse:
         """Handle SQL-based query."""
-        sql, explanation = self.sql_generator.generate(query, schema_context, history)
+        sql, gen_response = self.sql_generator.generate(query, schema_context, history)
+        
+        # Initial usage from SQL generation
+        total_usage = {
+            "input": gen_response.input_tokens,
+            "output": gen_response.output_tokens,
+            "total": gen_response.total_tokens
+        }
         
         # Validate SQL
         is_valid, msg, sanitized_sql = self.sql_validator.validate(sql)
         if not is_valid:
             return ChatResponse(answer=f"Could not generate safe query: {msg}",
-                              query_type="sql", error=msg)
+                              query_type="sql", error=msg, token_usage=total_usage)
         
         # Execute query
         try:
             results = self.db.execute_query(sanitized_sql)
         except Exception as e:
             return ChatResponse(answer=f"Query execution failed: {e}",
-                              query_type="sql", sql_query=sanitized_sql, error=str(e))
+                              query_type="sql", sql_query=sanitized_sql, error=str(e),
+                              token_usage=total_usage)
         
         # SMART FALLBACK: If SQL returns nothing, it might be a semantic issue (e.g. wrong column)
         # We try RAG as a fallback if SQL found nothing
@@ -316,6 +336,15 @@ YOUR RESPONSE:"""
             rag_response.answer = f"I couldn't find a direct match using a database query, but here is what I found in the product descriptions:\n\n{rag_response.answer}"
             rag_response.query_type = "hybrid_fallback"
             rag_response.sql_query = sanitized_sql
+            
+            # Add usage from SQL gen to RAG usage
+            if rag_response.token_usage:
+                rag_response.token_usage["input"] += total_usage["input"]
+                rag_response.token_usage["output"] += total_usage["output"]
+                rag_response.token_usage["total"] += total_usage["total"]
+            else:
+                rag_response.token_usage = total_usage
+            
             return rag_response
 
         # Generate response
@@ -328,10 +357,16 @@ YOUR RESPONSE:"""
             prompt
         )
         
-        answer = self.llm_client.chat(messages)
+        final_response = self.llm_client.chat(messages)
+        
+        # Add usage from final response
+        total_usage["input"] += final_response.input_tokens
+        total_usage["output"] += final_response.output_tokens
+        total_usage["total"] += final_response.total_tokens
         
-        return ChatResponse(answer=answer, query_type="sql",
-                          sql_query=sanitized_sql, sql_results=results[:10])
+        return ChatResponse(answer=final_response.content, query_type="sql",
+                          sql_query=sanitized_sql, sql_results=results[:10],
+                          token_usage=total_usage)
     
     def _handle_hybrid(self, query: str, schema_context: str, history: List[Dict], allowed_tables: Optional[List[str]] = None) -> ChatResponse:
         """Handle hybrid RAG + SQL query."""
@@ -341,8 +376,17 @@ YOUR RESPONSE:"""
         # Try SQL as well
         sql_context = ""
         sql_query = None
+        
+        total_usage = {"input": 0, "output": 0, "total": 0}
+        
         try:
-            sql, _ = self.sql_generator.generate(query, schema_context, history)
+            sql, gen_response = self.sql_generator.generate(query, schema_context, history)
+            
+            # Accumulate usage
+            total_usage["input"] += gen_response.input_tokens
+            total_usage["output"] += gen_response.output_tokens
+            total_usage["total"] += gen_response.total_tokens
+            
             is_valid, _, sanitized_sql = self.sql_validator.validate(sql)
             if is_valid:
                 results = self.db.execute_query(sanitized_sql)
@@ -360,9 +404,14 @@ YOUR RESPONSE:"""
             prompt
         )
         
-        answer = self.llm_client.chat(messages)
+        final_response = self.llm_client.chat(messages)
         
-        return ChatResponse(answer=answer, query_type="hybrid", sql_query=sql_query)
+        # Add final usage
+        total_usage["input"] += final_response.input_tokens
+        total_usage["output"] += final_response.output_tokens
+        total_usage["total"] += final_response.total_tokens
+        
+        return ChatResponse(answer=final_response.content, query_type="hybrid", sql_query=sql_query, token_usage=total_usage)
     
     def _construct_messages(self, system_instruction: str, history: List[Dict], user_content: str) -> List[Dict]:
         """Construct message list, merging system messages from history."""
@@ -401,8 +450,15 @@ YOUR RESPONSE:"""
             history, 
             query
         )
-        answer = self.llm_client.chat(messages)
-        return ChatResponse(answer=answer, query_type="general")
+        response = self.llm_client.chat(messages)
+        
+        usage = {
+            "input": response.input_tokens,
+            "output": response.output_tokens,
+            "total": response.total_tokens
+        }
+        
+        return ChatResponse(answer=response.content, query_type="general", token_usage=usage)
     
     def _format_results(self, results: List[Dict], max_rows: int = 10) -> str:
         """Format SQL results for display."""

llm/client.py

@@ -11,11 +11,21 @@ from typing import List, Dict, Optional
 logger = logging.getLogger(__name__)
 
 
+from dataclasses import dataclass
+
+@dataclass
+class LLMResponse:
+    content: str
+    input_tokens: int = 0
+    output_tokens: int = 0
+    total_tokens: int = 0
+
+
 class LLMClient(ABC):
     """Abstract base class for LLM clients."""
     
     @abstractmethod
-    def chat(self, messages: List[Dict[str, str]]) -> str:
+    def chat(self, messages: List[Dict[str, str]]) -> LLMResponse:
         pass
     
     @abstractmethod
@@ -64,14 +74,20 @@ class GroqClient(LLMClient):
             self._client = Groq(api_key=self.api_key)
         return self._client
     
-    def chat(self, messages: List[Dict[str, str]]) -> str:
+    def chat(self, messages: List[Dict[str, str]]) -> LLMResponse:
         response = self.client.chat.completions.create(
             model=self.model,
             messages=messages,
             temperature=self.temperature,
             max_tokens=self.max_tokens
         )
-        return response.choices[0].message.content
+        usage = response.usage
+        return LLMResponse(
+            content=response.choices[0].message.content,
+            input_tokens=usage.prompt_tokens if usage else 0,
+            output_tokens=usage.completion_tokens if usage else 0,
+            total_tokens=usage.total_tokens if usage else 0
+        )
     
     def is_available(self) -> bool:
         try:
@@ -106,14 +122,20 @@ class OpenAIClient(LLMClient):
             self._client = OpenAI(api_key=self.api_key)
         return self._client
     
-    def chat(self, messages: List[Dict[str, str]]) -> str:
+    def chat(self, messages: List[Dict[str, str]]) -> LLMResponse:
         response = self.client.chat.completions.create(
             model=self.model,
             messages=messages,
             temperature=self.temperature,
             max_tokens=self.max_tokens
         )
-        return response.choices[0].message.content
+        usage = response.usage
+        return LLMResponse(
+            content=response.choices[0].message.content,
+            input_tokens=usage.prompt_tokens if usage else 0,
+            output_tokens=usage.completion_tokens if usage else 0,
+            total_tokens=usage.total_tokens if usage else 0
+        )
     
     def is_available(self) -> bool:
         try:
@@ -150,14 +172,21 @@ class LocalLLaMAClient(LLMClient):
             )
         return self._pipeline
     
-    def chat(self, messages: List[Dict[str, str]]) -> str:
+    def chat(self, messages: List[Dict[str, str]]) -> LLMResponse:
         output = self.pipeline(
             messages,
             max_new_tokens=self.max_tokens,
             temperature=self.temperature,
             do_sample=True
         )
-        return output[0]["generated_text"][-1]["content"]
+        generated_text = output[0]["generated_text"][-1]["content"]
+        # Approximate tokens for local (or use tokenizer if available)
+        return LLMResponse(
+            content=generated_text,
+            input_tokens=0, # Local pipeline generic usually doesn't give this easily without more access
+            output_tokens=0,
+            total_tokens=0
+        )
     
     def is_available(self) -> bool:
         try:
@@ -165,8 +194,7 @@ class LocalLLaMAClient(LLMClient):
             return True
         except Exception:
             return False
-
-
+            
 def create_llm_client(provider: str = "groq", **kwargs) -> LLMClient:
     """
     Factory function to create LLM client.

router.py

@@ -43,7 +43,7 @@ USER QUERY: {query}
 
 Determine if this query needs:
 1. RAG - Semantic search through text content (searching for meanings, concepts, descriptions)
-2. SQL - Structured database query (counting, filtering, aggregating, specific lookups, OR pagination requests like "show more", "show other", "next results", "remaining items")
+2. SQL - Structured database query (counting, filtering, aggregating, specific lookups, OR pagination requests like "show more", "show other", "next results", "remaining items", OR subjective filtering like "for kids", "summer shoes", "rainy season" which map to columns)
 3. HYBRID - Both semantic search and structured query
 4. GENERAL - General conversation not requiring database access
 
@@ -81,7 +81,7 @@ REASONING: [brief explanation]"""
                 {"role": "system", "content": "You are a query routing assistant."},
                 {"role": "user", "content": prompt}
             ])
-            return self._parse_routing_response(response)
+            return self._parse_routing_response(response.content)
         except Exception as e:
             logger.warning(f"LLM routing failed: {e}, using heuristics")
             return self._heuristic_route(query)
@@ -158,6 +158,8 @@ REASONING: [brief explanation]"""
             return RoutingDecision(QueryType.SQL, 0.8, "SQL query for data retrieval")
         elif rag_score > sql_score:
             return RoutingDecision(QueryType.RAG, 0.8, "Semantic search for concepts")
+        elif "is it good" in query_lower or "consider other" in query_lower:
+            return RoutingDecision(QueryType.GENERAL, 0.7, "Consultative question about metrics")
         elif sql_score > 0 and rag_score > 0:
             return RoutingDecision(QueryType.HYBRID, 0.6, "Mixed query type")
         else:

sql/generator.py

@@ -45,6 +45,12 @@ SQLite-SPECIFIC NOTES:
     else:  # MySQL
         return """
 MySQL-SPECIFIC NOTES:
+- CRITICALLY IMPORTANT: This server runs with ONLY_FULL_GROUP_BY enabled.
+- IF YOU USE GROUP BY, EVERY SINGLE COLUMN in the SELECT list MUST be either:
+  1. In the GROUP BY clause, OR
+  2. Wrapped in an aggregate function (SUM, COUNT, AVT, MAX, MIN).
+- EXAMPLE ERROR: "Expression #2 of SELECT list is not in GROUP BY clause..." -> This means you selected a raw column without aggregation.
+- FIX: Change `SELECT name, clicks... GROUP BY name` to `SELECT name, SUM(clicks)... GROUP BY name`.
 - LIKE is case-insensitive for non-binary strings
 - Use CONCAT() for string concatenation
 - Use LIMIT at the end of queries
@@ -69,11 +75,33 @@ RULES:
    - Use pattern matching for flexibility.
    - Use `OR` to combine multiple column checks.
 7. DATA AWARENESS: In footwear databases, specific types like 'Formal', 'Casual', or 'Sports' often appear in `sub_category` OR `category`. Check both if available.
-8. Return ONLY the SQL query, no explanations.
-9. PAGINATION: If the user asks to "show more", "show other", "see remaining", or similar follow-up:
+8. SUBJECTIVE/IMPLICIT FILTERS:
+   If the user asks for subjective attributes (e.g., "for kids", "summer usage", "rainy season") and no direct column exists:
+   - INFER logical mappings using available columns (material, type, category, description).
+   - EXAMPLES:
+     * "Summer" -> `category` IN ('Sandals', 'Slippers', 'Flip Flops') OR `material` IN ('Canvas', 'Mesh') OR `description` LIKE '%breathable%'
+     * "Winter/Rainy" -> `category` IN ('Boots') OR `material` IN ('Leather', 'Synthetic', 'Rubber') OR `description` LIKE '%waterproof%'
+     * "Kids" -> `category` IN ('Kids', 'Children', 'Junior') OR `product_name` LIKE '%Junior%' OR `product_name` LIKE '%Infant%' OR (`size` < 6 AND `size` > 0)
+   - Use `OR` broadly to capture potential matches.
+   - Use pattern matching (`LIKE` / `ILIKE`) on text columns if categories are unclear.
+
+9. Return ONLY the SQL query, no explanations.
+10. PAGINATION: If the user asks to "show more", "show other", "see remaining", or similar follow-up:
    - Look at the previous conversation for the original query conditions.
    - Use LIMIT with OFFSET to get the next set of results (e.g., LIMIT 10 OFFSET 10 for the second page).
    - Keep the same WHERE conditions from the previous query.
+   - Use LIMIT with OFFSET to get the next set of results (e.g., LIMIT 10 OFFSET 10 for the second page).
+   - Keep the same WHERE conditions from the previous query.
+11. GROUP BY RULES: If you use GROUP BY, every column in the SELECT list must be either in the GROUP BY clause or wrapped in an aggregate function (SUM, AVG, COUNT, MAX). Do NOT select raw columns like `clicks` or `price` if you are grouping by `product_name`; use SUM(clicks), AVG(price), etc.
+12. BUSINESS LOGIC & METRICS:
+   - `sales` column is usually QUANTITY (integer). `price` is Unit Price. `mfrcost` is Unit Cost.
+   - REVENUE = `sales * price`
+   - GROSS PROFIT = `(price - mfrcost) * sales`
+   - NET PROFIT (w/ Ad Cost) = `((price - mfrcost) * sales) - adcost`
+   - PROFIT MARGIN (%) = `(NET PROFIT / REVENUE) * 100`
+   - ROAS = `REVENUE / adcost`
+   - If User asks for "Profit" or "Margin" and `adcost` is available, PREFER the NET PROFIT formula that subtracts `adcost`.
+   - Always aggregate (SUM) these values when grouping by product/category.
 
 {dialect_hints}
 
@@ -127,8 +155,15 @@ Generate a single {dialect} SELECT query to answer the user's question."""
         
         response = self.llm_client.chat(messages)
         
-        # Extract SQL from response
-        sql = self._extract_sql(response)
+        # Extract SQL from response content
+        sql = self._extract_sql(response.content)
+        
+        # We can optionally pass usage back too, but for strict backward compatibility 
+        # let's just use the content in the tuple for now, or update the return type.
+        # Since I am updating the chatbot anyway, I will attach usage to the response.
+        # However, to avoid breaking other calls immediately, I'll return the response object as the second item
+        # instead of just the explanation string, OR I can monkey-patch the explanation string.
+        # Better: let's update return type to Tuple[str, LLMResponse].
         
         return sql, response