Upload folder using huggingface_hub

.env

@@ -0,0 +1,19 @@
+AZURE_OPENAI_API_KEY = 74fO9RE4s4f7HTSd9SM19Adw6rnECwUuBnfY593dPI7xSHa057RHJQQJ99BEACfhMk5XJ3w3AAAAACOGFVJQ
+
+OPENAI_API_TYPE = azure
+
+AZURE_OPENAI_API_VERSION = 2024-12-01-preview
+AZURE_OPENAI_DEPLOYMENT_NAME = gpt-4o-mini
+AZURE_OPENAI_ENDPOINT = https://tal-chatbot-resource2.cognitiveservices.azure.com/openai/deployments/gpt-4o-mini/chat/completions?api-version=2025-01-01-preview
+
+OPENAI_EMBEDDINGS_MODEL_NAME = text-embedding-ada-002
+OPENAI_EMBEDDINGS_MODEL_DEPLOYMENT = text-embedding-ada-002
+OPENAI_API_ENDPOINT = https://tal-chatbot-resource2.cognitiveservices.azure.com/
+
+LANGSMITH_API_KEY = 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
+LANGSMITH_TRACING=true
+
+
+AZURE_COSMOS_DB_ENDPOINT = https://tal-chatbot.documents.azure.com:443/
+AZURE_COSMOS_DB_KEY = 6XG3CwRPJeHWAufiMNbWNS2PhBfoSMtPEP5qNGPQJFulXqgJfR9K3xO1sgegOq9vkjwSgmIDqA7hACDbWIzPVA==
+AZURE_COSMOS_DB_DATABASE = tal-chatbot

README.md

@@ -1,12 +1,6 @@
 ---
-title: TAL Chatbot
-emoji: 💻
-colorFrom: yellow
-colorTo: yellow
+title: TAL-Chatbot
+app_file: chatbot-gradio.py
 sdk: gradio
-sdk_version: 5.32.1
-app_file: app.py
-pinned: false
+sdk_version: 5.31.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

chatbot-gradio.py

