Enhance Sales Assistant with Pydantic Validation and Gradio Dashboard

- Updated README.md to include instructions for running the Gradio dashboard.
- Refactored tools_node.py to implement Pydantic validation for tool configurations and schemas.
- Improved agent_tools_utils.py to streamline data retrieval and error handling.
- Enhanced create_quote.py to utilize Pydantic models for input/output validation and error handling.
- Updated execute_sql_query.py to return structured output using Pydantic schemas.
- Refined get_exchange_rates.py to implement Pydantic validation for currency conversion.
- Modified db_utils.py to raise exceptions for better error handling.
- Improved prompts module with a new system prompt for enhanced user interaction.
- Updated Gradio app to improve UI and user experience with example queries.
- Introduced tool_schemas.py to define Pydantic schemas for various tool inputs and outputs.

README.md

@@ -19,3 +19,9 @@ uv pip install -e .
 ```bash
 uv run python src/sales_assistant/main.py
 ```
+
+## TO run the gradio dashboard, run:
+
+```bash
+uv run python src/sales_assistant/ui_dashboard/gradio_app.py
+```

src/sales_assistant/agent_main/tools_node.py

@@ -1,54 +1,98 @@
 """
-Tools node that are using the agent_tools folder's tools
+Tools node using state-of-the-art patterns with Pydantic validation.
 """
-from typing import List
+import os
+from typing import List, Optional
 from langchain_core.tools import BaseTool
 from langgraph.prebuilt import ToolNode
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, validator
+from dotenv import load_dotenv
 
-# Import all the tools from agent_tools
+# Load environment variables
+load_dotenv()
+
+# Import tools with proper schemas
 from ..agent_tools.execute_sql_query import execute_sql_query
 from ..agent_tools.get_exchange_rates import exchange_converter
 from ..agent_tools.create_quote import create_quote
 
+
 class ToolConfig(BaseModel):
     """Configuration for tools with validation."""
     enable_advanced_tools: bool = Field(default=False, description="Enable advanced database tools")
-    max_tools: int = Field(default=10, description="Maximum number of tools to load")
+    max_tools: int = Field(default=10, ge=1, le=50, description="Maximum number of tools to load")
+    model_name: str = Field(default_factory=lambda: os.getenv("MODEL_NAME", "gpt-4o-mini"), description="Model optimized for these tools")
+    
+    @validator('model_name')
+    def validate_model_name(cls, v):
+        allowed_models = ["gpt-5-mini", "gpt-4o-mini", "gpt-4", "gpt-3.5-turbo"]
+        if v not in allowed_models:
+            raise ValueError(f"Model must be one of {allowed_models}")
+        return v
+
+
+class ToolRegistry(BaseModel):
+    """Registry for validated tools."""
+    tools: List[BaseTool] = Field(description="List of validated tools")
+    config: ToolConfig = Field(description="Tool configuration")
+    
+    class Config:
+        arbitrary_types_allowed = True
+    
+    @validator('tools')
+    def validate_tools(cls, v):
+        """Validate that all tools have proper schemas."""
+        for tool in v:
+            if not hasattr(tool, 'args_schema'):
+                raise ValueError(f"Tool {tool.name} missing args_schema for validation")
+            if not hasattr(tool, 'name') or not tool.name:
+                raise ValueError("Tool missing required name attribute")
+        return v
+
 
-def get_all_tools(config: ToolConfig = None) -> List[BaseTool]:
+def get_all_tools(config: Optional[ToolConfig] = None) -> List[BaseTool]:
     """
-    Get GPT-5-mini optimized tools using built-in LangChain patterns.
+    Get gpt-5-mini optimized tools with proper validation.
     
     Args:
-        config: Optional tool configuration
+        config: Optional tool configuration with validation
         
     Returns:
-        List of validated tools for GPT-5-mini
+        List of validated tools
     """
     if config is None:
         config = ToolConfig()
     
-    # Core tools optimized for GPT-5-mini
+    # Core tools with Pydantic schemas for LangGraph
     core_tools = [
         execute_sql_query,
         exchange_converter, 
         create_quote
     ]
     
-    # Validate tools have proper schemas (built-in validation)
-    validated_tools = []
-    for tool in core_tools:
-        if hasattr(tool, 'args_schema') or hasattr(tool, 'name'):
-            validated_tools.append(tool)
+    # Create registry with validation
+    registry = ToolRegistry(tools=core_tools, config=config)
     
-    return validated_tools[:config.max_tools]
+    return registry.tools[:config.max_tools]
+
 
-# Create the tool node using LangGraph's built-in ToolNode with error handling
-def create_tool_node() -> ToolNode:
-    """Create a validated tool node with built-in error handling."""
-    tools = get_all_tools()
+def create_tool_node(config: Optional[ToolConfig] = None) -> ToolNode:
+    """Create a validated tool node with LangGraph built-in error handling."""
+    tools = get_all_tools(config)
+    # LangGraph ToolNode handles validation, execution, and error handling automatically
     return ToolNode(tools)
 
-# Use the factory function for better control
-tool_node = create_tool_node()
+
+# Factory function with LangGraph best practices
+def create_optimized_tool_node() -> ToolNode:
+    """Create tool node optimized for the configured model from environment."""
+    config = ToolConfig(
+        enable_advanced_tools=True,
+        max_tools=20,
+        model_name=os.getenv("MODEL_NAME", "gpt-5-mini")
+    )
+    return create_tool_node(config)
+
+
+# Use the optimized factory for production
+tool_node = create_optimized_tool_node()

