Refactor code structure and remove redundant sections for improved readability and maintainability

.github/copilot-instructions.md

@@ -0,0 +1,12 @@
+This project is using uv so you can run the files using the uv commands.
+
+
+Be sure to:
+if you are using llm agents use the langchain or langgraph built in framework as much as possbile with states and pydantic if needed.
+Do NOT use custom written function if possible.
+Use this document if needed with the offical documentation:
+https://langchain-ai.github.io/langgraph/concepts/low_level/
+https://langchain-ai.github.io/langgraph/how-tos/graph-api/
+
+There is a mysql database (called: streamnet_prodcut_try) with the following tables and columns.
+You will use this in the chatbot retrieve data.

.gitignore

@@ -0,0 +1,94 @@
+# Environment files
+*.env
+.env*
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*checkpoint*
+
+# IPython
+profile_default/
+ipython_config.py
+
+# PyEnv
+.python-version
+
+# UV
+.venv/
+venv/
+ENV/
+env/
+
+# VS Code
+.vscode/
+*.code-workspace
+
+# IDE
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Project specific
+*.pem
+*.log
+
+# Temporary files
+*.tmp
+*.temp

README.md

@@ -0,0 +1,21 @@
+# Sales Assistant with Quote
+
+A sales bot that can answer questions about products and provide quotes based on a database.
+
+## Installation
+
+```bash
+uv sync
+```
+
+Or if you want to install it in editable mode:
+
+```bash
+uv pip install -e .
+```
+
+## To try out the sales assistant, run:
+
+```bash
+uv run python src/sales_assistant/main.py
+```

pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "sales-assistant-with-quote"
+version = "1.0.0"
+description = "A sales bot that can answer questions about products and provide quotes based on a database."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pandas>=2.3.1",
+    "pymysql>=1.1.1",
+    "python-dotenv>=1.1.1",
+    "sqlalchemy>=2.0.41",
+    "sshtunnel>=0.4.0",
+    "paramiko>=3.0.0,<4.0.0",
+    # for jupyter notebooks
+    "jupyter>=1.0.0",
+    "ipykernel>=6.25.2",
+    "langchain>=0.3.27",
+    "langgraph>=0.6.5",
+    "langchain-openai>=0.3.30",
+    "langchain-nvidia-ai-endpoints>=0.3.0",
+    "langsmith>=0.2.13",
+    "pydantic>=2.11.7",
+    "huggingface-hub>=0.34.4",
+    "langchain-huggingface>=0.3.1",
+]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"

src/sales_assistant/__init__.py

@@ -0,0 +1 @@
+# Sales Assistant Package

src/sales_assistant/agent_main/__init__.py

@@ -0,0 +1 @@
+# Sales Assistant Package

src/sales_assistant/agent_main/agent_graph.py

@@ -0,0 +1,49 @@
+import os
+import sys
+import uuid
+from typing import List, Dict, Any, Literal
+from langchain_core.tools import tool
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langgraph.graph import StateGraph, MessagesState, START, END
+from langgraph.prebuilt import ToolNode, tools_condition
+from langchain.chat_models import init_chat_model
+from langsmith import Client
+from dotenv import load_dotenv
+from .agent_node import agent_node
+from .tools_node import tool_node
+
+def create_agent_graph(checkpointer=None):
+    """
+    Create the ReAct database exploration agent using LangGraph's built-in components.
+    
+    Args:
+        checkpointer: Optional checkpointer for state persistence
+    """
+    # Initialize StateGraph with built-in MessagesState
+    workflow = StateGraph(MessagesState)
+    
+    # Add nodes using built-in components
+    workflow.add_node("agent", agent_node)
+    workflow.add_node("tools", tool_node) 
+    
+    # Add edges using built-in routing
+    workflow.add_edge(START, "agent")
+    
+    # Use built-in tools_condition for conditional routing
+    workflow.add_conditional_edges(
+        "agent",
+        tools_condition,  # Built-in condition that checks for tool calls
+        {
+            "tools": "tools",
+            END: END, 
+        }
+    )
+    
+    # Tools always return to agent for continued reasoning
+    workflow.add_edge("tools", "agent")
+    
+    # Compile the graph with optional checkpointer
+    if checkpointer:
+        return workflow.compile(checkpointer=checkpointer)
+    else:
+        return workflow.compile()

src/sales_assistant/agent_main/agent_node.py

@@ -0,0 +1,71 @@
+"""
+Basis agent node that creates the initial agent with the system prompt.
+Need to use the prompt from the prompts/system_prompt.py file
+"""
+import os
+from typing import Dict, Any
+from langchain_core.messages import SystemMessage
+from langgraph.graph import MessagesState
+from langchain_openai import ChatOpenAI
+from dotenv import load_dotenv
+from ..prompts.system_prompt import SYSTEM_PROMPT
+
+# Load environment variables
+load_dotenv()
+
+def agent_node(state: MessagesState) -> Dict[str, Any]:
+    """
+    Agent node that processes messages and generates responses using the LLM.
+    
+    Args:
+        state: MessagesState containing the conversation history
+        
+    Returns:
+        Dict containing the updated messages
+    """
+    # Get model configuration from environment
+    model_provider = os.getenv("MODEL_PROVIDER", "openai").lower()
+    model_name = os.getenv("MODEL_NAME", "gpt-5-mini")
+    
+    # Initialize the chat model based on provider
+    if model_provider == "openai":
+        # Check if model supports temperature
+        if "gpt-5" in model_name:
+            # GPT-5 models don't have temperature parameter
+            model = ChatOpenAI(
+                model=model_name,
+                api_key=os.getenv("OPENAI_API_KEY"),
+            )
+        else:
+            # Other models with temperature support
+            temperature = float(os.getenv("MODEL_TEMPERATURE", "0.1"))
+            model = ChatOpenAI(
+                model=model_name,
+                api_key=os.getenv("OPENAI_API_KEY"),
+                temperature=temperature,
+            )
+    else:
+        # Fallback to OpenAI if other providers not implemented
+        model = ChatOpenAI(
+            model=model_name,
+            api_key=os.getenv("OPENAI_API_KEY"),
+        )
+    
+    # Bind tools to the model
+    from .tools_node import get_all_tools
+    tools = get_all_tools()
+    model_with_tools = model.bind_tools(tools)
+    
+    # Get the current messages
+    messages = state["messages"]
+    
+    # Add system prompt if it's the first message or not present
+    if not messages or not isinstance(messages[0], SystemMessage):
+        system_message = SystemMessage(content=SYSTEM_PROMPT)
+        messages = [system_message] + messages
+    
+    # Generate response
+    response = model_with_tools.invoke(messages)
+    
+    # Return the updated state
+    return {"messages": [response]}

src/sales_assistant/agent_main/agent_runner.py

@@ -0,0 +1,262 @@
+import os
+import uuid
+from typing import Dict, Any, Optional, List
+from langchain_core.messages import HumanMessage, AIMessage
+from langgraph.graph import MessagesState
+from langgraph.checkpoint.memory import MemorySaver
+from langsmith import Client
+from dotenv import load_dotenv
+from pydantic import BaseModel, Field
+from .agent_graph import create_agent_graph
+
+# Load environment variables
+load_dotenv()
+
+
+class ConversationConfig(BaseModel):
+    """Configuration for the conversation."""
+    session_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    user_id: str = Field(default="default_user")
+    langsmith_project: str = Field(default_factory=lambda: os.getenv("LANGSMITH_PROJECT", "sales-assistant"))
+    enable_langsmith: bool = Field(default=True)
+
+
+def setup_langsmith_tracing(config: ConversationConfig) -> Optional[Client]:
+    """
+    Setup LangSmith tracing for the conversation.
+    
+    Args:
+        config: Configuration for the conversation
+        
+    Returns:
+        LangSmith client if enabled, None otherwise
+    """
+    if not config.enable_langsmith:
+        return None
+    
+    try:
+        # Set environment variables for LangSmith using the correct env var names
+        if os.getenv("LANGSMITH_API_KEY"):
+            os.environ["LANGCHAIN_TRACING_V2"] = os.getenv("LANGSMITH_TRACING_V2", "true")
+            os.environ["LANGCHAIN_PROJECT"] = config.langsmith_project
+            os.environ["LANGCHAIN_ENDPOINT"] = os.getenv("LANGSMITH_ENDPOINT", "https://api.smith.langchain.com")
+            os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGSMITH_API_KEY")
+            
+            client = Client()
+            return client
+    except Exception as e:
+        print(f"Warning: Could not setup LangSmith tracing: {e}")
+    
+    return None
+
+
+def create_agent_runner(config: ConversationConfig = None) -> tuple:
+    """
+    Create an agent runner with the compiled graph and LangGraph's built-in memory.
+    
+    Args:
+        config: Optional configuration for the conversation
+        
+    Returns:
+        Tuple of (compiled_graph, checkpointer, langsmith_client, thread_id)
+    """
+    if config is None:
+        config = ConversationConfig()
+    
+    # Setup LangSmith tracing
+    langsmith_client = setup_langsmith_tracing(config)
+    
+    # Create LangGraph's built-in memory checkpointer
+    checkpointer = MemorySaver()
+    
+    # Create the agent graph with checkpointing
+    compiled_graph = create_agent_graph(checkpointer)
+    
+    # Use session_id as thread_id for LangGraph's memory
+    thread_id = config.session_id
+    
+    return compiled_graph, checkpointer, langsmith_client, thread_id
+
+
+def run_conversation_turn(
+    compiled_graph, 
+    thread_id: str, 
+    user_input: str,
+    langsmith_client: Optional[Client] = None
+) -> str:
+    """
+    Run a single conversation turn with the agent using LangGraph's built-in state management.
+    
+    Args:
+        compiled_graph: The compiled LangGraph agent with checkpointer
+        thread_id: Thread ID for conversation persistence
+        user_input: User's input message
+        langsmith_client: Optional LangSmith client for tracing
+        
+    Returns:
+        Agent's response as a string
+    """
+    try:
+        # Create user message
+        user_message = HumanMessage(content=user_input)
+        
+        # Create the config for this conversation thread
+        config = {"configurable": {"thread_id": thread_id}}
+        
+        # Invoke the graph with the user message
+        # LangGraph will automatically handle state persistence
+        result = compiled_graph.invoke(
+            {"messages": [user_message]}, 
+            config=config
+        )
+        
+        # Get the assistant's response
+        assistant_message = result["messages"][-1]
+        assistant_response = assistant_message.content
+        
+        return assistant_response
+        
+    except Exception as e:
+        error_message = f"Error processing message: {str(e)}"
+        print(error_message)
+        return error_message
+
+
+def run_interactive_loop(config: ConversationConfig = None) -> None:
+    """
+    Run an interactive conversation loop with the agent using LangGraph's built-in state management.
+    
+    Args:
+        config: Optional configuration for the conversation
+    """
+    if config is None:
+        config = ConversationConfig()
+    
+    # Create agent runner with LangGraph's built-in memory
+    compiled_graph, checkpointer, langsmith_client, thread_id = create_agent_runner(config)
+    
+    print("🤖 Sales Assistant initialized!")
+    print(f"Using the following llm model: {os.getenv('MODEL_NAME', 'not set in .env')}")
+    print("💬 Type your questions about products or 'quit' to exit")
+    print(f"📊 Session ID: {config.session_id}")
+    print(f"🧵 Thread ID: {thread_id}")
+    if langsmith_client:
+        print(f"📈 LangSmith tracking enabled - Project: {config.langsmith_project}")
+    print("-" * 50)
+    
+    while True:
+        try:
+            user_input = input("\n👤 You: ").strip()
+            
+            if user_input.lower() in ['quit', 'exit', 'bye']:
+                print("👋 Goodbye!")
+                break
+            
+            if not user_input:
+                continue
+            
+            print("🔄 Processing...")
+            response = run_conversation_turn(
+                compiled_graph, 
+                thread_id, 
+                user_input, 
+                langsmith_client
+            )
+            
+            print(f"\n🤖 Assistant: {response}")
+            
+        except KeyboardInterrupt:
+            print("\n👋 Goodbye!")
+            break
+        except Exception as e:
+            print(f"\n❌ Error: {str(e)}")
+
+
+def get_conversation_history(compiled_graph, thread_id: str) -> List[Dict[str, Any]]:
+    """
+    Get the conversation history from LangGraph's checkpointer.
+    
+    Args:
+        compiled_graph: The compiled graph with checkpointer
+        thread_id: Thread ID for conversation
+        
+    Returns:
+        List of messages in the conversation
+    """
+    try:
+        config = {"configurable": {"thread_id": thread_id}}
+        # Get the current state from LangGraph's checkpointer
+        state = compiled_graph.get_state(config)
+        messages = state.values.get("messages", [])
+        
+        # Convert messages to dict format
+        history = []
+        for msg in messages:
+            if hasattr(msg, "type"):
+                history.append({
+                    "type": msg.type,
+                    "content": msg.content,
+                    "timestamp": getattr(msg, "id", str(uuid.uuid4()))
+                })
+        return history
+    except Exception as e:
+        print(f"Error getting conversation history: {e}")
+        return []
+
+
+def clear_conversation_history(compiled_graph, thread_id: str) -> None:
+    """
+    Clear the conversation history in LangGraph's checkpointer.
+    
+    Args:
+        compiled_graph: The compiled graph with checkpointer
+        thread_id: Thread ID for conversation
+    """
+    try:
+        config = {"configurable": {"thread_id": thread_id}}
+        # Note: LangGraph's MemorySaver doesn't have a direct clear method
+        # You would need to implement this based on your specific checkpointer
+        print(f"Note: To clear history, restart with a new thread_id")
+    except Exception as e:
+        print(f"Error clearing conversation history: {e}")
+
+
+# Example usage function
+def demo_agent_runner():
+    """
+    Demo function to show how to use the agent runner with LangGraph's built-in state management.
+    """
+    # Create configuration
+    config = ConversationConfig(
+        session_id="demo_session",
+        user_id="demo_user",
+        langsmith_project="sales-assistant-demo"
+    )
+    
+    # Create agent runner with LangGraph's built-in memory
+    compiled_graph, checkpointer, langsmith_client, thread_id = create_agent_runner(config)
+    
+    # Run a few example interactions
+    test_queries = [
+        "What products do you have from Samsung?",
+        "Show me the cheapest camara available from angekis", 
+        "Can you find me Samsung outdoor tv-s?"
+    ]
+    
+    print("🚀 Running demo conversations...")
+    
+    for query in test_queries:
+        print(f"\n👤 Demo Query: {query}")
+        response = run_conversation_turn(compiled_graph, thread_id, query, langsmith_client)
+        print(f"🤖 Response: {response}")
+    
+    # Show conversation history
+    print("\n📝 Conversation History:")
+    history = get_conversation_history(compiled_graph, thread_id)
+    for i, msg in enumerate(history, 1):
+        print(f"{i}. [{msg['type']}]: {msg['content'][:100]}...")
+
+
+if __name__ == "__main__":
+    # Run interactive loop
+    run_interactive_loop()