@@ -0,0 +1,303 @@
+import logging
+from semantic_kernel import Kernel
+from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
+from semantic_kernel.functions import kernel_function
+from azure.cosmos import CosmosClient
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.azure_chat_prompt_execution_settings import (
+    AzureChatPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
+from models.converterModels import PowerConverter  
+from plugins.converterPlugin import ConverterPlugin
+import os
+import gradio as gr
+
+from dotenv import load_dotenv
+load_dotenv()
+
+logger = logging.getLogger("kernel")
+logger.setLevel(logging.DEBUG)
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter(
+    "[%(asctime)s - %(name)s:%(lineno)d - %(levelname)s] %(message)s"
+))
+logger.addHandler(handler)
+
+
+# Initialize Semantic Kernel
+kernel = Kernel()
+
+# Add Azure OpenAI Chat Service
+kernel.add_service(AzureChatCompletion(
+    service_id="chat",
+    deployment_name=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
+    endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
+    api_key=os.getenv("AZURE_OPENAI_KEY")
+))
+
+# SQL Generation Plugin
+class NL2SQLPlugin:
+    @kernel_function(name="generate_sql", description="Generate Cosmos DB SQL query")
+    async def generate_sql(self, question: str) -> str:
+        sql = await self._generate_sql_helper(question)
+        # if ["DELETE", "UPDATE", "INSERT"] in sql:
+        #     return ""
+        if "FROM converters c" in sql:
+            sql = sql.replace("FROM converters c", "FROM c")
+        if "SELECT *" not in sql and "FROM c" in sql:
+            sql = sql.replace("SELECT c.*,", "SELECT *")
+            sql = sql.replace("SELECT c.*", "SELECT *")
+            sql = sql.replace("SELECT c", "SELECT *")
+
+        return sql
+
+    async def _generate_sql_helper(self, question: str) -> str:
+        from semantic_kernel.contents import ChatHistory
+        
+        chat_service = kernel.get_service("chat")
+        chat_history = ChatHistory()
+        chat_history.add_user_message(f"""Convert to Cosmos DB SQL: {question}
+            Collection: converters (alias 'c')
+            Fields:
+                - type (e.g., '350mA')
+                - artnr (numeric (int) article number e.g., 930546)
+                - output_voltage_v: dictionary with min/max values for output voltage
+                - output_voltage_v.min (e.g., 15)
+                - output_voltage_v.max (e.g., 40)
+                - nom_input_voltage_v: dictionary with min/max values for input voltage
+                - nom_input_voltage_v.min (e.g., 198)
+                - nom_input_voltage_v.max (e.g., 264)
+                - lamps: dictionary with min/max values for lamp types for this converter
+                - lamps["lamp_name"].min (e.g., 1)
+                - lamps["lamp_name"].max (e.g., 10)
+                - class (safety class)
+                - dimmability (e.g. if not dimmable 'NOT DIMMABLE'. if supports dimming, 'DALI/TOUCHDIM','MAINS DIM LC' etc)
+                - listprice (e.g., 58)
+                - lifecycle (e.g., 'Active')
+                - size (e.g., '150x30x30')
+                - dimlist_type (e.g., 'DALI')
+                - pdf_link (link to product PDF)
+                - converter_description (e.g., 'POWERLED CONVERTER REMOTE 180mA 8W IP20 1-10V')
+                - ip (Ingress Protection, integer values e.g., 20,67)
+                - efficiency_full_load (e.g., 0.9)
+                - name (e.g., 'Power Converter 350mA')
+                - unit (e.g., 'PC')
+                - strain_relief (e.g., "NO", "YES")
+            Return ONLY SQL without explanations""")
+        
+        response = await chat_service.get_chat_message_content(
+            chat_history=chat_history,
+            settings=AzureChatPromptExecutionSettings()
+        )
+        
+        return str(response)
+    
+
+# Register plugins
+kernel.add_plugin(ConverterPlugin(logger=logger), "CosmosDBPlugin")
+kernel.add_plugin(NL2SQLPlugin(), "NL2SQLPlugin")
+
+# Updated query handler using function calling
+async def handle_query(user_input: str):
+    
+    settings = AzureChatPromptExecutionSettings(
+            function_choice_behavior=FunctionChoiceBehavior.Auto(auto_invoke=True)        
+        )
+    
+    prompt = f"""
+    You are a converter database expert. Process this user query:
+    {user_input}
+    
+    Available functions:
+    - generate_sql: Creates SQL queries (use only for complex queries or schema keywords)
+    - query_converters: Executes SQL queries
+    - get_compatible_lamps: Simple artnr-based lamp queries
+    - get_converters_by_lamp_type: Simple lamp type searches
+    - get_lamp_limits: Simple artnr+lamp combinations
+    
+    Decision Flow:
+    1. Use simple functions if query matches these patterns:
+       - "lamps for [artnr]" → get_compatible_lamps
+       - "converters for [lamp type]" → get_converters_by_lamp_type
+       - "min/max [lamp] for [artnr]" → get_lamp_limits
+    
+    2. Use SQL generation ONLY when:
+       - Query contains schema keywords: voltage, price, type, ip, efficiency, size, class, dimmability
+       - Combining multiple conditions (AND/OR/NOT)
+       - Needs complex filtering/sorting
+       - Requesting technical specifications
+    
+    SQL Guidelines (if needed):
+    1. Always use SELECT * instead of field lists
+    2. For exact matches use: WHERE c.[field] = value
+    3. For ranges use: WHERE c.[field].min >= X AND c.[field].max <= Y
+    4. Do not use AS and cast key names
+    
+    Examples:
+    User: "Show IP67 converters under €100" → generate_sql
+    User: "What lamps are compatible with 930560?" → get_compatible_lamps
+    User: "What converters are compatible with haloled lamps?" → get_converters_by_lamp_type
+    User: "Voltage range for 930562" → generate_sql
+    """
+    
+    result = await kernel.invoke_prompt(
+        prompt=prompt,
+        settings=settings
+    )
+    
+    return str(result)
+
+# Example usage
+async def main():
+
+   while True:
+        try:
+            query = input("User: ")
+            if query.lower() in ["exit", "quit"]:
+                break
+
+            response = await handle_query(query)
+            print(response)
+            
+        except KeyboardInterrupt:
+            break
+
+
+
+# --- Gradio UI ---
+
+custom_css = """
+#chatbot-toggle-btn {
+    position: fixed;
+    bottom: 30px;
+    right: 30px;
+    z-index: 10001;
+    background-color: #ED1C24;
+    color: white;
+    border: none;
+    border-radius: 50%;
+    width: 56px;
+    height: 56px;
+    font-size: 28px;
+    font-weight: bold;
+    cursor: pointer;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.3s ease;
+}
+
+#chatbot-panel {
+    position: fixed;
+    bottom: 100px;
+    right: 30px;
+    z-index: 10000;
+    width: 600px;
+    height: 700px;
+    background-color: #ffffff;
+    border-radius: 20px;
+    box-shadow: 0 4px 24px rgba(0,0,0,0.25);
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    justify-content: space-between; /* keep input box pinned at the bottom */
+    font-family: 'Arial', sans-serif;
+}
+
+#chatbot-panel.hide {
+    display: none !important;
+}
+
+#chat-header {
+    background-color: #ED1C24;
+    color: white;
+    padding: 16px;
+    font-weight: bold;
+    font-size: 16px;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+#chat-header img {
+    border-radius: 50%;
+    width: 32px;
+    height: 32px;
+}
+
+.gr-chatbot {
+    flex: 1;
+    overflow-y: auto;
+    padding: 12px;
+    background-color: #f8f8f8;
+    border: none;
+}
+
+.gr-textbox {
+    border-top: 1px solid #eee;
+    padding: 10px;
+    background-color: #fff;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+}
+
+.gr-textbox textarea {
+    flex: 1;
+    resize: none;
+    padding: 10px;
+    background-color: white;
+    border: 1px solid #ccc;
+    border-radius: 8px;
+    font-family: inherit;
+    font-size: 14px;
+}
+
+footer {
+    display: none !important;
+}
+"""
+panel_visible = False
+
+def toggle_panel():
+    global panel_visible
+    panel_visible = not panel_visible
+    return gr.Column(visible=panel_visible)
+
+with gr.Blocks(css=custom_css) as demo:
+    # Toggle button (floating action button)
+    toggle_btn = gr.Button("💬", elem_id="chatbot-toggle-btn")
+
+    # Chat panel (initially hidden)
+    chat_panel = gr.Column(visible=panel_visible, elem_id="chatbot-panel")
+    with chat_panel:
+        # Chat header
+        with gr.Row(elem_id="chat-header"):
+            gr.HTML("""
+                <div id='chat-header'>
+                    <img src="https://www.svgrepo.com/download/490283/pixar-lamp.svg" />
+                    Lofty the TAL Bot
+                </div>
+            """)
+        # Chatbot and input
+        chatbot = gr.Chatbot(elem_id="gr-chatbot", type="messages")
+        msg = gr.Textbox(placeholder="Type your question here...", elem_id="gr-textbox")
+        clear = gr.ClearButton([msg, chatbot])
+
+
+    # Function to handle messages
+    async def respond(message, chat_history):
+        response = await handle_query(message)
+        # Convert existing history to OpenAI format if it's in tuples
+        
+        # Add new messages
+        chat_history.append({"role": "user", "content": message})
+        chat_history.append({"role": "assistant", "content": response})
+        return "", chat_history
+
+    msg.submit(respond, [msg, chatbot], [msg, chatbot])
+    toggle_btn.click(toggle_panel, outputs=chat_panel)
+
+demo.launch(share=True)