src/sales_assistant/agent_tools/agent_tools_utils.py

@@ -15,54 +15,51 @@ def get_data_for_agent(query: str, return_type: str = "dict_records") -> str:
     
     Args:
         query (str): SQL query string to execute.
+        return_type (str): Format for returned data ("dict_records", "dict", "string")
         
     Returns:
-        str: Formatted string of query results or error message.
+        tuple: (original_df, formatted_data) - Raises exception if query fails
     """
-    try:
-        # Log the SQL query being executed
-        logger.info(f"Executing SQL query: {query}")
-        
-        df_original = read_sql(query)
-
-        if return_type == "dict_records":
-            df_formated = df_original.to_dict(orient="records")
-        
-        if return_type == "dict":
-            df_formated = df_original.to_dict()
+    # Log the SQL query being executed
+    logger.info(f"Executing SQL query: {query}")
+    
+    # Let exceptions propagate up to the calling function
+    df_original = read_sql(query)
 
-        if return_type == "string":
-            if df_original.empty:
-                df_formated = "No data found."
-            else:
-                df_formated = df_original.to_string(index=False)
+    if return_type == "dict_records":
+        df_formated = df_original.to_dict(orient="records")
+    elif return_type == "dict":
+        df_formated = df_original.to_dict()
+    elif return_type == "string":
+        if df_original.empty:
+            df_formated = "No data found."
+        else:
+            df_formated = df_original.to_string(index=False)
+    else:
+        df_formated = df_original.to_dict(orient="records")  # default
 
-        return df_original, df_formated
-    
-    except Exception as e:
-        data_value = f"Error retrieving data: {str(e)}"
-        df_original = pd.DataFrame()
-        df_formated = pd.DataFrame()
-        return df_original, df_formated
+    return df_original, df_formated
     
 
-def create_results_metadata(results_orignal: pd.DataFrame) -> dict:
+def create_results_metadata(results_original: pd.DataFrame) -> dict:
     """
     Create metadata about the results such as count of records and columns.
     
     Args:
-        results_orignal (pd.DataFrame): Original DataFrame of query results.
+        results_original (pd.DataFrame): Original DataFrame of query results.
         
     Returns:
         dict: Metadata including counts of records and columns.
     """
-
-    shape = results_orignal.shape
+    shape = results_original.shape
     rows = shape[0]
     cols = shape[1]
+    columns = results_original.columns.tolist()
 
     metadata = {
-        'row count': rows
+        'row_count': rows,
+        'column_count': cols,
+        'columns': columns
     }
     
     return metadata

src/sales_assistant/agent_tools/create_quote.py

@@ -5,7 +5,7 @@ This tool queries products by ID and creates structured quotes with proper Markd
 
 import os
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
+from typing import Union, List, Dict, Any
 from collections import Counter
 from langchain_core.tools import tool
 from langchain_openai import ChatOpenAI
@@ -20,6 +20,7 @@ from .quote_template import (
 )
 from .get_exchange_rates import convert_amount
 from .agent_tools_utils import get_data_for_agent
+from .tool_schemas import QuoteInput, QuoteOutput, QuoteItemSummary, ErrorOutput
 
 # Load environment variables
 load_dotenv()
@@ -65,10 +66,9 @@ def fetch_products_by_ids(product_ids: List[int], target_currency: str = "EUR")
                     target_currency, 
                     msrp_price
                 )
-                if "error" not in conversion_result:
-                    converted_price = conversion_result["converted_amount"]
+                if hasattr(conversion_result, 'converted_amount'):
+                    converted_price = conversion_result.converted_amount
                 else:
-                    print(f"Warning: Currency conversion failed for product {product.get('id')}: {conversion_result.get('error')}")
                     converted_price = msrp_price  # Use original price
             else:
                 converted_price = msrp_price
@@ -157,25 +157,26 @@ def create_quote_file(quote: Quote, content: str) -> str:
     return filepath
 
 
-@tool
+@tool(args_schema=QuoteInput)
 def create_quote(
     product_ids: List[int],
     customer_name: str,
-    customer_email: Optional[str] = None,
-    customer_company: Optional[str] = None,
+    customer_email: str = None,
+    customer_company: str = None,
     target_currency: str = "EUR",
-    notes: Optional[str] = None
-) -> Dict[str, Any]:
+    notes: str = None
+) -> Union[QuoteOutput, ErrorOutput]:
     """
-    A quote creation tool that generates quotes using product IDs from the database.
+    A quote creation tool that generates professional quotes using product IDs from the database.
     
     This tool takes a list of product IDs (can include duplicates for multiple quantities),
     fetches product details from the database, and generates a professional quote with
-    proper Markdown tables and formatting. This can only works if the products have prices
+    proper Markdown tables and formatting. This tool only works if the products have prices
     set in the database.
     
     Args:
-        product_ids (List[int]): List of product IDs from database. Duplicates indicate multiple quantities. Example: [1, 1, 1, 3, 4, 5] means 3x product ID 1, 1x product ID 3, 1x product ID 4, 1x product ID 5
+        product_ids (List[int]): List of product IDs from database. Duplicates indicate multiple quantities. 
+                                Example: [1, 1, 1, 3, 4, 5] means 3x product ID 1, 1x product ID 3, 1x product ID 4, 1x product ID 5
         customer_name (str): Customer's full name (required)
         customer_email (Optional[str]): Customer's email address
         customer_company (Optional[str]): Customer's company name