src/sales_assistant/agent_main/tools_node.py

@@ -0,0 +1,43 @@
+"""
+Tools node that are using the agent_tools folder's tools
+"""
+from typing import List
+from langchain_core.tools import BaseTool
+from langgraph.prebuilt import ToolNode
+
+# Import all the tools from agent_tools
+from ..agent_tools.describe_table import describe_table
+from ..agent_tools.execute_advanced_query import execute_advanced_query
+from ..agent_tools.get_distinct_values import get_distinct_values
+from ..agent_tools.get_product_by_criteria import search_products_by_criteria
+from ..agent_tools.get_samples_data import get_sample_data
+from ..agent_tools.get_table_statistics import get_table_statistics
+from ..agent_tools.get_exchange_rates import exchange_converter
+from ..agent_tools.execute_sql_query import execute_sql_query
+from ..agent_tools.create_quote import create_quote
+
+
+def get_all_tools() -> List[BaseTool]:
+    """
+    Get all available tools for the agent.
+    
+    Returns:
+        List of all available tools
+    """
+    simple_tool_list = [execute_sql_query, exchange_converter, create_quote]
+    advanced_tool_list = [
+        describe_table,
+        execute_advanced_query,
+        get_distinct_values,
+        search_products_by_criteria,
+        get_sample_data,
+        get_table_statistics,
+        exchange_converter,
+        create_quote
+    ]
+
+    return simple_tool_list
+
+
+# Create the tool node using LangGraph's built-in ToolNode
+tool_node = ToolNode(get_all_tools())

src/sales_assistant/agent_tools/__init__.py

@@ -0,0 +1 @@
+# Sales Assistant Package

src/sales_assistant/agent_tools/agent_tools_utils.py