chatbot.py

@@ -0,0 +1,165 @@
+import logging
+from semantic_kernel import Kernel
+from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
+from semantic_kernel.functions import kernel_function
+from azure.cosmos import CosmosClient
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.azure_chat_prompt_execution_settings import (
+    AzureChatPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
+from models.converterModels import PowerConverter  
+from plugins.converterPlugin import ConverterPlugin
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+logger = logging.getLogger("kernel")
+logger.setLevel(logging.DEBUG)
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter(
+    "[%(asctime)s - %(name)s:%(lineno)d - %(levelname)s] %(message)s"
+))
+logger.addHandler(handler)
+
+
+# Initialize Semantic Kernel
+kernel = Kernel()
+
+# Add Azure OpenAI Chat Service
+kernel.add_service(AzureChatCompletion(
+    service_id="chat",
+    deployment_name=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
+    endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
+    api_key=os.getenv("AZURE_OPENAI_KEY")
+))
+
+# SQL Generation Plugin
+class NL2SQLPlugin:
+    @kernel_function(name="generate_sql", description="Generate Cosmos DB SQL query")
+    async def generate_sql(self, question: str) -> str:
+        sql = await self._generate_sql_helper(question)
+        # if ["DELETE", "UPDATE", "INSERT"] in sql:
+        #     return ""
+        if "FROM converters c" in sql:
+            sql = sql.replace("FROM converters c", "FROM c")
+        if "SELECT *" not in sql and "FROM c" in sql:
+            sql = sql.replace("SELECT c.*,", "SELECT *")
+            sql = sql.replace("SELECT c.*", "SELECT *")
+            sql = sql.replace("SELECT c", "SELECT *")
+
+        return sql
+
+    async def _generate_sql_helper(self, question: str) -> str:
+        from semantic_kernel.contents import ChatHistory
+        
+        chat_service = kernel.get_service("chat")
+        chat_history = ChatHistory()
+        chat_history.add_user_message(f"""Convert to Cosmos DB SQL: {question}
+            Collection: converters (alias 'c')
+            Fields:
+                - type (e.g., '350mA')
+                - artnr (numeric (int) article number e.g., 930546)
+                - output_voltage_v: dictionary with min/max values for output voltage
+                - output_voltage_v.min (e.g., 15)
+                - output_voltage_v.max (e.g., 40)
+                - nom_input_voltage_v: dictionary with min/max values for input voltage
+                - nom_input_voltage_v.min (e.g., 198)
+                - nom_input_voltage_v.max (e.g., 264)
+                - lamps: dictionary with min/max values for lamp types for this converter
+                - lamps["lamp_name"].min (e.g., 1)
+                - lamps["lamp_name"].max (e.g., 10)
+                - class (safety class)
+                - dimmability (e.g. if not dimmable 'NOT DIMMABLE'. if supports dimming, 'DALI/TOUCHDIM','MAINS DIM LC' etc)
+                - listprice (e.g., 58)
+                - lifecycle (e.g., 'Active')
+                - size (e.g., '150x30x30')
+                - dimlist_type (e.g., 'DALI')
+                - pdf_link (link to product PDF)
+                - converter_description (e.g., 'POWERLED CONVERTER REMOTE 180mA 8W IP20 1-10V')
+                - ip (Ingress Protection, integer values e.g., 20,67)
+                - efficiency_full_load (e.g., 0.9)
+                - name (e.g., 'Power Converter 350mA')
+                - unit (e.g., 'PC')
+                - strain_relief (e.g., "NO", "YES")
+            Return ONLY SQL without explanations""")
+        
+        response = await chat_service.get_chat_message_content(
+            chat_history=chat_history,
+            settings=AzureChatPromptExecutionSettings()
+        )
+        
+        return str(response)
+    
+
+# Register plugins
+kernel.add_plugin(ConverterPlugin(logger=logger), "CosmosDBPlugin")
+kernel.add_plugin(NL2SQLPlugin(), "NL2SQLPlugin")
+
+# Updated query handler using function calling
+async def handle_query(user_input: str):
+    
+    settings = AzureChatPromptExecutionSettings(
+            function_choice_behavior=FunctionChoiceBehavior.Auto(auto_invoke=True)        
+        )
+    
+    prompt = f"""
+    You are a converter database expert. Process this user query:
+    {user_input}
+    
+    Available functions:
+    - generate_sql: Creates SQL queries (use only for complex queries or schema keywords)
+    - query_converters: Executes SQL queries
+    - get_compatible_lamps: Simple artnr-based lamp queries
+    - get_converters_by_lamp_type: Simple lamp type searches
+    - get_lamp_limits: Simple artnr+lamp combinations
+    
+    Decision Flow:
+    1. Use simple functions if query matches these patterns:
+       - "lamps for [artnr]" → get_compatible_lamps
+       - "converters for [lamp type]" → get_converters_by_lamp_type
+       - "min/max [lamp] for [artnr]" → get_lamp_limits
+    
+    2. Use SQL generation ONLY when:
+       - Query contains schema keywords: voltage, price, type, ip, efficiency, size, class, dimmability
+       - Combining multiple conditions (AND/OR/NOT)
+       - Needs complex filtering/sorting
+       - Requesting technical specifications
+    
+    SQL Guidelines (if needed):
+    1. Always use SELECT * instead of field lists
+    2. For exact matches use: WHERE c.[field] = value
+    3. For EXACT ranges ALWAYS use: SELECT * FROM c WHERE c.[field].min = X AND c.[field].max = Y and NEVER >= <=
+    4. Limit results with SELECT TOP 10
+    
+    Examples:
+    User: "Show IP67 converters under €100" → generate_sql
+    User: "What lamps are compatible with 930560?" → get_compatible_lamps
+    User: "What converters are compatible with haloled lamps?" → get_converters_by_lamp_type
+    User: "Voltage range for 930562" → generate_sql
+    """
+    
+    result = await kernel.invoke_prompt(
+        prompt=prompt,
+        settings=settings
+    )
+    
+    return str(result)
+
+# Example usage
+async def main():
+
+   while True:
+        try:
+            query = input("User: ")
+            if query.lower() in ["exit", "quit"]:
+                break
+
+            response = await handle_query(query)
+            print(response)
+            
+        except KeyboardInterrupt:
+            break
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