@@ -192,15 +193,10 @@ def create_quote(
         )
     
     Returns:
-        Dict containing quote details and file path.
+        QuoteOutput: Quote details with file path and summary information.
     """
     try:
-        # Validate inputs
-        if not customer_name:
-            return {"error": "Customer name is required"}
-            
-        if not product_ids or len(product_ids) == 0:
-            return {"error": "At least one product ID is required"}
+        # Pydantic validation handled by LangGraph automatically
         
         # Count quantities for each product ID
         product_quantities = Counter(product_ids)
@@ -210,7 +206,7 @@ def create_quote(
         products_data = fetch_products_by_ids(unique_product_ids, target_currency)
         
         if not products_data:
-            return {"error": "No products found for the provided IDs"}
+            return ErrorOutput(error="No products found for the provided IDs")
         
         # Create customer info
         customer = CustomerInfo(
@@ -296,38 +292,38 @@ def create_quote(
         # Save to Markdown file
         file_path = create_quote_file(quote, final_quote)
         
-        # Prepare response
-        response = {
-            "success": True,
-            "quote_id": quote.quote_id,
-            "customer_name": customer_name,
-            "grand_total": quote.grand_total,
-            "currency": target_currency,
-            "item_count": len(quote_items),
-            "unique_products": len(unique_product_ids),
-            "total_items": sum(product_quantities.values()),
-            "file_path": file_path,
-            "file_format": "markdown",
-            "created_date": quote.created_date.isoformat(),
-            "valid_until": quote.valid_until.isoformat(),
-            "quote_summary": {
+        # Create quote summary with Pydantic models
+        quote_summary_items = [
+            QuoteItemSummary(
+                product_id=item.product_id,
+                name=item.product_name,
+                quantity=item.quantity,
+                unit_price=item.unit_price,
+                total=item.total_price
+            ).dict() for item in quote_items
+        ]
+        
+        return QuoteOutput(
+            success=True,
+            quote_id=quote.quote_id,
+            customer_name=customer_name,
+            grand_total=quote.grand_total,
+            currency=target_currency,
+            item_count=len(quote_items),
+            unique_products=len(unique_product_ids),
+            total_items=sum(product_quantities.values()),
+            file_path=file_path,
+            file_format="markdown",
+            created_date=quote.created_date.isoformat(),
+            valid_until=quote.valid_until.isoformat(),
+            quote_summary={
                 "grand_total": quote.grand_total,
-                "items": [
-                    {
-                        "product_id": item.product_id,
-                        "name": item.product_name,
-                        "quantity": item.quantity,
-                        "unit_price": item.unit_price,
-                        "total": item.total_price
-                    } for item in quote_items
-                ]
+                "items": quote_summary_items
             }
-        }
-        
-        return response
+        )
         
     except Exception as e:
-        return {"error": f"Quote creation failed: {str(e)}"}
+        return ErrorOutput(error=f"Quote creation failed: {str(e)}")
 
 
 def create_sample_quote_from_ids():

src/sales_assistant/agent_tools/execute_sql_query.py

@@ -1,16 +1,20 @@
 from typing import Any, Dict, List, Optional, Literal
 from langchain_core.tools import tool
-from .agent_tools_utils import *
+from .agent_tools_utils import get_data_for_agent, create_results_metadata
+from .tool_schemas import SQLQueryInput, SQLQueryOutput, QueryMetadata
 
 
-@tool
+@tool(args_schema=SQLQueryInput)
 def execute_sql_query(
     sql_query: str, 
     query_type: Optional[Literal["search", "statistics", "distinct_values", "sample", "advanced"]] = None
-) -> Dict[str, Any]:
+) -> SQLQueryOutput:
     """
     Execute any SQL query against the database with complete flexibility for all types of operations.
     This unified tool handles product searches, statistical analysis, data exploration, sampling, and advanced queries.
+
+    We use mySQL database with the following main table:
+    - Main table: `streamnet.products_list`
     
     Args:
         sql_query (str): Any valid SQL query to execute against the streamnet.products_list table.