@@ -0,0 +1,69 @@
+'''
+Functions that help create and run the agent with its tools.
+'''
+import pandas as pd
+import logging
+from sales_assistant.db.utils.db_utils import read_sql
+
+# Configure logging for SQL queries
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def get_data_for_agent(query: str, return_type: str = "dict_records") -> str:
+    """
+    Helper function to get data from the database for the agent.
+    
+    Args:
+        query (str): SQL query string to execute.
+        
+    Returns:
+        str: Formatted string of query results or error message.
+    """
+    try:
+        # Log the SQL query being executed
+        print(f"🔍 SQL Query: {query}")
+        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()
+
+        if return_type == "string":
+            if df_original.empty:
+                df_formated = "No data found."
+            else:
+                df_formated = df_original.to_string(index=False)
+
+        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
+    
+
+def create_results_metadata(results_orignal: 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.
+        
+    Returns:
+        dict: Metadata including counts of records and columns.
+    """
+
+    shape = results_orignal.shape
+    rows = shape[0]
+    cols = shape[1]
+
+    metadata = {
+        'row count': rows
+    }
+    
+    return metadata

src/sales_assistant/agent_tools/create_quote.py

@@ -0,0 +1,348 @@
+"""
+Quote creation tool that generates professional quotes in Markdown format using product IDs from database.
+This tool queries products by ID and creates structured quotes with proper Markdown tables.
+"""
+
+import os
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+from collections import Counter
+from langchain_core.tools import tool
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage
+from dotenv import load_dotenv
+
+from .quote_template import (
+    Quote, QuoteItem, CustomerInfo, 
+    generate_markdown_quote,
+    GREETING_PROMPT, INTRO_PROMPT,
+    generate_product_description
+)
+from .get_exchange_rates import convert_amount
+from .agent_tools_utils import get_data_for_agent
+
+# Load environment variables
+load_dotenv()
+
+
+def fetch_products_by_ids(product_ids: List[int], target_currency: str = "EUR") -> List[Dict[str, Any]]:
+    """
+    Fetch product details from database by product IDs and convert prices to target currency.
+    
+    Args:
+        product_ids: List of product IDs to fetch
+        target_currency: Currency to convert prices to
+        
+    Returns:
+        List of product dictionaries with converted prices
+    """
+    try:
+        # Query to get product details including model numbers
+        product_ids_str = ",".join(map(str, product_ids))
+        query = f"""
+        SELECT id, manufacturer, model_name, model_number_long, model_number_short, 
+               description, msrp, currency, category, sub_category
+        FROM streamnet.products_list 
+        WHERE id IN ({product_ids_str})
+        """
+        
+        # Execute query
+        df_original, df_formatted = get_data_for_agent(query, return_type="dict_records")
+        
+        if not df_formatted or len(df_formatted) == 0:
+            return []
+        
+        # Process and convert currencies
+        products = []
+        for product in df_formatted:
+            original_currency = product.get('currency', 'EUR')
+            msrp_price = float(product.get('msrp', 0))
+            
+            # Convert currency if needed
+            if original_currency != target_currency and msrp_price > 0:
+                conversion_result = convert_amount(
+                    original_currency, 
+                    target_currency, 
+                    msrp_price
+                )
+                if "error" not in conversion_result:
+                    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
+            
+            # Build product name
+            product_name = product.get('model_name', '') or product.get('model_number_long', '') or f"Product {product.get('id')}"
+            
+            products.append({
+                'id': product.get('id'),
+                'product_name': product_name,
+                'model_number_short': product.get('model_number_short'),
+                'model_number_long': product.get('model_number_long'),
+                'unit_price': converted_price,
+                'currency': target_currency,
+                'original_currency': original_currency,
+                'manufacturer': product.get('manufacturer', ''),
+                'category': product.get('category', ''),
+                'sub_category': product.get('sub_category', ''),
+                'original_description': product.get('description', '')
+            })
+        
+        return products
+        
+    except Exception as e:
+        print(f"Error fetching products: {e}")
+        return []
+
+
+def generate_dynamic_content(prompt: str, max_retries: int = 2) -> str:
+    """
+    Generate dynamic content using LLM.
+    
+    Args:
+        prompt: The prompt for content generation
+        max_retries: Number of retry attempts if generation fails
+        
+    Returns:
+        Generated content string
+    """
+    try:
+        # Initialize the LLM
+        model = ChatOpenAI(
+            model=os.getenv("MODEL_NAME", "gpt-4o-mini"),
+            api_key=os.getenv("OPENAI_API_KEY"),
+            temperature=0.3  # Slightly creative but controlled
+        )
+        
+        # Generate content
+        response = model.invoke([HumanMessage(content=prompt)])
+        return response.content.strip()
+        
+    except Exception as e:
+        print(f"Warning: LLM content generation failed: {e}")
+        # Fallback to generic content
+        if "greeting" in prompt.lower():
+            return "Dear Valued Customer, thank you for your interest in our products."
+        else:
+            return "We are pleased to provide you with this detailed quotation for your consideration."
+
+
+def create_quote_file(quote: Quote, content: str) -> str:
+    """
+    Save the quote to a Markdown file in the created_quotes directory.
+    
+    Args:
+        quote: Quote object with metadata
+        content: The formatted quote content
+        
+    Returns:
+        Path to the saved file
+    """
+    # Ensure the created_quotes directory exists
+    quotes_dir = "/Users/krinya/sales_assistant_with_quote/src/sales_assistant/created_quotes"
+    os.makedirs(quotes_dir, exist_ok=True)
+    
+    # Generate unique filename
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    customer_name = quote.customer.name.replace(" ", "_").replace("/", "_")
+    filename = f"quote_{quote.quote_id}_{customer_name}_{timestamp}.md"
+    filepath = os.path.join(quotes_dir, filename)
+    
+    # Write the quote to file
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(content)
+    
+    return filepath
+
+
+@tool
+def create_quote(
+    product_ids: List[int],
+    customer_name: str,
+    customer_email: Optional[str] = None,
+    customer_company: Optional[str] = None,
+    target_currency: str = "EUR",
+    notes: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    A quote creation tool that generates 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
+    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
+        customer_name (str): Customer's full name (required)
+        customer_email (Optional[str]): Customer's email address
+        customer_company (Optional[str]): Customer's company name
+        target_currency (str): Currency for the final quote (EUR, USD, HUF)
+        notes (Optional[str]): Additional notes for the quote
+        
+    Example usage:
+        create_quote(
+            product_ids=[123, 123, 456, 789],  # 2x product 123, 1x product 456, 1x product 789
+            customer_name="John Smith",
+            customer_email="john@company.com",
+            customer_company="Tech Solutions Inc",
+            target_currency="EUR"
+        )
+    
+    Returns:
+        Dict containing quote details and file path.
+    """
+    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"}
+        
+        # Count quantities for each product ID
+        product_quantities = Counter(product_ids)
+        unique_product_ids = list(product_quantities.keys())
+        
+        # Fetch product details from database
+        products_data = fetch_products_by_ids(unique_product_ids, target_currency)
+        
+        if not products_data:
+            return {"error": "No products found for the provided IDs"}
+        
+        # Create customer info
+        customer = CustomerInfo(
+            name=customer_name,
+            email=customer_email,
+            company=customer_company
+        )
+        
+        # Initialize LLM for description generation
+        llm = ChatOpenAI(
+            model=os.getenv("MODEL_NAME", "gpt-4o-mini"),
+            api_key=os.getenv("OPENAI_API_KEY"),
+            temperature=0.3
+        )
+        
+        # Create quote items with quantities and LLM-generated descriptions
+        quote_items = []
+        for product_data in products_data:
+            product_id = product_data['id']
+            quantity = product_quantities[product_id]
+            
+            # Generate concise description using LLM
+            product_info = {
+                'manufacturer': product_data['manufacturer'],
+                'model_name': product_data['product_name'],
+                'category': product_data['category'],
+                'sub_category': product_data['sub_category'],
+                'description': product_data['original_description']
+            }
+            llm_description = generate_product_description(product_info, llm)
+            
+            quote_item = QuoteItem(
+                product_id=product_id,
+                product_name=product_data['product_name'],
+                model_number_short=product_data['model_number_short'],
+                model_number_long=product_data['model_number_long'],
+                description=llm_description,
+                quantity=quantity,
+                unit_price=product_data['unit_price'],
+                currency=target_currency
+            )
+            quote_items.append(quote_item)
+        
+        # Create the quote object
+        quote = Quote(
+            customer=customer,
+            items=quote_items,
+            currency=target_currency,
+            notes=notes
+        )
+        
+        # Generate LLM content
+        company_info = f" from {customer_company}" if customer_company else ""
+        
+        # Generate greeting
+        greeting_prompt = GREETING_PROMPT.format(
+            customer_name=customer_name,
+            company_info=company_info,
+            company=customer_company or "N/A"
+        )
+        greeting = generate_dynamic_content(greeting_prompt)
+        
+        # Generate introduction
+        product_summary = ", ".join([item.product_name for item in quote_items[:3]])
+        if len(quote_items) > 3:
+            product_summary += f" and {len(quote_items) - 3} other item(s)"
+            
+        intro_prompt = INTRO_PROMPT.format(
+            customer_name=customer_name,
+            company=customer_company or "your organization",
+            product_summary=product_summary,
+            item_count=len(quote_items)
+        )
+        introduction = generate_dynamic_content(intro_prompt)
+        
+        # Generate the complete Markdown quote
+        quote_template = generate_markdown_quote(quote)
+        final_quote = quote_template.format(
+            greeting=greeting,
+            introduction=introduction
+        )
+        
+        # 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": {
+                "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
+                ]
+            }
+        }
+        
+        return response
+        
+    except Exception as e:
+        return {"error": f"Quote creation failed: {str(e)}"}
+
+
+def create_sample_quote_from_ids():
+    """Create a sample quote using product IDs for testing purposes."""
+    
+    # Sample with some repeated IDs to test quantity handling
+    sample_product_ids = [760, 760, 763, 765, 765, 768]  # 2x product 760, 1x product 763, 2x product 765, 1x product 768
+    
+    result = create_quote.invoke({
+        "product_ids": sample_product_ids,
+        "customer_name": "Jane Doe",
+        "customer_email": "jane.doe@example.com",
+        "customer_company": "Example Corp",
+        "target_currency": "EUR",
+        "notes": "Sample quote generated from product IDs"
+    })
+    
+    return result

src/sales_assistant/agent_tools/describe_table.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict
+from langchain_core.tools import tool
+import pandas as pd
+from .agent_tools_utils import *
+
+
+@tool
+def describe_table(sql_query: str = "DESCRIBE streamnet.products_list;") -> Dict[str, Any]:
+    """
+    Explore the schema of a database table using an SQL query.
+    You can modify the query to explore different tables or get specific schema information.
+    
+    Args:
+        sql_query (str): SQL query to explore table schema. 
+        Examples:
+        - "DESCRIBE streamnet.products_list;"
+        - "SHOW COLUMNS FROM streamnet.products_list;"
+        - "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE FROM information_schema.COLUMNS WHERE TABLE_NAME = 'products_list';"
+        
+    Returns:
+        Dict[str, Any]: Table schema information from the query results.
+    """
+    try:
+        results_orignal, results_formated = get_data_for_agent(sql_query, return_type="dict_records")
+        metadata = create_results_metadata(results_orignal)
+
+        result_dict = {
+            "query_executed": sql_query,
+            "data_from_db": results_formated,
+            "metadata": metadata
+        }
+        
+        return result_dict
+       
+    except Exception as e:
+        return {"error": f"Schema exploration failed: {str(e)}"}

src/sales_assistant/agent_tools/execute_advanced_query.py

@@ -0,0 +1,37 @@
+from typing import Any, Dict, List
+from langchain_core.tools import tool
+from .agent_tools_utils import *
+
+
+@tool
+def execute_advanced_query(sql_query: str) -> Dict[str, Any]:
+    """
+    Execute any advanced SQL query for complex data exploration, joins, subqueries, and analytical operations.
+    This tool gives you complete flexibility to run sophisticated database operations.
+    
+    Args:
+        sql_query (str): Any valid SQL query for advanced operations.
+        
+        Examples:
+            - "SELECT manufacturer, category, AVG(msrp) as avg_price FROM streamnet.products_list WHERE msrp > 0 GROUP BY manufacturer, category HAVING COUNT(*) > 5 ORDER BY avg_price DESC;"
+            - "SELECT * FROM streamnet.products_list WHERE msrp = (SELECT MAX(msrp) FROM streamnet.products_list WHERE manufacturer = 'Apple');"
+            - "SELECT manufacturer, COUNT(*) as products, ROUND(AVG(msrp), 2) as avg_price, ROUND(STDDEV(msrp), 2) as price_std FROM streamnet.products_list GROUP BY manufacturer HAVING COUNT(*) > 10;"
+            - "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 advanced query execution.
+    """
+    try:
+        results_orignal, results_formated = get_data_for_agent(sql_query, return_type="dict_records")
+        metadata = create_results_metadata(results_orignal)
+
+        result_dict = {
+            "query_executed": sql_query,
+            "data_from_db": results_formated,
+            "metadata": metadata
+        }
+        
+        return result_dict
+       
+    except Exception as e:
+        return {"error": f"Advanced query execution failed: {str(e)}"}

src/sales_assistant/agent_tools/execute_sql_query.py

@@ -0,0 +1,79 @@
+from typing import Any, Dict, List, Optional, Literal
+from langchain_core.tools import tool
+from .agent_tools_utils import *
+
+
+@tool
+def execute_sql_query(
+    sql_query: str, 
+    query_type: Optional[Literal["search", "statistics", "distinct_values", "sample", "advanced"]] = None
+) -> Dict[str, Any]:
+    """
+    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.
+    
+    Args:
+        sql_query (str): Any valid SQL query to execute against the streamnet.products_list table.
+        query_type (Optional[str]): Hint about the type of query for better organization. Options:
+            - "search": Product searches with filtering and criteria
+            - "statistics": Statistical analysis and aggregations  
+            - "distinct_values": Exploring unique values and patterns
+            - "sample": Data sampling and exploration
+            - "advanced": Complex queries with joins, subqueries, analytics
+            
+    Query Examples by Type:
+    
+    SEARCH QUERIES:
+    - "SELECT * FROM streamnet.products_list WHERE manufacturer = 'Samsung' AND category = 'Electronics' LIMIT 15;"
+    - "SELECT * FROM streamnet.products_list WHERE description LIKE '%wireless%' AND msrp BETWEEN 50 AND 200;"
+    - "SELECT * FROM streamnet.products_list WHERE model_name LIKE '%Pro%' ORDER BY msrp DESC LIMIT 10;"
+    - "SELECT manufacturer, model_name, msrp FROM streamnet.products_list WHERE sub_category IN ('Smartphones', 'Tablets') ORDER BY msrp;"
+    
+    STATISTICS QUERIES:
+    - "SELECT COUNT(*) as total_products, AVG(msrp) as avg_price, MIN(msrp) as min_price, MAX(msrp) as max_price FROM streamnet.products_list;"
+    - "SELECT manufacturer, COUNT(*) as product_count, AVG(msrp) as avg_price FROM streamnet.products_list GROUP BY manufacturer ORDER BY product_count DESC;"
+    - "SELECT category, sub_category, COUNT(*) as count FROM streamnet.products_list GROUP BY category, sub_category ORDER BY count DESC;"
+    - "SELECT currency, COUNT(*) as products, MIN(msrp) as min_price, MAX(msrp) as max_price FROM streamnet.products_list GROUP BY currency;"
+    
+    DISTINCT VALUES QUERIES:
+    - "SELECT manufacturer, COUNT(*) as count FROM streamnet.products_list GROUP BY manufacturer ORDER BY count DESC LIMIT 20;"
+    - "SELECT category, COUNT(*) as count FROM streamnet.products_list GROUP BY category ORDER BY count DESC;"
+    - "SELECT manufacturer, sub_category, COUNT(*) as count FROM streamnet.products_list WHERE manufacturer = 'Samsung' GROUP BY manufacturer, sub_category;"
+    - "SELECT DISTINCT model_name FROM streamnet.products_list WHERE category = 'Electronics' ORDER BY model_name;"
+    - "SELECT currency, AVG(msrp) as avg_price, COUNT(*) as product_count FROM streamnet.products_list GROUP BY currency;"
+    
+    SAMPLE QUERIES:
+    - "SELECT * FROM streamnet.products_list LIMIT 20;"
+    - "SELECT * FROM streamnet.products_list WHERE manufacturer = 'Samsung' ORDER BY RAND() LIMIT 15;"
+    - "SELECT * FROM streamnet.products_list WHERE category = 'camera' AND sub_category LIKE '%accessories%' LIMIT 10;"
+    - "SELECT manufacturer, category, COUNT(*) FROM streamnet.products_list GROUP BY manufacturer, category LIMIT 25;"
+    - "SELECT * FROM streamnet.products_list WHERE msrp > 100 ORDER BY RAND() LIMIT 30;"
+    
+    ADVANCED QUERIES:
+    - "SELECT manufacturer, category, AVG(msrp) as avg_price FROM streamnet.products_list WHERE msrp > 0 GROUP BY manufacturer, category HAVING COUNT(*) > 5 ORDER BY avg_price DESC;"
+    - "SELECT * FROM streamnet.products_list WHERE msrp = (SELECT MAX(msrp) FROM streamnet.products_list WHERE manufacturer = 'Apple');"
+    - "SELECT manufacturer, COUNT(*) as products, ROUND(AVG(msrp), 2) as avg_price, ROUND(STDDEV(msrp), 2) as price_std FROM streamnet.products_list GROUP BY manufacturer HAVING COUNT(*) > 10;"
+    - "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.
+    """
+    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
+       
+    except Exception as e:
+        return {
+            "error": f"SQL query execution failed: {str(e)}",
+            "query_executed": sql_query,
+            "query_type": query_type
+        }