cosmosConnector.py

@@ -0,0 +1,134 @@
+# cosmosConnector.py
+from jsonschema import ValidationError
+from models.converterModels import PowerConverter
+import os
+from azure.cosmos import CosmosClient
+from typing import List, Optional, Dict
+from langchain_openai import AzureOpenAIEmbeddings
+from rapidfuzz import fuzz
+import logging
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+# Initialize logging
+logger = logging.getLogger(__name__)
+
+class CosmosLampHandler:
+    
+    def __init__(self, logger: Optional[logging.Logger] = None):
+        self.client = CosmosClient(
+            os.getenv("AZURE_COSMOS_DB_ENDPOINT"),
+            os.getenv("AZURE_COSMOS_DB_KEY")
+        )
+        self.database = self.client.get_database_client("TAL_DB")
+        self.container = self.database.get_container_client("Converters")
+        self.logger = logger
+
+    async def get_compatible_lamps(self, artnr: int) -> List[str]:
+        """Get compatible lamps for a converter with fuzzy matching"""
+        try:
+            parameters = [{"name": "@artnr", "value": artnr}]
+            query = "SELECT * FROM c WHERE c.artnr = @artnr"
+            
+            # Collect results properly
+            results = [item for item in list(self.container.query_items(
+                query=query,
+                parameters=parameters
+            ))]
+            
+            if not results:
+                return []
+                
+            return list(results[0]["lamps"].keys())
+        
+        except Exception as e:
+            logger.error(f"Failed to get compatible lamps: {str(e)}")
+            return []
+        
+    async def get_converters_by_lamp_type(self, lamp_type: str, threshold: int = 75) -> List[PowerConverter]:
+        """Get converters with fuzzy-matched lamp types"""
+        try:
+            # Case-insensitive search with fuzzy matching
+            query = """
+            SELECT
+                *
+            FROM c WHERE IS_DEFINED(c.lamps)"""
+            converters = []
+            results = list(self.container.query_items(
+                                                    query=query,
+                                                    enable_cross_partition_query=True))
+            for item in results:
+                lamp_keys = item.get("lamps", {}).keys()
+                matches = [key for key in lamp_keys 
+                          if fuzz.ratio(key.lower(), lamp_type.lower()) >= threshold]
+                
+                if matches:
+                    converters.append(PowerConverter(**item))
+            
+            return converters
+            
+        except Exception as e:
+            logger.error(f"Lamp type search failed: {str(e)}")
+            return []
+
+    
+    async def get_lamp_limits(self, artnr: int, lamp_type: str) -> Dict[str, int]:
+        """Get lamp limits with typo tolerance"""
+        try:
+            parameters = [{"name": "@artnr", "value": artnr}]
+            query = """
+            SELECT c.lamps FROM c 
+            WHERE c.artnr = @artnr
+            """
+            results_iter = list(self.container.query_items(
+                query=query,
+                parameters=parameters
+            ))
+
+            results = [item for item in results_iter]  # Collect results asynchronously
+
+            if not results:
+                return {}
+
+            lamps = results[0]["lamps"]
+
+            # Fuzzy match lamp type
+            best_match = max(
+                lamps.keys(),
+                key=lambda x: fuzz.ratio(x.lower(), lamp_type.lower())
+            )
+
+            if fuzz.ratio(best_match.lower(), lamp_type.lower()) < 65:
+                raise ValueError("No matching lamp type found")
+
+            return {
+                "min": int(lamps[best_match]["min"]),
+                "max": int(lamps[best_match]["max"])
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to get lamp limits: {str(e)}")
+            raise
+    
+
+
+    async def query_converters(self, query: str) -> str:
+        try:
+            print(f"Executing query: {query}")
+            items = list(self.container.query_items(
+                query=query,
+                enable_cross_partition_query=True
+            ))
+            print(f"Query returned {len(items)} items")
+            items = items[:10] 
+            # self.logger.debug(f"Raw items: {items}")
+
+            items = [PowerConverter(**item) for item in items] if items else []
+
+            self.logger.info(f"Query returned {len(items)} items after conversion")            
+
+            return str(items)
+        except Exception as e:
+            self.logger.info(f"Query failed: {str(e)}")
+            return f"Query failed: {str(e)}"

models/converterModels.py

@@ -0,0 +1,60 @@
+# models/converterModels.py
+from pydantic import BaseModel, ConfigDict, Field, field_validator, validator
+from typing import Dict, Optional
+
+class LampConnections(BaseModel):
+    min: float
+    max: float
+    
+    @field_validator('min', 'max', mode='before')
+    def convert_values(cls, v):
+        v_str = str(v)
+        # Handle comma decimals
+        v_str = v_str.replace(',', '.')
+        return float(v_str)
+
+
+class VoltageRange(BaseModel):
+    min: float
+    max: float
+
+    @field_validator('min', 'max', mode='before')
+    def convert_values(cls, v):
+        v_str = str(v)
+        # Handle comma decimals
+        v_str = v_str.replace(',', '.')
+        return float(v_str)
+
+    
+class PowerConverter(BaseModel):
+    doc_id: Optional[str] = Field(None, alias="id")
+    artnr: Optional[int] = Field(None, alias="artnr")
+    ip_rating: Optional[int] = Field(None, alias="ip")
+    lamps: Optional[Dict[str, LampConnections]] = Field(default_factory=dict, alias="lamps")  
+    
+    type: Optional[str] = Field(None, alias="type")  
+    name: Optional[str] = Field(None, alias="name")  
+    efficiency: Optional[float] = Field(None, alias="efficiency_full_load")
+    pdf_link: Optional[str] = Field(None, alias="pdf_link")
+    converter_description: Optional[str] = Field(None, alias="converter_description")
+
+    nom_input_voltage: Optional[VoltageRange] = Field(None, alias="nom_input_voltage_v")
+    output_voltage:Optional[VoltageRange]= Field(None, alias="output_voltage_v")
+
+    unit: Optional[str] = Field(None, alias="unit")
+    price: Optional[float] = Field(None, alias="listprice")
+    life_cycle: Optional[str] = Field(None, alias="lifecycle")
+    size: Optional[str] = Field(None, alias="size")
+    ccr_amplitude: Optional[str] = Field(None, alias="ccr_amplitude")
+    dimmability: Optional[str] = Field(None, alias="dimmability")
+    dim_list_type: Optional[str] = Field(None, alias="dimlist_type")
+
+    strain_relief: Optional[str] = Field(None, alias="strain_relief")
+    gross_weight: Optional[float] = Field(None, alias="gross_weight")
+
+    similarity_score: Optional[float] = Field(None, alias="SimilarityScore")  # For hybrid search results
+    model_config = ConfigDict(
+        populate_by_name=True,  # Critical fix
+
+        extra="ignore"  
+    )

plugins/converterPlugin.py

@@ -0,0 +1,77 @@
+#converterPlugin.py
+from typing import Annotated, Optional
+from cosmosConnector import CosmosLampHandler
+from semantic_kernel.functions import kernel_function
+
+class ConverterPlugin:
+    def __init__(self, logger):
+        self.logger = logger
+        self.db = CosmosLampHandler(logger=logger)
+
+    
+    @kernel_function(
+        name="query_converters",
+        description="Execute SQL query against Cosmos DB converters collection"
+    )
+    async def query_converters(self, query: str) -> str:
+        try:
+            items = await self.db.query_converters(query)
+            self.logger.info(f"Executed query: {query}")
+            if not items:
+                return "No items found for the given query."
+            return str(items)
+        except Exception as e:
+            return f"Query failed: {str(e)}"
+    
+    
+    @kernel_function
+    async def get_compatible_lamps(
+        self,
+        artnr: Annotated[int, "Converter ARTNR (partition key)"]
+    ) -> str:
+        """Get compatible lamps for a converter by ARTNR"""
+        try:
+            lamps = await self.db.get_compatible_lamps(artnr)
+            self.logger.info(f"Used get_compatible_lamps with ARTNR: {artnr}")
+            return f"Compatible lamps: {', '.join(lamps)}" if lamps else "No lamps found"
+            # return "\n".join([f"{c.model_dump()})" for c in lamps]) if lamps else "No lamps found"
+        except Exception as e:
+            return f"Error retrieving compatible lamps: {str(e)}"
+        
+        
+    @kernel_function(
+        name="get_converters_by_lamp_type",
+        description="Find converters compatible with a specific lamp type"
+    )
+    async def get_converters_by_lamp_type(
+        self,
+        lamp_type: Annotated[str, "Lamp model (e.g., Haloled, B4)"]
+    ) -> str:
+        """Find converters compatible with specific lamp type"""
+        try:
+            converters = await self.db.get_converters_by_lamp_type(lamp_type)
+            self.logger.info(f"Used get_converters_by_lamp_type with lamp_type: {lamp_type}")
+            if not converters:
+                return "No compatible converters found"
+            # return "\n".join([f"{c.name} (ARTNR: {c.artnr})\nTYPE: {c.type}\nMANUAL: {c.pdf_link}" for c in converters])
+            return "\n".join([f"{c.model_dump()})" for c in converters]) if converters else "No converters found"
+        except Exception as e:
+            return f"Error retrieving converters: {str(e)}"
+        
+    
+    @kernel_function(
+        name="get_lamp_limits",
+        description="Get min/max lamps for a converter by ARTNR and lamp type"
+    )
+    async def get_lamp_limits(
+        self,
+        artnr: Annotated[int, "Converter ARTNR"],
+        lamp_type: Annotated[str, "Lamp model (e.g., Haloled)"]
+    ) -> str:
+        """Get min/max lamps for a converter"""
+        try:
+            limits = await self.db.get_lamp_limits(artnr, lamp_type)
+            self.logger.info(f"Used get_lamp_limits with ARTNR: {artnr} and lamp_type: {lamp_type}")
+            return f"{lamp_type}: Min {limits['min']} - Max {limits['max']} lamps"
+        except Exception as e:
+            return f"Error retrieving lamp limits: {str(e)}"

questions.txt

@@ -0,0 +1,10 @@
+what lamps can i use with 930599
+how many thinksmall halosphere double lamps can i use with 930599
+cheapest converter that supports Beaufort lamps
+what is the converter that supports the most number of single led xpe lamps
+what is the output voltage range of converter 930560
+give me converters that are not dimmable and also support Haloled lamps
+which converters support boa wc lamps and have an efficiency greater than 0.7
+what is the input voltage range of converter 930544
+give me converters with an input voltage range of 230-240
+which converters are of type 500mA and support dimming

requirements.txt

@@ -0,0 +1 @@
+semantic-kernel

sql-genonly-chatbot.py

@@ -0,0 +1,182 @@
+import logging
+from semantic_kernel import Kernel
+from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
+from semantic_kernel.functions import kernel_function
+from azure.cosmos import CosmosClient
+from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.azure_chat_prompt_execution_settings import (
+    AzureChatPromptExecutionSettings,
+)
+from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
+from models.converterModels import PowerConverter  
+
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+logger = logging.getLogger("kernel")
+logger.setLevel(logging.DEBUG)
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter(
+    "[%(asctime)s - %(name)s:%(lineno)d - %(levelname)s] %(message)s"
+))
+logger.addHandler(handler)
+
+
+# Initialize Semantic Kernel
+kernel = Kernel()
+
+# Add Azure OpenAI Chat Service
+kernel.add_service(AzureChatCompletion(
+    service_id="chat",
+    deployment_name=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
+    endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
+    api_key=os.getenv("AZURE_OPENAI_KEY")
+))
+
+# Database Plugin
+class CosmosDBPlugin:
+    def __init__(self):
+        self.client = CosmosClient(
+            os.getenv("AZURE_COSMOS_DB_ENDPOINT"),
+            os.getenv("AZURE_COSMOS_DB_KEY")
+        )
+        self.database = self.client.get_database_client("TAL_DB")
+        self.container = self.database.get_container_client("Converters")
+        self.logger = logger
+
+    @kernel_function(
+        name="query_converters",
+        description="Execute SQL query against Cosmos DB converters collection"
+    )
+    async def query_converters(self, query: str) -> str:
+        try:
+            print(f"Executing query: {query}")
+            items = list(self.container.query_items(
+                query=query,
+                enable_cross_partition_query=True
+            ))
+            print(f"Query returned {len(items)} items")
+            items = items[:10] 
+            self.logger.debug(f"Raw items: {items}")
+
+            items = [PowerConverter(**item) for item in items] if items else []
+
+            self.logger.info(f"Query returned {len(items)} items after conversion")
+            self.logger.debug(f"Items: {items}")
+
+            
+
+            return str(items)
+        except Exception as e:
+            self.logger.info(f"Query failed: {str(e)}")
+            return f"Query failed: {str(e)}"
+
+# SQL Generation Plugin
+class NL2SQLPlugin:
+    @kernel_function(name="generate_sql", description="Generate Cosmos DB SQL query")
+    async def generate_sql(self, question: str) -> str:
+        sql = await self._generate_sql_helper(question)
+        if "SELECT *" not in sql and "FROM c" in sql:
+            sql = sql.replace("SELECT c.*", "SELECT *")
+            sql = sql.replace("SELECT c", "SELECT *")
+        return sql
+
+    async def _generate_sql_helper(self, question: str) -> str:
+        from semantic_kernel.contents import ChatHistory
+        
+        chat_service = kernel.get_service("chat")
+        chat_history = ChatHistory()
+        chat_history.add_user_message(f"""Convert to Cosmos DB SQL: {question}
+            Collection: converters (alias 'c')
+            Fields:
+                - type (e.g., '350mA')
+                - artnr (numeric (int) article number e.g., 930546)
+                - output_voltage_v: dictionary with min/max values for output voltage
+                - output_voltage_v.min (e.g., 15)
+                - output_voltage_v.max (e.g., 40)
+                - input_voltage_v: dictionary with min/max values for input voltage
+                - input_voltage_v.min (e.g., 198)
+                - input_voltage_v.max (e.g., 264)
+                - lamps: dictionary with min/max values for lamp types for this converter
+                - lamps["lamp_name"].min (e.g., 1)
+                - lamps["lamp_name"].max (e.g., 10)
+                - nom_input_voltage (e.g, '198-264V')
+                - class (safety class)
+                - dimmability (e.g., 'MAINS DIM LC')
+                - listprice (e.g., 58)
+                - lifecycle (e.g., 'Active')
+                - size (e.g., '150x30x30')
+                - dimlist_type (e.g., 'DALI')
+                - pdf_link (link to product PDF)
+                - converter_description (e.g., 'POWERLED CONVERTER REMOTE 180mA 8W IP20 1-10V')
+                - ip (Ingress Protection, integer values e.g., 20,67)
+                - efficiency_full_load (e.g., 0.9)
+                - name (e.g., 'Power Converter 350mA')
+                - unit (e.g., 'PC')
+            Return ONLY SQL without explanations""")
+        
+        response = await chat_service.get_chat_message_content(
+            chat_history=chat_history,
+            settings=AzureChatPromptExecutionSettings()
+        )
+        
+        return str(response)
+    
+
+# Register plugins
+kernel.add_plugin(CosmosDBPlugin(), "CosmosDBPlugin")
+kernel.add_plugin(NL2SQLPlugin(), "NL2SQLPlugin")
+
+# Updated query handler using function calling
+async def handle_query(user_input: str):
+    
+    settings = AzureChatPromptExecutionSettings(
+            function_choice_behavior=FunctionChoiceBehavior.Auto(auto_invoke=True)        
+        )
+    
+    prompt = f"""
+    You are a converter database expert. Process this user query:
+    {user_input}
+    
+    Available functions:
+    - generate_sql: Creates SQL queries from natural language
+    - query_converters: Executes SQL queries against the database
+    
+    Follow these steps:
+    1. Generate SQL using generate_sql
+    2. Execute query with query_converters
+    3. Format results into natural language response
+
+    Query Guidelines:
+    1. When performing SELECT ALL queries always use SELECT *. Never use SELECT c.* or SELECT c
+    2. For questions about lamp compatibility, ALWAYS use SELECT * FROM c WHERE IS_DEFINED(c.lamps["lamp_name"])
+    3. For questions about lamps that can be used with a converter, ALWAYS use SELECT c.lamps FROM c WHERE c.artnr = @artnr
+    5. For questions about lamp limits, query for the lamps dictionary and return min/max values
+
+    """
+    
+    result = await kernel.invoke_prompt(
+        prompt=prompt,
+        settings=settings
+    )
+    
+    return str(result)
+
+# Example usage
+async def main():
+
+   while True:
+        try:
+            query = input("User: ")
+            if query.lower() in ["exit", "quit"]:
+                break
+
+            response = await handle_query(query)
+            print(response)
+            
+        except KeyboardInterrupt:
+            break
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())