@@ -22,6 +26,10 @@ def execute_sql_query(
             - "advanced": Complex queries with joins, subqueries, analytics
             
     Query Examples by Type:
+
+    DESCRIBE QUERIES:
+    - "DESCRIBE streamnet.products_list;"
+    - "SHOW COLUMNS FROM streamnet.products_list;"
     
     SEARCH QUERIES:
     - "SELECT * FROM streamnet.products_list WHERE manufacturer = 'Samsung' AND category = 'Electronics' LIMIT 15;"
@@ -56,24 +64,51 @@ def execute_sql_query(
     - "SELECT YEAR(NOW()) as current_year, manufacturer, model_name, msrp FROM streamnet.products_list WHERE description LIKE '%2024%' OR description LIKE '%new%';"
         
     Returns:
-        Dict[str, Any]: Results from the SQL query execution with metadata.
+        SQLQueryOutput: Results from the SQL query execution with metadata, including error details if query fails.
     """
     try:
         results_original, results_formatted = get_data_for_agent(sql_query, return_type="dict_records")
         metadata = create_results_metadata(results_original)
-
-        result_dict = {
-            "query_executed": sql_query,
-            "data_from_db": results_formatted,
-            "query_type": query_type,
-            "metadata": metadata
-        }
         
-        return result_dict
+        # Convert to Pydantic metadata model with success info
+        pydantic_metadata = QueryMetadata(
+            row_count=metadata.get("row_count", 0),
+            column_count=metadata.get("column_count", 0),
+            columns=metadata.get("columns", []),
+            execution_time=metadata.get("execution_time"),
+            query_successful=True,
+            error_message=None,
+            error_type=None
+        )
+
+        return SQLQueryOutput(
+            query_executed=sql_query,
+            data_from_db=results_formatted,
+            query_type=query_type,
+            metadata=pydantic_metadata,
+            success=True
+        )
        
     except Exception as e:
-        return {
-            "error": f"SQL query execution failed: {str(e)}",
-            "query_executed": sql_query,
-            "query_type": query_type
-        }
+        # Capture detailed error information
+        error_type = type(e).__name__
+        error_message = str(e)
+        
+        # Create metadata with error details
+        error_metadata = QueryMetadata(
+            row_count=0,
+            column_count=0,
+            columns=[],
+            execution_time=None,
+            query_successful=False,
+            error_message=error_message,
+            error_type=error_type
+        )
+        
+        return SQLQueryOutput(
+            query_executed=sql_query,
+            data_from_db=[],
+            query_type=query_type,
+            metadata=error_metadata,
+            success=False
+        )

src/sales_assistant/agent_tools/get_exchange_rates.py

@@ -1,5 +1,6 @@
-from typing import Any, Dict
+from typing import Any, Dict, Union
 from langchain_core.tools import tool
+from .tool_schemas import CurrencyConversionInput, CurrencyConversionOutput, ErrorOutput
 
 # Fixed exchange rates relative to HUF (kept simple and deterministic)
 _EXCHANGE_RATES = {
@@ -13,8 +14,8 @@ def _normalize_currency(code: str) -> str:
     return code.strip().upper() if isinstance(code, str) else ""
 
 
-def convert_amount(from_currency: str, to_currency: str, amount: float, precision: int = 2) -> Dict[str, Any]:
-    """Simple, deterministic currency converter.
+def convert_amount(from_currency: str, to_currency: str, amount: float, precision: int = 2) -> Union[CurrencyConversionOutput, ErrorOutput]:
+    """Simple, deterministic currency converter with Pydantic validation.
 
     Returns a small dict on success: {
       "converted_amount": float,
@@ -29,38 +30,56 @@ def convert_amount(from_currency: str, to_currency: str, amount: float, precisio
     tc = _normalize_currency(to_currency)
 
     if not fc or not tc:
-        return {"error": "from_currency and to_currency are required strings"}
+        return ErrorOutput(error="from_currency and to_currency are required strings")
 
     if fc not in _EXCHANGE_RATES or tc not in _EXCHANGE_RATES:
-        return {"error": f"Unsupported currency. Supported: {', '.join(sorted(_EXCHANGE_RATES.keys()))}"}
+        return ErrorOutput(error=f"Unsupported currency. Supported: {', '.join(sorted(_EXCHANGE_RATES.keys()))}")
 
     try:
         amt = float(amount)
     except Exception:
-        return {"error": "Amount must be a number"}
+        return ErrorOutput(error="Amount must be a number")
 
     if amt < 0:
-        return {"error": "Amount must be non-negative"}
+        return ErrorOutput(error="Amount must be non-negative")
 
     if fc == tc:
-        return {"converted_amount": round(amt, precision), "exchange_rate": 1.0, "from": fc, "to": tc}
+        return CurrencyConversionOutput(
+            original_amount=round(amt, precision),
+            from_currency=fc,
+            converted_amount=round(amt, precision),
+            to_currency=tc,
+            exchange_rate=1.0
+        )
 
     # Convert via HUF as base: source -> HUF -> target
     converted = (amt * _EXCHANGE_RATES[fc]) / _EXCHANGE_RATES[tc]
     rate = converted / amt if amt != 0 else 0.0
 
-    return {
-        "original_amount": round(amt, precision),
-        "from": fc,
-        "converted_amount": round(converted, precision),
-        "to": tc,
-        "exchange_rate": round(rate, max(4, precision))
-    }
+    return CurrencyConversionOutput(
+        original_amount=round(amt, precision),
+        from_currency=fc,
+        converted_amount=round(converted, precision),
+        to_currency=tc,
+        exchange_rate=round(rate, max(4, precision))
+    )
 
 
-@tool
-def exchange_converter(from_currency: str = "EUR", to_currency: str = "HUF", amount: float = 1.0, precision: int = 2) -> Dict[str, Any]:
+@tool(args_schema=CurrencyConversionInput)
+def exchange_converter(from_currency: str = "EUR", to_currency: str = "HUF", amount: float = 1.0, precision: int = 2) -> Union[CurrencyConversionOutput, ErrorOutput]:
     """
-    Currency converter tool. That can convert between EUR, USD, and HUF, allowing specification of precision.
+    Currency converter tool that can convert between EUR, USD, and HUF currencies with configurable precision.
+    
+    This tool provides deterministic currency conversion using fixed exchange rates relative to HUF.
+    Supports EUR, USD, and HUF currencies with customizable decimal precision for results.
+    
+    Args:
+        from_currency (str): Source currency code (EUR, USD, HUF). Default: "EUR"
+        to_currency (str): Target currency code (EUR, USD, HUF). Default: "HUF" 
+        amount (float): Amount to convert (must be non-negative). Default: 1.0
+        precision (int): Decimal precision for result (0-10). Default: 2
+        
+    Returns:
+        CurrencyConversionOutput: Conversion result with original amount, converted amount, and exchange rate.
     """
     return convert_amount(from_currency, to_currency, amount, precision)

src/sales_assistant/agent_tools/tool_schemas.py

@@ -0,0 +1,107 @@
+"""
+Pydantic schemas for tool inputs and outputs following LangGraph standards.
+"""
+from typing import Any, Dict, List, Optional, Literal, Union
+from pydantic import BaseModel, Field, validator
+from datetime import datetime
+
+
+class SQLQueryInput(BaseModel):
+    """Input schema for SQL query execution."""
+    sql_query: str = Field(description="Valid SQL query to execute")
+    query_type: Optional[Literal["search", "statistics", "distinct_values", "sample", "advanced"]] = Field(
+        default=None, description="Type hint for query classification"
+    )
+
+
+class QueryMetadata(BaseModel):
+    """Metadata for query results."""
+    row_count: int = Field(description="Number of rows returned")
+    column_count: int = Field(description="Number of columns in result")
+    columns: List[str] = Field(description="Column names")
+    execution_time: Optional[float] = Field(default=None, description="Query execution time in seconds")
+    query_successful: bool = Field(default=True, description="Whether the query executed successfully")
+    error_message: Optional[str] = Field(default=None, description="Error message if query failed")
+    error_type: Optional[str] = Field(default=None, description="Type of error that occurred")
+
+
+class SQLQueryOutput(BaseModel):
+    """Output schema for SQL query results."""
+    query_executed: str = Field(description="The SQL query that was executed")
+    data_from_db: List[Dict[str, Any]] = Field(description="Query results as list of dictionaries")
+    query_type: Optional[str] = Field(description="Type of query executed")
+    metadata: QueryMetadata = Field(description="Query execution metadata")
+    success: bool = Field(default=True, description="Whether query executed successfully")
+
+
+class CurrencyConversionInput(BaseModel):
+    """Input schema for currency conversion."""
+    from_currency: str = Field(default="EUR", description="Source currency code")
+    to_currency: str = Field(default="HUF", description="Target currency code")
+    amount: float = Field(default=1.0, ge=0, description="Amount to convert (must be non-negative)")
+    precision: int = Field(default=2, ge=0, le=10, description="Decimal precision for result")
+
+
+class CurrencyConversionOutput(BaseModel):
+    """Output schema for currency conversion results."""
+    original_amount: float = Field(description="Original amount")
+    from_currency: str = Field(description="Source currency")
+    converted_amount: float = Field(description="Converted amount")
+    to_currency: str = Field(description="Target currency")
+    exchange_rate: float = Field(description="Exchange rate used")
+    success: bool = Field(default=True, description="Whether conversion was successful")
+
+
+class QuoteItemSummary(BaseModel):
+    """Summary of a quote item."""
+    product_id: int = Field(description="Product ID from database")
+    name: str = Field(description="Product name")
+    quantity: int = Field(description="Quantity ordered")
+    unit_price: float = Field(description="Unit price")
+    total: float = Field(description="Total price for this item")
+
+
+class QuoteInput(BaseModel):
+    """Input schema for quote creation."""
+    product_ids: List[int] = Field(description="List of product IDs (duplicates indicate multiple quantities)")
+    customer_name: str = Field(description="Customer full name")
+    customer_email: Optional[str] = Field(default=None, description="Customer email address")
+    customer_company: Optional[str] = Field(default=None, description="Customer company name")
+    target_currency: str = Field(default="EUR", description="Currency for quote")
+    notes: Optional[str] = Field(default=None, description="Additional notes")
+
+    @validator('product_ids')
+    def validate_product_ids(cls, v):
+        if not v or len(v) == 0:
+            raise ValueError("At least one product ID is required")
+        return v
+
+    @validator('customer_name')
+    def validate_customer_name(cls, v):
+        if not v or not v.strip():
+            raise ValueError("Customer name is required")
+        return v.strip()
+
+
+class QuoteOutput(BaseModel):
+    """Output schema for quote creation results."""
+    success: bool = Field(description="Whether quote was created successfully")
+    quote_id: str = Field(description="Unique quote identifier")
+    customer_name: str = Field(description="Customer name")
+    grand_total: float = Field(description="Total quote amount")
+    currency: str = Field(description="Quote currency")
+    item_count: int = Field(description="Number of unique items")
+    unique_products: int = Field(description="Number of unique products")
+    total_items: int = Field(description="Total quantity of all items")
+    file_path: str = Field(description="Path to generated quote file")
+    file_format: str = Field(description="Format of generated file")
+    created_date: str = Field(description="Quote creation date")
+    valid_until: str = Field(description="Quote expiration date")
+    quote_summary: Dict[str, Any] = Field(description="Summary of quote contents")
+
+
+class ErrorOutput(BaseModel):
+    """Standard error output schema."""
+    error: str = Field(description="Error message")
+    success: bool = Field(default=False, description="Always False for errors")
+    timestamp: str = Field(default_factory=lambda: datetime.now().isoformat(), description="Error timestamp")

src/sales_assistant/db/utils/db_utils.py

@@ -18,6 +18,9 @@ def read_sql(query_str: str) -> pd.DataFrame:
         
     Returns:
         pandas DataFrame with query results
+        
+    Raises:
+        Exception: Re-raises any database or connection errors for proper error handling
     """
     tunnel = None
     engine = None
@@ -30,8 +33,8 @@ def read_sql(query_str: str) -> pd.DataFrame:
         return df
     except Exception as e:
         print(f"Error executing read query: {e}")
-        # return an empty DataFrame on error
-        return pd.DataFrame()
+        # Re-raise the exception so it can be handled by the calling function
+        raise e
     finally:
         disconnect(engine, tunnel)
 

src/sales_assistant/prompts/__init__.py

@@ -0,0 +1,8 @@
+"""
+Prompts module for the sales assistant agent.
+Optimized for GPT-5-mini reasoning capabilities.
+"""
+
+from .system_prompt import SYSTEM_PROMPT
+
+__all__ = ["SYSTEM_PROMPT"]

src/sales_assistant/prompts/system_prompt.py

@@ -1,141 +1,56 @@
-
-SYSTEM_PROMPT = """You are an intelligent database exploration and sales assistant agent. You help users explore a MySQL database and answer questions about products using dynamic SQL queries.
-
-## Your Mission
-1. **Explore First**: When a user asks a question, start by exploring the database structure and content using custom SQL queries. This should be broad.
- - tips: start wth the manifcaturer, get the categories and subcategories and then look into the descipton column to find products
-2. **Understand the Data**: Use multiple tools with creative SQL queries to understand what products are available
-3. **Query Strategically**: Build sophisticated SQL queries based on your exploration findings run multiple queries to get a complete picture
-4. **Answer Comprehensively**: Provide helpful, detailed answers with specific product information
-
-## Database Information
-- Main table: `streamnet.products_list`
-- Key columns: id, manufacturer, category, sub_category, model_name, model_number_long, model_number_short, description, currency, distributor_pricing, msrp
-- Contains various products with pricing and detailed information from various manufacturers
-- different manufacturers can have different definitions how they categorize their products, so you need to be creative in how you search for products with custom SQL queries
-
-## Information about user's intent:
-- if a user asks about specific product you need to use the model_name, or model_number_long, or model_number_short to find the product
-- if a user asks about a non specific product you can use the manifcaturer, category and sub_category fields to find the products more generally e.g.
-- the description column can contain additional information about the product like: size, resolution, etc so you can creatively use it to find products
-
-## Available Dynamic SQL Tools
-All tools now accept custom SQL queries as input, giving you complete flexibility:
-
-- `describe_table`: Use custom SQL to explore table structure (DESCRIBE, SHOW COLUMNS, information_schema queries)
-- `get_sample_data`: Use dynamic SQL with WHERE clauses, JOINs, filtering to sample specific data subsets
-- `get_distinct_values`: Use GROUP BY, aggregations, complex filtering to explore data patterns and distributions
-- `search_products_by_criteria`: Use sophisticated WHERE clauses, LIKE patterns, ranges, sorting for product searches
-- `get_table_statistics`: Use aggregation functions (COUNT, AVG, MIN, MAX, STDDEV) for analytical insights
-- `execute_advanced_query`: Run any complex SQL including subqueries, CTEs, window functions, advanced analytics
-
-## Avalable Non-SQL Tools
-- `exchange_converter`: Convert between EUR, USD, and HUF currencies
-- `create_quote`: Generate professional quotes with multiple products, customer info, and LLM-generated content
-
-## Your Enhanced ReAct Process with Dynamic SQL
-1. **Reason**: Think about what information you need and what SQL query would best retrieve it, but always start with exploring the database structure and if you need by manufacturer, category and sub_category the structure one by one goind deeper
-2. **Act**: Craft custom SQL queries using the appropriate tools for maximum flexibility trying out different queries to explore the database
-3. **Observe**: Analyze the results from your SQL queries
-4. **Iterate**: Refine your SQL queries based on results, add filters, change aggregations, explore different angles
-5. **Respond**: Provide a comprehensive answer with specific product details
-
-## Advanced SQL examples and tips
-- Use WHERE clauses creatively to filter data: `WHERE manufacturer = 'Samsung' AND category = 'Electronics AND sub_category'`
-- Use LIKE for pattern matching: `WHERE description LIKE '%50%' OR model_name LIKE '%Pro%'`
-- Use aggregations for insights: `SELECT manufacturer, COUNT(*), AVG(msrp) FROM ... GROUP BY manufacturer`
-- Use ORDER BY for meaningful sorting: `ORDER BY msrp DESC, manufacturer ASC`
-- Use LIMIT to control result size: `LIMIT 10` or `LIMIT 20` you an go even higher to get more results
-- Combine multiple conditions: `WHERE msrp BETWEEN 100 AND 500 AND manufacturer IN ('Apple', 'Samsung')`
-- Use subqueries for complex logic: `WHERE msrp > (SELECT AVG(msrp) FROM streamnet.products_list)`
-
-## SQL Query Examples for Inspiration
-- `SELECT * FROM streamnet.products_list WHERE manufacturer = 'Samsung' AND model_name like '%Entry%'`
-- `SELECT DISTINCT category FROM streamnet.products_list WHERE manufacturer like 'angekis'`
-- `SELECT * FROM streamnet.products_list WHERE category = 'Camera'
-
-## Price list description
-- For sony products the category and sub_category is not desciptive e.g. Professional BRAVIA Full HD & 4K are tvs, and Video Wall are led displays
-- For sony you need to look at the description column to find the products and their categories too
-
-## Guidelines
-- If the user intent is straightforward, use the most relevant tool with a custom SQL query
-- If not always start with database exploration using custom SQL queries in this way you can find the products more easily
-- Be creative with your SQL - use complex WHERE clauses, JOINs, subqueries as needed
-- Use multiple tools with different SQL queries to get a complete picture if needed
-- Provide specific product details including pricing when a user ask for it
-- the `exchange_converter` tool can be used to convert prices if the user asks for it or if you want to normalize prices to a common currency
-- **Quote Generation**: When users want quotes, use the `create_quote` tool with:
-  - Customer information (name, email, company)
-  - Product id-s of the products they want quotes for (use multiple if needed)
-  - Appropriate currency
-  - The tool generates professional quotes with LLM-enhanced greetings and introductions
-
-## Other Guidelines
-- Ask follow-up questions if the user's request is unclear
-- Build upon previous SQL query results to refine your search
-- Remember context from previous explorations in the conversation
-
-If you want you can start by exploring the database structure with a custom SQL query to understand what you're working with!"""
-
-
-SYSTEM_PROMPT = """You are an intelligent database exploration and sales assistant agent. You help users explore a MySQL database and answer questions about products using dynamic SQL queries.
-
-## Your Mission
-1. **Explore First**: When a user asks a question, start by exploring the database structure and content using custom SQL queries. This should be broad.
- - tips: start wth the manufcaturer, get the categories and subcategories, get some samples and then look into the descipton column to find products
-2. **Understand the Data**: Use multiple tools with creative SQL queries to understand what products are available if needed
-3. **Query Strategically**: Build sophisticated SQL queries based on your exploration findings run multiple queries to get a complete picture
-4. **Answer Comprehensively**: Provide helpful, detailed answers with specific product information
-
-## Database Information
-- Main table: `streamnet.products_list`
-- Key columns: id, manufacturer, category, sub_category, model_name, model_number_long, model_number_short, description, currency, distributor_pricing, msrp
-- Contains various products with pricing and detailed information from various manufacturers
-- different manufacturers can have different definitions how they categorize their products, so you need to be creative in how you search for products with custom SQL queries
-
-## Manufacturer specific tips
-- For sony products the category and sub_category is not desciptive e.g. Professional BRAVIA Full HD & 4K are tvs, and Video Wall are led displays
-- For sony you need to look at the description column to find the products and their categories too
-
-## Information about user's intent:
-- if a user asks about specific product you need to use the model_name, or model_number_long, or model_number_short to find the product
-- if a user asks about a non specific product you can use the manifcaturer, category and sub_category fields to find the products more generally e.g.
-- the description column can contain additional information about the product like: size, resolution, etc so you can creatively use it to find products
-
-## Available Dynamic SQL Tools
-- `execute_sql_query`: Use custom SQL to explore table structure, and query data with complete flexibility
-
-## Avalable Non-SQL Tools
-- `exchange_converter`: Convert between EUR, USD, and HUF currencies
-- `create_quote`: Generate professional quotes with multiple products, customer info, and LLM-generated content
-
-## Your Enhanced ReAct Process with Dynamic SQL
-1. **Reason**: Think about what information you need and what SQL query would best retrieve it, but always start with exploring the database structure and if you need by manufacturer, category and sub_category the structure one by one goind deeper
-2. **Act**: Craft custom SQL queries using the appropriate tools for maximum flexibility trying out different queries to explore the database
-3. **Observe**: Analyze the results from your SQL queries
-4. **Iterate**: Refine your SQL queries based on results, add filters, change aggregations, explore different angles
-5. **Respond**: Provide a comprehensive answer with specific product details
-
-## Guidelines
-- If the user intent is straightforward, use the most relevant tool with a custom SQL query
-- If not always start with database exploration using custom SQL queries in this way you can find the products more easily
-- Be creative with your SQL - use complex WHERE clauses, JOINs, subqueries as needed
-- Use limit to focus your results and minimize token usage as much as possible
-- Use multiple tools with different SQL queries to get a complete picture if needed
-- Provide specific product details including pricing when a user ask for it
-- the `exchange_converter` tool can be used to convert prices if the user asks for it or if you want to normalize prices to a common currency
-- **Quote Generation**: When users want quotes, use the `create_quote` tool with:
-  - Customer information (name, email)
-  - Product id-s of the products they want quotes for (use multiple if needed)
-  - Appropriate currency
-  - The tool generates professional quotes with LLM-enhanced greetings and introductions
-
-## Other Guidelines
-- Ask follow-up questions if the user's request is unclear
-- Avoid offering options that you cannot fulfill like (generating pdf, send emails, etc)
-- If the user want to compare products pull them up with a single SQL query using IN
-- Build upon previous SQL query results to refine your search
-- Remember context from previous explorations in the conversation
-
-If you want you can start by exploring the database structure with a custom SQL query to understand what you're working with!"""
+SYSTEM_PROMPT = """You are an intelligent sales assistant agent powered by GPT-5-mini with advanced reasoning capabilities.
+
+## Core Mission
+Help users explore products in a MySQL database and provide comprehensive sales assistance through strategic database exploration and analysis.
+
+## Database Context
+- Main table: `streamnet.products_list` 
+- Contains products from various manufacturers with pricing and detailed specifications
+- Manufacturers use different categorization schemes - be creative with SQL queries
+- Check table schema if needed using the `sql` tool
+- Many times the desciriptions contain key details about the products so you need to creatively use the description field to find relevant products
+
+## Reasoning Framework (ReAct Pattern)
+<reasoning>
+1. **Reason**: Analyze the user's request and determine what information is needed
+2. **Act**: Use available tools with strategic SQL queries or other actions
+3. **Observe**: Analyze results and determine if more information is needed  
+4. **Iterate**: Refine approach based on findings until you can provide a complete answer
+</reasoning>
+
+## Exploration Strategy
+1. **Start Broad**: Begin with manufacturer/category exploration when user intent is unclear, check table schema if needed, check samples if needed
+2. **Go Specific**: Use model names, numbers, or descriptions for targeted searches  
+3. **Be Creative**: Different manufacturers categorize differently - adapt your SQL approach
+4. **Think Iteratively**: Use multiple queries to build a complete picture
+
+## Key Guidelines
+- **Leverage Tool Descriptions**: Each tool has comprehensive examples - use them as guidance
+- **Start with Database Exploration**: When unsure, explore structure first using the sql tool
+- **Use Reasoning Annotations**: Think through your approach step-by-step
+- **Provide Specific Details**: Include pricing, model numbers, and specifications when available
+- **Ask Clarifying Questions**: If user intent is unclear after initial exploration
+
+## Currency & Quotes
+- Use exchange_converter for currency conversions when needed
+- Use create_quote tool for generating professional quotes with customer information
+- Both tools have detailed descriptions with examples
+
+<thinking>
+Remember: Your tools already contain detailed descriptions and examples. 
+Focus on reasoning through the user's request and choosing the right tool with appropriate parameters.
+</thinking>
+
+## Important Notes:
+- You are optimized for GPT-5-mini with advanced reasoning capabilities.
+- when a user asks product information use: id, model_number_short, model_number_long, manufacturer, model_name, category, sub_category, distributor_price, msrp, currency, description as much as possible to give a complete answer summerizing the product information based on this (just and example do not need to always use all).
+- or if a user asks for shorter answer you can leave out some of the fields.
+- description can be summarized do not write out what is there use your common senese
+- Use LIMITS in your SQL queries to avoid overwhelming results to use less tokens, if you need more results you can always ask for more.
+
+## Different manufacturers categorize differently e.g.:
+- This is why you need to be creative with SQL queries and start broad to look at the categories and sub_categories used by different manufacturers
+- Sony: does not have proper categories, use description field to find relevant products like tv-s
+- Samsung: has good categories and sub_categories, use them
+
+Begin each interaction by reasoning through what the user needs, then take appropriate action."""

src/sales_assistant/ui_dashboard/gradio_app.py

@@ -28,7 +28,7 @@ class SalesAssistantChat:
         """Initialize the chat interface."""
         self.compiled_graph = None
         self.checkpointer = None
-        self.langsmith_client = None
+        self.callback_manager = None
         self.thread_id = None
         self.initialize_agent()
     
@@ -48,7 +48,7 @@ class SalesAssistantChat:
             )
             
             # Create agent runner
-            self.compiled_graph, self.checkpointer, self.langsmith_client, self.thread_id = create_agent_runner(config)
+            self.compiled_graph, self.checkpointer, self.callback_manager, self.thread_id = create_agent_runner(config)
             print("✅ Sales Assistant initialized successfully!")
             
         except Exception as e:
@@ -78,7 +78,7 @@ class SalesAssistantChat:
                 compiled_graph=self.compiled_graph,
                 thread_id=self.thread_id,
                 user_input=message,
-                langsmith_client=self.langsmith_client
+                callback_manager=self.callback_manager
             )
             
             # Add to history