src/sales_assistant/agent_tools/get_distinct_values.py

@@ -0,0 +1,37 @@
+from typing import Any, Dict, List
+from langchain_core.tools import tool
+from .agent_tools_utils import *
+
+
+@tool
+def get_distinct_values(sql_query: str = "SELECT manufacturer, COUNT(*) as count FROM streamnet.products_list GROUP BY manufacturer ORDER BY count DESC LIMIT 20;") -> Dict[str, Any]:
+    """
+    Explore distinct values and patterns using custom SQL queries with grouping, filtering, and aggregation.
+    You can dynamically modify this to explore any column combinations, apply filters, and get insights.
+    
+    Args:
+        sql_query (str): SQL query to explore distinct values and patterns.
+        
+        Examples:
+        - "SELECT category, COUNT(*) as count FROM streamnet.products_list GROUP BY category ORDER BY count DESC;"
+        - "SELECT manufacturer, sub_category, COUNT(*) as count FROM streamnet.products_list WHERE manufacturer = 'Samsung' GROUP BY manufacturer, sub_category;"
+        - "SELECT DISTINCT model_name FROM streamnet.products_list WHERE category = 'Electronics' ORDER BY model_name;"
+        - "SELECT currency, AVG(msrp) as avg_price, COUNT(*) as product_count FROM streamnet.products_list GROUP BY currency;"
+        
+    Returns:
+        Dict[str, Any]: Distinct values with their counts and patterns.
+    """
+    try:
+        results_orignal, results_formated = get_data_for_agent(sql_query, return_type="dict_records")
+        metadata = create_results_metadata(results_orignal)
+        
+        result_dict = {
+            "query_executed": sql_query,
+            "data_from_db": results_formated,
+            "metadata": metadata
+        }
+        
+        return result_dict
+       
+    except Exception as e:
+        return {"error": f"Distinct values exploration failed: {str(e)}"}

src/sales_assistant/agent_tools/get_exchange_rates.py

@@ -0,0 +1,66 @@
+from typing import Any, Dict
+from langchain_core.tools import tool
+
+# Fixed exchange rates relative to HUF (kept simple and deterministic)
+_EXCHANGE_RATES = {
+    "HUF": 1.0,
+    "EUR": 400.0,
+    "USD": 340.0
+}
+
+
+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.
+
+    Returns a small dict on success: {
+      "converted_amount": float,
+      "exchange_rate": float,  # target per one unit of source
+      "from": str,
+      "to": str
+    }
+
+    On error returns {"error": "message"}.
+    """
+    fc = _normalize_currency(from_currency)
+    tc = _normalize_currency(to_currency)
+
+    if not fc or not tc:
+        return {"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()))}"}
+
+    try:
+        amt = float(amount)
+    except Exception:
+        return {"error": "Amount must be a number"}
+
+    if amt < 0:
+        return {"error": "Amount must be non-negative"}
+
+    if fc == tc:
+        return {"converted_amount": round(amt, precision), "exchange_rate": 1.0, "from": fc, "to": tc}
+
+    # 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))
+    }
+
+
+@tool
+def exchange_converter(from_currency: str = "EUR", to_currency: str = "HUF", amount: float = 1.0, precision: int = 2) -> Dict[str, Any]:
+    """
+    Currency converter tool. That can convert between EUR, USD, and HUF, allowing specification of precision.
+    """
+    return convert_amount(from_currency, to_currency, amount, precision)

src/sales_assistant/agent_tools/get_product_by_criteria.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict, List
+from langchain_core.tools import tool
+from .agent_tools_utils import *
+
+
+@tool
+def search_products_by_criteria(sql_query: str = "SELECT * FROM streamnet.products_list WHERE manufacturer LIKE '%Samsung%' LIMIT 10;") -> Dict[str, Any]:
+    """
+    Search for products using dynamic SQL queries with complex filtering, sorting, and conditions.
+    You can build sophisticated searches with multiple criteria, price ranges, text matching, and more.
+    
+    Args:
+        sql_query (str): SQL query to search for products with custom criteria.
+            Examples:
+            - "SELECT * FROM streamnet.products_list WHERE manufacturer = 'Samsung' AND category = 'Electronics' LIMIT 15;"
+            - "SELECT * FROM streamnet.products_list WHERE description LIKE '%wireless%' AND msrp BETWEEN 50 AND 200;"
+            - "SELECT * FROM streamnet.products_list WHERE model_name LIKE '%Pro%' ORDER BY msrp DESC LIMIT 10;"
+            - "SELECT manufacturer, model_name, msrp FROM streamnet.products_list WHERE sub_category IN ('Smartphones', 'Tablets') ORDER BY msrp;"
+        
+    Returns:
+        Dict[str, Any]: Matching products based on search criteria.
+    """
+    try:
+        results_orignal, results_formated = get_data_for_agent(sql_query, return_type="dict_records")
+        results_metadata = create_results_metadata(results_orignal)
+        
+        result_dict = {
+            "query_executed": sql_query,
+            "data_from_db": results_formated,
+            "metadata": results_metadata
+        }
+        
+        return result_dict
+       
+    except Exception as e:
+        return {"error": f"Product search failed: {str(e)}"}

src/sales_assistant/agent_tools/get_samples_data.py

@@ -0,0 +1,57 @@
+from typing import Any, Dict, Optional
+from langchain_core.tools import tool
+import pandas as pd
+from .agent_tools_utils import *
+
+
+@tool
+def get_sample_data(sql_query: str = "SELECT * FROM streamnet.products_list", method: Optional[str] = "limit", sample_size: Optional[int] = 20) -> Dict[str, Any]:
+    """
+    Get sample data using a custom SQL query with different sampling methods.
+    You can modify this query to explore specific data patterns, filter by conditions, or sample different subsets.
+    
+    Args:
+        sql_query (str): Base SQL query to retrieve data (without LIMIT or ORDER BY RAND()).
+            Examples:
+            - "SELECT * FROM streamnet.products_list"
+            - "SELECT * FROM streamnet.products_list WHERE manufacturer = 'Samsung'"
+            - "SELECT * FROM streamnet.products_list WHERE category = 'camera' AND sub_category LIKE '%accessories%'"
+            - "SELECT manufacturer, category, COUNT(*) FROM streamnet.products_list GROUP BY manufacturer, category"
+            - "SELECT * FROM streamnet.products_list WHERE msrp > 100"
+        
+        method (Optional[str]): Sampling method to use. Options:
+            - "limit": Use LIMIT clause to get first N records
+            - "random": Use ORDER BY RAND() LIMIT to get random N records  
+            - None: Return all results without limiting (ignores sample_size)
+            
+        sample_size (Optional[int]): Number of sample records to retrieve (default is 20). Only used if method is "limit" or "random".
+        
+    Returns:
+        Dict[str, Any]: Sample rows from the query execution with metadata.
+    """
+    try:
+        # Build the final query based on the method
+        final_query = sql_query.rstrip(';')  # Remove trailing semicolon if present
+        
+        if method == "limit":
+            final_query += f" LIMIT {sample_size};"
+        elif method == "random":
+            final_query += f" ORDER BY RAND() LIMIT {sample_size};"
+        elif method is None or method.lower() == "none":
+            final_query += ";"
+        else:
+            result = f"Invalid value for the method arg: '{method}'. Must be 'limit', 'random', or None"
+        
+        results_orignal, results_formated = get_data_for_agent(final_query, return_type="dict_records")
+        metadata = create_results_metadata(results_orignal)
+
+        result_info = {
+            "query_executed": final_query,
+            "data_from_db": results_formated,
+            "metadata": metadata
+        }
+        
+        return result_info
+       
+    except Exception as e:
+        return {"error": f"Data sampling failed: {str(e)}"}

src/sales_assistant/agent_tools/get_table_statistics.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict, List
+from langchain_core.tools import tool
+from .agent_tools_utils import *
+
+
+@tool
+def get_table_statistics(sql_query: str = "SELECT COUNT(*) as total_rows, COUNT(DISTINCT manufacturer) as unique_manufacturers, COUNT(DISTINCT category) as unique_categories FROM streamnet.products_list;") -> Dict[str, Any]:
+    """
+    Get statistics and analytical insights using custom SQL queries with aggregations.
+    You can modify this to get different statistical views, price analytics, distribution analysis, and more.
+    
+    Args:
+        sql_query (str): SQL query to generate statistics and insights.
+            Examples:
+            - "SELECT COUNT(*) as total_products, AVG(msrp) as avg_price, MIN(msrp) as min_price, MAX(msrp) as max_price FROM streamnet.products_list;"
+            - "SELECT manufacturer, COUNT(*) as product_count, AVG(msrp) as avg_price FROM streamnet.products_list GROUP BY manufacturer ORDER BY product_count DESC;"
+            - "SELECT category, sub_category, COUNT(*) as count FROM streamnet.products_list GROUP BY category, sub_category ORDER BY count DESC;"
+            - "SELECT currency, COUNT(*) as products, MIN(msrp) as min_price, MAX(msrp) as max_price FROM streamnet.products_list GROUP BY currency;"
+        
+    Returns:
+        Dict[str, Any]: Statistical results and insights.
+    """
+    try:
+        results_orignal, results_formated = get_data_for_agent(sql_query, return_type="dict_records")
+        metadata = create_results_metadata(results_orignal)
+
+        result_dict = {
+            "query_executed": sql_query,
+            "data_from_db": results_formated,
+            "metadata": metadata
+        }
+        
+        return result_dict
+       
+    except Exception as e:
+        return {"error": f"Statistics gathering failed: {str(e)}"}

src/sales_assistant/agent_tools/quote_template.py

@@ -0,0 +1,242 @@
+"""
+Quote template structures and Pydantic models for quote generation.
+This module contains the data models and templates used for creating professional quotes in Markdown format.
+"""
+
+from datetime import datetime, timedelta
+from typing import List, Optional
+from pydantic import BaseModel, Field
+import uuid
+
+
+class QuoteItem(BaseModel):
+    """Individual item in a quote with pricing details."""
+    product_id: int = Field(..., description="Database product ID")
+    product_name: str = Field(..., description="Name/model of the product")
+    model_number_short: Optional[str] = Field(None, description="Short model number")
+    model_number_long: Optional[str] = Field(None, description="Long model number")
+    description: str = Field(..., description="Detailed description of the product")
+    quantity: int = Field(..., gt=0, description="Quantity of items")
+    unit_price: float = Field(..., ge=0, description="MSRP price per unit")
+    currency: str = Field(default="EUR", description="Currency code")
+    
+    @property
+    def display_product_id(self) -> str:
+        """Get the product ID to display (prefer model_number_short, then model_number_long, then database ID)."""
+        if self.model_number_short:
+            return self.model_number_short
+        elif self.model_number_long:
+            return self.model_number_long
+        else:
+            return str(self.product_id)
+    
+    @property
+    def total_price(self) -> float:
+        """Calculate total price for this item."""
+        return self.quantity * self.unit_price
+
+
+class CustomerInfo(BaseModel):
+    """Customer information for the quote."""
+    name: str = Field(..., description="Customer name")
+    email: Optional[str] = Field(None, description="Customer email")
+    company: Optional[str] = Field(None, description="Company name")
+
+
+class Quote(BaseModel):
+    """Complete quote with all details - no tax calculations."""
+    quote_id: str = Field(default_factory=lambda: f"QT-{uuid.uuid4().hex[:8].upper()}")
+    customer: CustomerInfo
+    items: List[QuoteItem] = Field(..., min_items=1)
+    currency: str = Field(default="EUR", description="Quote currency")
+    created_date: datetime = Field(default_factory=datetime.now)
+    valid_until: datetime = Field(default_factory=lambda: datetime.now() + timedelta(days=30))
+    notes: Optional[str] = Field(None, description="Additional notes")
+    
+    @property
+    def grand_total(self) -> float:
+        """Calculate grand total of all items."""
+        return sum(item.total_price for item in self.items)
+
+
+# LLM prompts for dynamic content generation
+GREETING_PROMPT = """
+Generate a professional, warm greeting for a sales quote. The greeting should be 1-2 lines maximum.
+Consider the customer information: {customer_name} {company_info}
+
+Make it personal but professional. Examples:
+- "Dear [Name], thank you for your interest in our products."
+- "Hello [Name], we're pleased to provide you with the following quotation."
+
+Customer Name: {customer_name}
+Company: {company}
+"""
+
+INTRO_PROMPT = """
+Generate a professional introduction paragraph (2-3 sentences) for a sales quote.
+The introduction should:
+- Reference the products being quoted
+- Express confidence in meeting their needs
+- Be professional but friendly
+- Be concise (max 3 sentences)
+
+Customer: {customer_name}
+Company: {company}
+Products being quoted: {product_summary}
+Number of items: {item_count}
+
+Generate only the introduction paragraph, no additional formatting.
+"""
+
+DESCRIPTION_GENERATION_PROMPT = """You are a professional product description writer for technology equipment quotes. 
+
+Given the following product information:
+- Manufacturer: {manufacturer}
+- Model Name: {model_name}
+- Category: {category}
+- Sub-category: {sub_category}
+- Current Description: {current_description}
+
+Write a professional, concise product description in less than 30 words.
+Focus on key features, capabilities, and benefits. Make it suitable for a business quote.
+
+Write only the description of the product, no additional text."""
+
+
+def generate_product_description(product_info: dict, llm) -> str:
+    """
+    Generate a concise product description using LLM.
+    
+    Args:
+        product_info: Dictionary containing product details
+        llm: Language model instance
+        
+    Returns:
+        Generated product description (max 30 words)
+    """
+    try:
+        prompt = DESCRIPTION_GENERATION_PROMPT.format(
+            manufacturer=product_info.get('manufacturer', 'N/A'),
+            model_name=product_info.get('model_name', 'N/A'),
+            category=product_info.get('category', 'N/A'),
+            sub_category=product_info.get('sub_category', 'N/A'),
+            current_description=product_info.get('description', 'N/A')
+        )
+        
+        response = llm.invoke(prompt)
+        description = response.content.strip()
+            
+        return description
+        
+    except Exception as e:
+        # Fallback to a short version of the original description
+        original_desc = product_info.get('description', 'Professional technology equipment')
+        words = original_desc.split()
+        if len(words) > 30:
+            return ' '.join(words[:30])
+        return original_desc
+
+
+def format_currency(amount: float, currency: str) -> str:
+    """Format currency amount with proper symbol."""
+    symbols = {"EUR": "€", "USD": "$", "HUF": "Ft"}
+    symbol = symbols.get(currency, currency)
+    
+    if currency == "HUF":
+        return f"{amount:,.0f} {symbol}"
+    else:
+        return f"{symbol}{amount:,.2f}"
+
+
+def generate_markdown_quote(quote: Quote) -> str:
+    """
+    Generate a professional quote in Markdown format.
+    """
+    # Format dates
+    created_str = quote.created_date.strftime("%B %d, %Y")
+    valid_until_str = quote.valid_until.strftime("%B %d, %Y")
+    
+    # Build customer section
+    customer_section = f"**{quote.customer.name}**"
+    if quote.customer.company:
+        customer_section += f"  \n{quote.customer.company}"
+    if quote.customer.email:
+        customer_section += f"  \n📧 {quote.customer.email}"
+    
+    # Create Markdown table for products
+    markdown_table = """
+| Product Name | Product ID | Description | Quantity | Unit Price | Total Price |
+|--------------|------------|-------------|----------|------------|-------------|
+"""
+    
+    for item in quote.items:
+        # Clean description for table (remove line breaks but keep full text)
+        clean_desc = item.description.replace('\n', ' ').replace('\r', ' ')
+        
+        unit_price_str = format_currency(item.unit_price, quote.currency)
+        total_price_str = format_currency(item.total_price, quote.currency)
+        
+        markdown_table += f"| {item.product_name} | {item.display_product_id} | {clean_desc} | {item.quantity} | {unit_price_str} | {total_price_str} |\n"
+    
+    # Grand total
+    grand_total_str = format_currency(quote.grand_total, quote.currency)
+    
+    # Complete Markdown template
+    markdown_template = f"""# Professional Product Quotation
+
+## STREAMNET SOLUTIONS
+
+---
+
+**Quote ID:** {quote.quote_id}  
+**Date:** {created_str}  
+**Valid Until:** {valid_until_str}
+
+---
+
+## Quote To:
+
+{customer_section}
+
+---
+
+{{greeting}}
+
+{{introduction}}
+
+---
+
+## Products
+
+{markdown_table}
+
+---
+
+## **Grand Total: {grand_total_str}**
+
+---
+
+## Terms and Conditions
+
+- This quotation is valid for 30 days from the date of issue
+- Prices are subject to change without notice after expiration
+- Payment terms: Net 30 days from invoice date
+- All prices exclude shipping and handling unless otherwise specified
+- Products are subject to availability
+- Technical specifications may vary, please confirm before ordering
+- Returns accepted within 14 days in original condition
+- Warranty terms as per manufacturer specifications
+
+---
+
+### Contact Information
+
+📧 **Email:** sales@streamnet.com  
+📞 **Phone:** +1 (555) 123-4567
+
+---
+
+*Generated on {created_str}*
+"""
+    
+    return markdown_template

src/sales_assistant/created_quotes/quote_QT-B4849588_Kristof_Proba_20250825_114359.md

@@ -0,0 +1,63 @@
+# Professional Product Quotation
+
+## STREAMNET SOLUTIONS
+
+---
+
+**Quote ID:** QT-B4849588  
+**Date:** August 25, 2025  
+**Valid Until:** September 24, 2025
+
+---
+
+## Quote To:
+
+**Kristof Proba**  
+📧 kristofkristof@gmail.com
+
+---
+
+Option 1: Dear Kristof Proba, thank you for your interest—please find your tailored quotation below.
+
+Option 2: Hello Kristof, we’re pleased to provide the following quote and look forward to assisting you.
+
+Kristof Proba, please find a quote for two items: the Saber U20 (WHITE) and the Saber 5X (Saber Light). We’re confident these products will meet your needs and deliver the reliable performance you expect.
+
+---
+
+## Products
+
+
+| Product Name | Product ID | Description | Quantity | Unit Price | Total Price |
+|--------------|------------|-------------|----------|------------|-------------|
+| Saber U20 (WHITE) | ANG2-20FHD-01W | Angekis Saber U20 (White) — compact professional camera delivering high-quality imaging, reliable performance, versatile mounting and connectivity, and a discreet white finish for seamless commercial integration. | 2 | 312,460 Ft | 624,920 Ft |
+| Saber 5X (Saber Light) | U3-5FHD6 | angekis Saber 5X (Saber Light) PTZ camera — 5× zoom, 90° HFOV, simultaneous USB 3.0 60 fps and RS232 connectivity for high-frame-rate capture and seamless integration. | 3 | 321,300 Ft | 963,900 Ft |
+
+
+---
+
+## **Grand Total: 1,588,820 Ft**
+
+---
+
+## Terms and Conditions
+
+- This quotation is valid for 30 days from the date of issue
+- Prices are subject to change without notice after expiration
+- Payment terms: Net 30 days from invoice date
+- All prices exclude shipping and handling unless otherwise specified
+- Products are subject to availability
+- Technical specifications may vary, please confirm before ordering
+- Returns accepted within 14 days in original condition
+- Warranty terms as per manufacturer specifications
+
+---
+
+### Contact Information
+
+📧 **Email:** sales@streamnet.com  
+📞 **Phone:** +1 (555) 123-4567
+
+---
+
+*Generated on August 25, 2025*

src/sales_assistant/db/utils/db_connections.py

@@ -0,0 +1,105 @@
+"""
+Database utilities for MySQL operations through SSH tunnel.
+"""
+
+import os
+from dotenv import load_dotenv
+load_dotenv()
+import pandas as pd
+from sqlalchemy import create_engine, text
+from sshtunnel import SSHTunnelForwarder
+import pymysql
+from typing import Optional, Union, List, Dict, Any
+        
+# SSH Tunnel details
+ssh_hostname = os.getenv('SSH_HOSTNAME')
+ssh_port = int(os.getenv('SSH_PORT', 22))
+ssh_username = os.getenv('SSH_USERNAME')
+ssh_pkey_path = os.getenv('SSH_PKEY_PATH')
+
+# Convert relative path to absolute path if needed
+if ssh_pkey_path and not os.path.isabs(ssh_pkey_path):
+    # Get the current file's directory and navigate to find the correct path
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    print(f"Current directory: {current_dir}")
+    # We're in db/utils/, and the path in .env is "db/pemfile/db_pem.pem"
+    # So we need to go up to sales_assistant/ and then follow the path
+    sales_assistant_dir = os.path.dirname(os.path.dirname(current_dir))
+    ssh_pkey_path = os.path.join(sales_assistant_dir, ssh_pkey_path)
+    print(f"Converted SSH_PKEY_PATH to absolute path: {ssh_pkey_path}")
+        
+# MySQL database details
+mysql_host = os.getenv('MYSQL_HOST')
+mysql_port = int(os.getenv('MYSQL_PORT', 3306))
+mysql_user = os.getenv('MYSQL_USER')
+mysql_password = os.getenv('MYSQL_PASSWORD')
+mysql_db = os.getenv('MYSQL_DB')
+
+
+def validate_config(required_vars):
+
+    missing_vars = [var for var in required_vars if not os.getenv(var)]
+    if len(missing_vars) == 0:
+        is_valid = True
+    else:
+        is_valid = False
+    
+    return_dict = {
+        "is_valid": is_valid,
+        "missing_vars": missing_vars
+    }
+
+    return return_dict
+
+def connect_ssh_tunnel():
+    """
+    Establish an SSH tunnel to the MySQL server.
+    Returns the SSHTunnelForwarder object.
+    """
+    try:
+        tunnel = SSHTunnelForwarder(
+            (ssh_hostname, ssh_port),
+            ssh_username=ssh_username,
+            ssh_pkey=ssh_pkey_path,
+            remote_bind_address=(mysql_host, mysql_port)
+        )
+        tunnel.start()
+        return tunnel
+    except Exception as e:
+        print(f"Error establishing SSH tunnel: {e}")
+        raise
+
+def disconnect(engine, tunnel):
+    """
+    Disconnect the SQLAlchemy engine and stop the SSH tunnel.
+    """
+    try:
+        if engine:
+            engine.dispose()
+        if tunnel:
+            tunnel.stop()
+    except Exception as e:
+        print(f"Error during disconnection: {e}")
+        raise
+
+
+def create_db_engine(tunnel: SSHTunnelForwarder, charset: str = "utf8mb4"):
+    """
+    Create a SQLAlchemy engine connected to the MySQL database through the SSH tunnel.
+    """
+    try:
+        local_port = tunnel.local_bind_port
+        database_url = f"mysql+pymysql://{mysql_user}:{mysql_password}@127.0.0.1:{local_port}/{mysql_db}?charset={charset}"
+        engine = create_engine(
+            database_url,
+            connect_args={
+                "connect_timeout": 60*5,
+                "read_timeout": 60*5,
+                "write_timeout": 60*5,
+                "charset": charset
+            }
+        )
+        return engine
+    except Exception as e:
+        print(f"Error creating database engine: {e}")
+        raise

src/sales_assistant/db/utils/db_utils.py

@@ -0,0 +1,75 @@
+"""
+Database utilities for querying and writing to MySQL through an SSH tunnel.
+"""
+
+from dotenv import load_dotenv
+load_dotenv()
+import pandas as pd
+from sqlalchemy import text
+from .db_connections import connect_ssh_tunnel, create_db_engine, disconnect
+
+def read_sql(query_str: str) -> pd.DataFrame:
+    """
+    Execute a read SQL query and return the results as a pandas DataFrame.
+    Uses pandas built-in read_sql_query method.
+    
+    Args:
+        query_str: SQL query string to execute
+        
+    Returns:
+        pandas DataFrame with query results
+    """
+    tunnel = None
+    engine = None
+    try:
+        tunnel = connect_ssh_tunnel()
+        engine = create_db_engine(tunnel)
+        
+        df = pd.read_sql_query(sql=text(query_str), con=engine)
+        
+        return df
+    except Exception as e:
+        print(f"Error executing read query: {e}")
+        # return an empty DataFrame on error
+        return pd.DataFrame()
+    finally:
+        disconnect(engine, tunnel)
+
+
+def write_to_table(df: pd.DataFrame, table_name: str, if_exists: str = 'append', schema: str = None) -> bool:
+    """
+    Write a pandas DataFrame to a MySQL table using pandas built-in to_sql method.
+    
+    Args:
+        df: pandas DataFrame to write
+        table_name: Name of the target table
+        if_exists: What to do if table exists ('append', 'replace', 'fail')
+        schema: Database schema name (optional)
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    tunnel = None
+    engine = None
+    try:
+        tunnel = connect_ssh_tunnel()
+        engine = create_db_engine(tunnel)
+        
+        df.to_sql(
+            name=table_name,
+            con=engine,
+            if_exists=if_exists,
+            index=False,
+            schema=schema,
+            method='multi',
+            chunksize=1000
+        )
+        
+        print(f"Successfully wrote {len(df)} rows to table '{table_name}' (mode: {if_exists})")
+        return True
+        
+    except Exception as e:
+        print(f"Error writing DataFrame to table: {e}")
+        return False
+    finally:
+        disconnect(engine, tunnel)