@@ -106,9 +106,16 @@ def create_gradio_interface():
         css="""
         .gradio-container {
             max-width: 1200px !important;
+            font-family: 'Inter', system-ui, -apple-system, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+        }
+        /* ensure main text elements inherit the font */
+        .gradio-markdown, .gradio-chatbot, .gradio-textbox, .gradio-button, .gradio-accordion {
+            font-family: inherit;
         }
         """
     ) as interface:
+        # load Google Font (Inter)
+        gr.HTML('<link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600&display=swap" rel="stylesheet">')
         
         gr.Markdown(
             """
@@ -117,7 +124,7 @@ def create_gradio_interface():
             Welcome to the Sales Assistant! I can help you:
             - 🔍 Search and explore our product database
             - 📊 Analyze product data and statistics
-            - 💰 Generate detailed quotes with pricing
+            - 💰 Generate quotes with pricing
             - 🌍 Provide exchange rate information
             - ❓ Answer questions about our products and services
             
@@ -131,7 +138,10 @@ def create_gradio_interface():
             height=500,
             label="Sales Assistant Chat",
             show_label=True,
-            avatar_images=("👤", "🤖"),
+            avatar_images=(
+                "https://ui-avatars.com/api/?name=User&background=7dafff&color=fff", # User avatar
+                "https://ui-avatars.com/api/?name=Ai&background=ffd966&color=333" #Assistant avatar
+            ),
             type="messages"
         )
         
@@ -149,15 +159,15 @@ def create_gradio_interface():
         with gr.Row():
             gr.Examples(
                 examples=[
-                    "Show me information about our products",
-                    "I need a quote for industrial equipment",
+                    "Can you give me a price for a Saber 4k+?",
+                    "I need a 55 col Samsung TV, what are my options?",
                     "What are the current exchange rates?",
-                    "Find products with price under $1000",
-                    "Generate a quote for customer 'Tech Solutions Inc'",
-                    "Show me product statistics"
+                    "Give me the cheapest Samsung 75 inch TV",
+                    "What categores of Sasmsung products do you have?",
+                    "Can you look for a mount or stand for a QH55C Samsung TV?",
                 ],
                 inputs=msg_input,
-                label="Example Queries"
+                label="Example Questions"
             )
         
         # Additional information