src/sales_assistant/main.py

@@ -0,0 +1,226 @@
+"""
+Main entry point for the Sales Assistant application.
+
+This file serves as the primary interface to run the sales assistant agent.
+It uses the agent runner from agent_main/agent_runner.py to create and manage
+the conversational agent with database exploration capabilities.
+"""
+import os
+import sys
+from typing import Optional
+from dotenv import load_dotenv
+
+# Add the src directory to the path so we can import from sales_assistant
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from sales_assistant.agent_main.agent_runner import (
+    ConversationConfig, 
+    run_interactive_loop, 
+    demo_agent_runner,
+    create_agent_runner,
+    run_conversation_turn
+)
+
+# Load environment variables
+load_dotenv()
+
+
+def check_environment_setup() -> bool:
+    """
+    Check if the environment is properly set up for the agent.
+    
+    Returns:
+        True if environment is properly configured, False otherwise
+    """
+    required_vars = [
+        "OPENAI_API_KEY",
+        "MODEL_PROVIDER",
+        "MODEL_NAME",
+        "MYSQL_HOST",
+        "MYSQL_USER", 
+        "MYSQL_PASSWORD",
+        "MYSQL_DB"
+    ]
+    
+    missing_vars = []
+    for var in required_vars:
+        if not os.getenv(var):
+            missing_vars.append(var)
+    
+    if missing_vars:
+        print("❌ Missing required environment variables:")
+        for var in missing_vars:
+            print(f"   - {var}")
+        print("\n💡 Please set these variables in your .env file")
+        return False
+    
+    print("✅ Environment configuration looks good!")
+    return True
+
+
+def create_custom_config(
+    session_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+    enable_langsmith: bool = True
+) -> ConversationConfig:
+    """
+    Create a custom configuration for the agent.
+    
+    Args:
+        session_id: Optional custom session ID
+        user_id: Optional user identifier
+        enable_langsmith: Whether to enable LangSmith tracing
+        
+    Returns:
+        ConversationConfig object
+    """
+    config = ConversationConfig(
+        enable_langsmith=enable_langsmith,
+        langsmith_project=os.getenv("LANGSMITH_PROJECT", "sales-assistant-prod")
+    )
+    
+    if session_id:
+        config.session_id = session_id
+    if user_id:
+        config.user_id = user_id
+    
+    return config
+
+
+def run_sales_assistant(
+    interactive: bool = True,
+    demo_mode: bool = False,
+    custom_config: Optional[ConversationConfig] = None
+) -> None:
+    """
+    Main function to run the sales assistant.
+    
+    Args:
+        interactive: Whether to run in interactive mode
+        demo_mode: Whether to run demo conversations
+        custom_config: Optional custom configuration
+    """
+    print("🚀 Starting Sales Assistant...")
+    
+    # Check environment setup
+    if not check_environment_setup():
+        return
+    
+    try:
+        if demo_mode:
+            print("🎮 Running in demo mode...")
+            demo_agent_runner()
+        elif interactive:
+            print("💬 Starting interactive mode...")
+            config = custom_config or ConversationConfig()
+            run_interactive_loop(config)
+        else:
+            print("⚙️ Agent initialized and ready for programmatic use")
+            config = custom_config or ConversationConfig()
+            compiled_graph, checkpointer, langsmith_client, thread_id = create_agent_runner(config)
+            print(f"📊 Session ID: {config.session_id}")
+            print(f"🧵 Thread ID: {thread_id}")
+            print("💡 Use the returned objects to run conversations programmatically")
+            return compiled_graph, checkpointer, langsmith_client, thread_id
+            
+    except KeyboardInterrupt:
+        print("\n👋 Sales Assistant stopped by user")
+    except Exception as e:
+        print(f"❌ Error running Sales Assistant: {str(e)}")
+        sys.exit(1)
+
+
+def single_query(query: str, config: Optional[ConversationConfig] = None) -> str:
+    """
+    Run a single query against the agent without interactive mode.
+    
+    Args:
+        query: The question to ask the agent
+        config: Optional configuration
+        
+    Returns:
+        Agent's response
+    """
+    if not check_environment_setup():
+        return "Environment not properly configured"
+    
+    try:
+        config = config or ConversationConfig()
+        compiled_graph, checkpointer, langsmith_client, thread_id = create_agent_runner(config)
+        
+        response = run_conversation_turn(
+            compiled_graph, 
+            thread_id, 
+            query, 
+            langsmith_client
+        )
+        
+        return response
+        
+    except Exception as e:
+        return f"Error processing query: {str(e)}"
+
+
+def main():
+    """
+    Main entry point when running the script directly.
+    """
+    import argparse
+    
+    parser = argparse.ArgumentParser(
+        description="Sales Assistant - Database-powered product inquiry agent"
+    )
+    parser.add_argument(
+        "--mode", 
+        choices=["interactive", "demo", "single"],
+        default="interactive",
+        help="Mode to run the assistant in"
+    )
+    parser.add_argument(
+        "--query",
+        type=str,
+        help="Single query to run (only for single mode)"
+    )
+    parser.add_argument(
+        "--no-langsmith",
+        action="store_true",
+        help="Disable LangSmith tracing"
+    )
+    parser.add_argument(
+        "--session-id",
+        type=str,
+        help="Custom session ID"
+    )
+    parser.add_argument(
+        "--user-id", 
+        type=str,
+        help="User identifier"
+    )
+    
+    args = parser.parse_args()
+    
+    # Create configuration
+    config = create_custom_config(
+        session_id=args.session_id,
+        user_id=args.user_id,
+        enable_langsmith=not args.no_langsmith
+    )
+    
+    if args.mode == "single":
+        if not args.query:
+            print("❌ --query is required for single mode")
+            sys.exit(1)
+        
+        print(f"🔍 Processing query: {args.query}")
+        response = single_query(args.query, config)
+        print(f"🤖 Response: {response}")
+        
+    elif args.mode == "demo":
+        run_sales_assistant(interactive=False, demo_mode=True, custom_config=config)
+        
+    else:  # interactive mode
+        run_sales_assistant(interactive=True, demo_mode=False, custom_config=config)
+
+
+if __name__ == "__main__":
+    main()

src/sales_assistant/prompts/system_prompt.py

@@ -0,0 +1,141 @@
+
+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!"""

test_files/db_test.py

@@ -0,0 +1,81 @@
+from sales_assistant.db.utils.db_connections import validate_config
+from sales_assistant.db.utils.db_utils import read_sql, write_to_table
+import pandas as pd
+
+# Validate configuration
+required_vars = [
+    'SSH_HOSTNAME', 'SSH_USERNAME', 'SSH_PKEY_PATH',
+    'MYSQL_HOST', 'MYSQL_USER', 'MYSQL_PASSWORD', 'MYSQL_DB'
+]
+validate_config_vars = validate_config(required_vars)
+print("Config validation:", validate_config_vars)
+
+# Test basic connection
+print("\n=== Testing basic connection ===")
+test_connection = read_sql("SELECT 1 as test_column;")
+print("Connection test result:")
+print(test_connection)
+
+# Test reading from products table
+print("\n=== Testing products table read ===")
+test_product_table = read_sql("SELECT * FROM streamnet.products_list LIMIT 5;")
+print("Products table sample:")
+print(test_product_table.head())
+print(f"Shape: {test_product_table.shape}")
+
+# Test writing a sample DataFrame
+print("\n=== Testing DataFrame write (create new table) ===")
+sample_data = pd.DataFrame({
+    'id': [1, 2, 3],
+    'name': ['Test Product 1', 'Test Product 2', 'Test Product 3'],
+    'price': [10.99, 20.50, 15.75],
+    'description': ['Sample description 1', 'Sample description 2', 'Sample description 3']
+})
+
+print("Sample data to write:")
+print(sample_data)
+
+# Create new table using convenience function
+success = write_to_table(
+    df=sample_data, 
+    table_name='test_products',
+    schema='streamnet',
+    if_exists='replace'  # Use replace to create new table
+)
+
+if success:
+    print("✅ Create table test successful!")
+    
+    # Test appending more data
+    print("\n=== Testing DataFrame append ===")
+    additional_data = pd.DataFrame({
+        'id': [4, 5],
+        'name': ['Test Product 4', 'Test Product 5'],
+        'price': [25.00, 30.99],
+        'description': ['Sample description 4', 'Sample description 5']
+    })
+    
+    print("Additional data to append:")
+    print(additional_data)
+    
+    append_success = write_to_table(
+        df=additional_data,
+        table_name='test_products',
+        schema='streamnet',
+        if_exists='append'
+    )
+    
+    if append_success:
+        print("✅ Append test successful!")
+        
+        # Read back all the data
+        print("\n=== Verifying all written data ===")
+        read_back = read_sql("SELECT * FROM streamnet.test_products ORDER BY id;")
+        print("All data in test table:")
+        print(read_back)
+        print(f"Total rows: {len(read_back)}")
+    else:
+        print("❌ Append test failed!")
+        
+else:
+    print("❌ Create table test failed!")

test_files/quote_test.py

@@ -0,0 +1,171 @@
+"""
+Test script for the quote generation tool.
+"""
+
+import sys
+import os
+
+# Add the src directory to the path so we can import from sales_assistant
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from sales_assistant.agent_tools.create_quote import create_quote, create_sample_quote
+
+
+def test_basic_quote():
+    """Test basic quote creation functionality."""
+    print("=== Testing Basic Quote Creation ===")
+    
+    # Test data
+    sample_items = [
+        {
+            "product_name": "Samsung Galaxy S24 Ultra",
+            "description": "Samsung Galaxy S24 Ultra 512GB, Titanium Black, 5G smartphone with S Pen",
+            "quantity": 1,
+            "unit_price": 1399.99,
+            "currency": "EUR"
+        },
+        {
+            "product_name": "Apple MacBook Pro 14\"",
+            "description": "MacBook Pro 14-inch, M3 Pro chip, 18GB RAM, 512GB SSD, Space Black",
+            "quantity": 2,
+            "unit_price": 2499.00,
+            "currency": "EUR"
+        }
+    ]
+    
+    # Invoke the tool
+    result = create_quote.invoke({
+        "customer_name": "Alice Johnson",
+        "customer_email": "alice.johnson@company.com",
+        "customer_company": "Innovation Labs Inc.",
+        "customer_address": "456 Tech Street, Silicon Valley, CA 94000",
+        "customer_phone": "+1 (555) 987-6543",
+        "items": sample_items,
+        "target_currency": "EUR",
+        "tax_rate": 0.21,  # 21% VAT
+        "notes": "Corporate discount applied"
+    })
+    
+    print("Result:")
+    print(result)
+    return result
+
+
+def test_currency_conversion():
+    """Test quote creation with currency conversion."""
+    print("\n=== Testing Currency Conversion ===")
+    
+    # Items in different currencies
+    mixed_currency_items = [
+        {
+            "product_name": "Dell XPS 15",
+            "description": "Dell XPS 15 laptop, Intel i7, 16GB RAM, 1TB SSD",
+            "quantity": 1,
+            "unit_price": 1899.99,
+            "currency": "USD"  # Will be converted to EUR
+        },
+        {
+            "product_name": "Sony Camera",
+            "description": "Sony Alpha 7R V mirrorless camera with 61MP sensor",
+            "quantity": 1,
+            "unit_price": 3899.00,
+            "currency": "EUR"  # Already in target currency
+        }
+    ]
+    
+    result = create_quote.invoke({
+        "customer_name": "Bob Wilson",
+        "customer_email": "bob@techstudio.com",
+        "customer_company": "TechStudio Photography",
+        "items": mixed_currency_items,
+        "target_currency": "EUR"
+    })
+    
+    print("Result:")
+    print(result)
+    return result
+
+
+def test_single_item_quote():
+    """Test quote with single item."""
+    print("\n=== Testing Single Item Quote ===")
+    
+    single_item = [{
+        "product_name": "iPad Pro 12.9\"",
+        "description": "iPad Pro 12.9-inch (6th generation) with M2 chip, 128GB, WiFi",
+        "quantity": 3,
+        "unit_price": 1199.00,
+        "currency": "EUR"
+    }]
+    
+    result = create_quote.invoke({
+        "customer_name": "Carol Davis",
+        "customer_email": "carol@school.edu",
+        "customer_company": "Mountain View School District",
+        "items": single_item,
+        "target_currency": "EUR",
+        "tax_rate": 0.0,  # Tax-exempt organization
+        "notes": "Educational institution - tax exempt"
+    })
+    
+    print("Result:")
+    print(result)
+    return result
+
+
+def test_error_handling():
+    """Test error handling in quote creation."""
+    print("\n=== Testing Error Handling ===")
+    
+    # Test missing customer name
+    print("Test 1: Missing customer name")
+    result1 = create_quote.invoke({
+        "customer_name": "",
+        "items": [{"product_name": "Test", "description": "Test", "quantity": 1, "unit_price": 100}]
+    })
+    print("Result:", result1)
+    
+    # Test empty items
+    print("\nTest 2: Empty items list")
+    result2 = create_quote.invoke({
+        "customer_name": "Test Customer",
+        "items": []
+    })
+    print("Result:", result2)
+    
+    # Test invalid item data
+    print("\nTest 3: Invalid item data")
+    result3 = create_quote.invoke({
+        "customer_name": "Test Customer",
+        "items": [{"product_name": "Test", "quantity": "invalid", "unit_price": "invalid"}]
+    })
+    print("Result:", result3)
+
+
+def test_sample_quote_function():
+    """Test the sample quote creation function."""
+    print("\n=== Testing Sample Quote Function ===")
+    
+    result = create_sample_quote()
+    print("Sample quote result:")
+    print(result)
+    return result
+
+
+if __name__ == "__main__":
+    print("🧪 Starting Quote Generation Tool Tests\n")
+    
+    try:
+        # Run all tests
+        test_basic_quote()
+        test_currency_conversion() 
+        test_single_item_quote()
+        test_sample_quote_function()
+        test_error_handling()
+        
+        print("\n✅ All tests completed!")
+        
+    except Exception as e:
+        print(f"\n❌ Test failed with error: {e}")
+        import traceback
+        traceback.print_exc()

test_files/test_product_id_quotes.py

@@ -0,0 +1,158 @@
+"""
+Test script for the new product ID-based quote generation tool.
+"""
+
+import sys
+import os
+
+# Add the src directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from sales_assistant.agent_tools.create_quote import create_quote, create_sample_quote_from_ids
+
+
+def test_product_id_quote():
+    """Test the new product ID-based quote creation."""
+    print("🧪 Testing Product ID-based Quote Generation")
+    print("=" * 50)
+    
+    # First, let's see what products are available in the database
+    print("📋 Testing with sample product IDs...")
+    
+    # Test with some actual product IDs (including duplicates for quantity)
+    sample_product_ids = [760, 760, 763, 765, 765, 768]  # 2x product 760, 1x product 763, 2x product 765, 1x product 768
+    
+    result = create_quote.invoke({
+        "product_ids": sample_product_ids,
+        "customer_name": "Maria Rodriguez",
+        "customer_email": "maria.rodriguez@techstart.com",
+        "customer_company": "TechStart Innovations",
+        "target_currency": "EUR",
+        "notes": "Startup package deal"
+    })
+    
+    print("📊 Result:")
+    if result.get('success'):
+        print("✅ Quote created successfully!")
+        print(f"📄 Quote ID: {result['quote_id']}")
+        print(f"👤 Customer: {result['customer_name']}")
+        print(f"💰 Grand Total: €{result['grand_total']:,.2f}")
+        print(f"📦 Unique Products: {result['unique_products']}")
+        print(f"🔢 Total Items: {result['total_items']}")
+        print(f"📄 File Format: {result['file_format']}")
+        print(f"💾 Saved to: {result['file_path']}")
+        
+        # Show quote summary
+        print("\n📊 Quote Summary:")
+        print("-" * 40)
+        for item in result['quote_summary']['items']:
+            print(f"• ID {item['product_id']}: {item['name']} (Qty: {item['quantity']}) - €{item['total']:,.2f}")
+        print("-" * 40)
+        print(f"GRAND TOTAL: €{result['quote_summary']['grand_total']:,.2f}")
+        
+        # Show first 25 lines of the generated Markdown file
+        print("\n📄 Generated Markdown Quote (preview):")
+        print("-" * 60)
+        try:
+            with open(result['file_path'], 'r', encoding='utf-8') as f:
+                lines = f.readlines()
+                for i, line in enumerate(lines[:25]):
+                    print(line.rstrip())
+                if len(lines) > 25:
+                    print("... (truncated for preview)")
+        except Exception as e:
+            print(f"Could not read quote file: {e}")
+            
+    else:
+        print("❌ Quote creation failed:")
+        print(result.get('error', 'Unknown error'))
+    
+    return result
+
+
+def test_different_currencies():
+    """Test quote generation with different currencies."""
+    print("\n\n💱 Testing Currency Conversion")
+    print("=" * 50)
+    
+    # Test with USD as target currency
+    result = create_quote.invoke({
+        "product_ids": [760, 763, 765],  # 1 of each
+        "customer_name": "John Williams",
+        "customer_company": "Global Tech Solutions",
+        "target_currency": "USD",
+        "notes": "USD pricing for US customer"
+    })
+    
+    if result.get('success'):
+        print(f"✅ USD Quote: ${result['grand_total']:,.2f}")
+        print(f"📄 File: {result['file_path']}")
+    else:
+        print(f"❌ USD Quote failed: {result.get('error')}")
+
+
+def test_error_cases():
+    """Test error handling."""
+    print("\n\n⚠️ Testing Error Handling")
+    print("=" * 50)
+    
+    # Test with invalid product IDs
+    print("Test 1: Invalid product IDs")
+    result1 = create_quote.invoke({
+        "product_ids": [999999, 999998],  # Likely non-existent IDs
+        "customer_name": "Test Customer"
+    })
+    print(f"Result: {result1}")
+    
+    # Test with empty product IDs
+    print("\nTest 2: Empty product IDs")
+    result2 = create_quote.invoke({
+        "product_ids": [],
+        "customer_name": "Test Customer"
+    })
+    print(f"Result: {result2}")
+    
+    # Test with missing customer name
+    print("\nTest 3: Missing customer name")
+    result3 = create_quote.invoke({
+        "product_ids": [760, 763],
+        "customer_name": ""
+    })
+    print(f"Result: {result3}")
+
+
+def test_sample_quote_function():
+    """Test the sample quote function."""
+    print("\n\n🎯 Testing Sample Quote Function")
+    print("=" * 50)
+    
+    result = create_sample_quote_from_ids()
+    print("Sample quote result:")
+    if result.get('success'):
+        print(f"✅ Quote ID: {result['quote_id']}")
+        print(f"💰 Total: €{result['grand_total']:,.2f}")
+        print(f"📄 File: {result['file_path']}")
+    else:
+        print(f"❌ Failed: {result.get('error')}")
+
+
+if __name__ == "__main__":
+    print("🚀 Starting Product ID-based Quote Generation Tests\n")
+    
+    try:
+        # Run all tests
+        main_result = test_product_id_quote()
+        test_different_currencies()
+        test_sample_quote_function()
+        test_error_cases()
+        
+        print("\n✅ All tests completed!")
+        
+        if main_result and main_result.get('success'):
+            print(f"\n🎉 Check out your generated Markdown quote at:")
+            print(f"📄 {main_result['file_path']}")
+        
+    except Exception as e:
+        print(f"\n❌ Test failed with error: {e}")
+        import traceback
+        traceback.print_exc()

test_files/tools_test.py

@@ -0,0 +1,184 @@
+from sales_assistant.agent_tools.describe_table import describe_table
+from sales_assistant.agent_tools.get_samples_data import get_sample_data
+from sales_assistant.agent_tools.execute_advanced_query import execute_advanced_query
+from sales_assistant.agent_tools.get_distinct_values import get_distinct_values
+from sales_assistant.agent_tools.get_product_by_criteria import search_products_by_criteria
+from sales_assistant.agent_tools.get_table_statistics import get_table_statistics
+
+def test_describe_table_tool():
+    """
+    Test the describe_table tool to ensure it retrieves schema information correctly.
+    """
+    print("\n=== Testing describe_table tool ===")
+    
+    # Test default query
+    print("Test 1: Default DESCRIBE query")
+    # Since describe_table is a LangChain tool, we need to invoke it properly
+    result = describe_table.invoke({})
+    print("Result:")
+    print(result)
+    
+    # Test with custom query
+    print("\nTest 2: Custom query")
+    custom_query = "SHOW TABLES FROM streamnet;"
+    result2 = describe_table.invoke({"sql_query": custom_query})
+    print("Result:")
+    print(result2)
+
+def test_get_sample_data_tool():
+    """
+    Test the get_sample_data tool to ensure it retrieves sample data correctly with different methods.
+    """
+    print("\n=== Testing get_sample_data tool ===")
+    
+    # Test default method (limit with default sample_size=5)
+    print("Test 1: Default method (limit, sample_size=5)")
+    result = get_sample_data.invoke({})
+    print("Result:")
+    print(result)
+    
+    # Test limit method with custom sample_size
+    print("Test 2: Limit method with sample_size=3")
+    result2 = get_sample_data.invoke({
+        "sql_query": "SELECT * FROM streamnet.products_list WHERE category = 'camera'",
+        "method": "limit",
+        "sample_size": 3
+    })
+    print("Result:")
+    print(result2)
+    
+    # Test random method
+    print("Test 3: Random method with sample_size=2")
+    result3 = get_sample_data.invoke({
+        "sql_query": "SELECT manufacturer, model_name FROM streamnet.products_list",
+        "method": "random",
+        "sample_size": 2
+    })
+    print("Result:")
+    print(result3)
+    
+    # Test None method (all results)
+    print("Test 4: None method (all results)")
+    result4 = get_sample_data.invoke({
+        "sql_query": "SELECT manufacturer, COUNT(*) as count FROM streamnet.products_list GROUP BY manufacturer",
+        "method": None,
+        "sample_size": 10  # This is ignored
+    })
+    print("Result:")
+    print(result4)
+    
+    # Test "none" string method (alternative way)
+    print("Test 5: 'none' string method (all results)")
+    result5 = get_sample_data.invoke({
+        "sql_query": "SELECT category, COUNT(*) as count FROM streamnet.products_list GROUP BY category",
+        "method": "none",
+        "sample_size": 5 # This is ignored
+    })
+    print("Result:")
+    print(result5)
+
+def test_execute_advanced_query_tool():
+    """
+    Test the execute_advanced_query tool to ensure it executes complex SQL queries correctly.
+    """
+    print("\n=== Testing execute_advanced_query tool ===")
+    
+    # Test basic advanced query
+    print("Test 1: Basic advanced query with aggregation")
+    query1 = "SELECT manufacturer, COUNT(*) as product_count, AVG(msrp) as avg_price FROM streamnet.products_list WHERE msrp > 0 GROUP BY manufacturer LIMIT 5"
+    result1 = execute_advanced_query.invoke({"sql_query": query1})
+    print("Result:")
+    print(result1)
+    
+    # Test complex query with joins/subqueries concept
+    print("Test 2: Complex query with filtering")
+    query2 = "SELECT manufacturer, category, model_name, msrp FROM streamnet.products_list WHERE msrp = (SELECT MAX(msrp) FROM streamnet.products_list WHERE manufacturer = 'Apple') LIMIT 3"
+    result2 = execute_advanced_query.invoke({"sql_query": query2})
+    print("Result:")
+    print(result2)
+
+def test_get_distinct_values_tool():
+    """
+    Test the get_distinct_values tool to ensure it retrieves distinct values and patterns correctly.
+    """
+    print("\n=== Testing get_distinct_values tool ===")
+    
+    # Test default query
+    print("Test 1: Default query (manufacturers by count)")
+    result1 = get_distinct_values.invoke({})
+    print("Result:")
+    print(result1)
+    
+    # Test custom query for categories
+    print("Test 2: Custom query for categories")
+    query2 = "SELECT category, COUNT(*) as count FROM streamnet.products_list GROUP BY category ORDER BY count DESC LIMIT 5"
+    result2 = get_distinct_values.invoke({"sql_query": query2})
+    print("Result:")
+    print(result2)
+    
+    # Test distinct model names
+    print("Test 3: Distinct model names for specific category")
+    query3 = "SELECT DISTINCT model_name FROM streamnet.products_list WHERE category = 'camera' ORDER BY model_name LIMIT 5"
+    result3 = get_distinct_values.invoke({"sql_query": query3})
+    print("Result:")
+    print(result3)
+
+def test_search_products_by_criteria_tool():
+    """
+    Test the search_products_by_criteria tool to ensure it searches products correctly.
+    """
+    print("\n=== Testing search_products_by_criteria tool ===")
+    
+    # Test default query
+    print("Test 1: Default query (Samsung products)")
+    result1 = search_products_by_criteria.invoke({})
+    print("Result:")
+    print(result1)
+    
+    # Test custom search with price range
+    print("Test 2: Custom search with price range")
+    query2 = "SELECT * FROM streamnet.products_list WHERE msrp BETWEEN 100 AND 500 AND manufacturer = 'Apple' LIMIT 5"
+    result2 = search_products_by_criteria.invoke({"sql_query": query2})
+    print("Result:")
+    print(result2)
+    
+    # Test search with text matching
+    print("Test 3: Search with text matching")
+    query3 = "SELECT manufacturer, model_name, msrp FROM streamnet.products_list WHERE model_name LIKE '%Pro%' ORDER BY msrp DESC LIMIT 5"
+    result3 = search_products_by_criteria.invoke({"sql_query": query3})
+    print("Result:")
+    print(result3)
+
+def test_get_table_statistics_tool():
+    """
+    Test the get_table_statistics tool to ensure it generates statistics correctly.
+    """
+    print("\n=== Testing get_table_statistics tool ===")
+    
+    # Test default query
+    print("Test 1: Default query (basic table statistics)")
+    result1 = get_table_statistics.invoke({})
+    print("Result:")
+    print(result1)
+    
+    # Test price statistics
+    print("Test 2: Price statistics")
+    query2 = "SELECT COUNT(*) as total_products, AVG(msrp) as avg_price, MIN(msrp) as min_price, MAX(msrp) as max_price FROM streamnet.products_list WHERE msrp > 0"
+    result2 = get_table_statistics.invoke({"sql_query": query2})
+    print("Result:")
+    print(result2)
+    
+    # Test manufacturer statistics
+    print("Test 3: Manufacturer statistics")
+    query3 = "SELECT manufacturer, COUNT(*) as product_count, AVG(msrp) as avg_price FROM streamnet.products_list WHERE msrp > 0 GROUP BY manufacturer ORDER BY product_count DESC LIMIT 5"
+    result3 = get_table_statistics.invoke({"sql_query": query3})
+    print("Result:")
+    print(result3)
+
+if __name__ == "__main__":
+    test_describe_table_tool()
+    test_get_sample_data_tool()
+    test_execute_advanced_query_tool()
+    test_get_distinct_values_tool() 
+    test_search_products_by_criteria_tool()
+    test_get_table_statistics_tool()