Upload folder using huggingface_hub

.env

@@ -0,0 +1,19 @@
+AZURE_OPENAI_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 RAGandSQLGen Chatbot
-emoji: 📈
-colorFrom: purple
-colorTo: pink
+title: TAL-RAGandSQLGen-Chatbot
+app_file: chatbot-gradio.py
 sdk: gradio
-sdk_version: 5.33.0
-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,323 @@
+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")
+))
+allowed_fields = [
+    "id","artnr","type", "converter_description","strain_relief","location","dimmability","efficiency_full_load",
+    "ip","class","nom_input_voltage_v.min","nom_input_voltage_v.max","output_voltage_v.min","output_voltage_v.max",
+    "name","listprice","unit","lifecycle","lamps","size"
+]
+# 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)
+        # Block DML commands first
+        if any(command in sql.upper() for command in ["DELETE", "UPDATE", "INSERT"]):
+            return ""
+        
+        # # Validate fields before proceeding
+        # if not self._validate_fields(sql, allowed_fields):
+        #     return "ERROR: Query contains invalid fields"
+        
+        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 *")
+        
+        logger.info(f"finalSQL {sql}")
+
+        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")
+            SQL Guidelines (if needed):
+                - Always use SELECT * and never individual fields
+                - Always refer to fields in WHERE clause using c.<field_name>
+                - For exact matches use: WHERE c.[field] = value
+                - For ranges use: WHERE c.[field].min = X AND c.[field].max = Y
+                - Check for dimmability support by using either !="NOT DIMMABLE" or ="NOT DIMMABLE"
+                - Do not use AS and cast key names
+            Return ONLY SQL without explanations""")
+        
+        response = await chat_service.get_chat_message_content(
+            chat_history=chat_history,
+            settings=AzureChatPromptExecutionSettings()
+        )
+        logger.info(f"Response dB schema{response}")
+        
+        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
+    - RAG_search: questions about dimmability or current (if query contains mains c, dali, 350mA, dali drivers, dimming)
+    
+    Decision Flow:
+    1. Identify synonyms :
+        output voltage = voltage forward = forward voltage = Vf
+        Driver = ledconverter = converter = power supply = gear
+        lamps = luminares
+
+    2. 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
+    
+    3. Use SQL generation ONLY when:
+       - Query contains schema keywords: voltage, price, type, ip, efficiency, size, class
+       - Combining multiple conditions (AND/OR/NOT)
+       - Needs complex filtering/sorting
+       - Requesting technical specifications
+    
+    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)

cosmosConnector.py

@@ -0,0 +1,219 @@
+# cosmosConnector.py
+from jsonschema import ValidationError
+from langchain_openai import AzureOpenAIEmbeddings
+from models.converterModels import PowerConverter
+from models.converterVectorStoreModels import PowerConverterVector
+import os
+from azure.cosmos import CosmosClient
+from typing import List, Optional, Dict
+from rapidfuzz import fuzz
+import logging
+import os
+from dotenv import load_dotenv
+from semantic_kernel.functions import kernel_function
+
+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_with_embeddings")
+        self.logger = logger
+        self.embedding_model = AzureOpenAIEmbeddings(
+            azure_endpoint=os.environ["OPENAI_API_ENDPOINT"],
+            azure_deployment=os.environ["OPENAI_EMBEDDINGS_MODEL_DEPLOYMENT"],
+            api_key=os.environ["AZURE_OPENAI_KEY"]
+        )
+
+    async def _generate_embedding(self, query: str) -> List[float]:
+        """Generate embedding for the given query using Azure OpenAI"""
+        try:
+            return self.embedding_model.embed_query(query)
+        except Exception as e:
+            logger.error(f"Embedding generation failed: {str(e)}")
+            raise
+
+    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)}"
+    
+    
+    async def RAG_search(self, query: str, artnr: Optional[int] = None, threshold: int = 75) -> List[PowerConverterVector]:
+        """Hybrid search using raw Cosmos DB vector search"""
+        try:
+            # Generate embedding
+            print(f"Performing hybrid search for query: {query} (ARTNR: {artnr})")
+            query_vector = await self._generate_embedding(query)
+            
+            sql_query = """
+                SELECT TOP 5
+                    c.id,
+                    c.converter_description,
+                    c.ip,
+                    c.efficiency_full_load,
+                    c.name,
+                    c.artnr,
+                    c.type,
+                    c.lamps,
+                    c.pdf_link,
+                    c.nom_input_voltage_v,
+                    c.output_voltage_v,
+                    c.unit,
+                    c["listprice"],
+                    c["lifecycle"],
+                    c.size,
+                    c.ccr_amplitude,
+                    c.dimmability,
+                    c.dimlist_type,
+                    c.strain_relief,
+                    c.gross_weight,
+                    VectorDistance(c.embedding, @vector) AS SimilarityScore
+                FROM c 
+                ORDER BY VectorDistance(c.embedding, @vector)
+                """
+            
+            parameters = [{"name": "@vector", "value": query_vector}]
+
+            # Execute query
+            results = list(self.container.query_items(
+                query=sql_query,
+                parameters=parameters,
+                enable_cross_partition_query=True
+            ))
+            
+            items = []
+            for item in results:
+                items.append(item)
+         
+            converters = []
+            for item in items:
+                # Convert float values to integers before validation
+                if "lamps" in item:
+                    for lamp_key in item["lamps"]:
+                        lamp_data = item["lamps"][lamp_key]
+                        lamp_data["min"] = int(lamp_data["min"])
+                        lamp_data["max"] = int(lamp_data["max"])
+  
+                converters.append(PowerConverterVector(**item))
+                   
+            return converters
+        except ValidationError as exc:
+            print(exc)
+                
+        except Exception as e:
+            logger.error(f"Hybrid search failed: {str(e)}")
+            print(f"Hybrid search 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"  
+    )

models/converterVectorStoreModels.py

@@ -0,0 +1,64 @@
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Annotated
+from pydantic import BaseModel, BeforeValidator, Field, field_validator  # Use Pydantic's Field
+from semantic_kernel.data import (
+    DistanceFunction,
+    IndexKind,
+    VectorStoreRecordDataField,
+    VectorStoreRecordKeyField,
+    VectorStoreRecordVectorField,
+    vectorstoremodel
+)
+
+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)
+
+@vectorstoremodel
+class PowerConverterVector(BaseModel):
+    id: Annotated[str, VectorStoreRecordKeyField]=Field(None, alias="id")
+    artnr: Annotated[int, VectorStoreRecordDataField()] = Field(..., alias="artnr")
+    ip: Annotated[int, VectorStoreRecordDataField()] = Field(..., alias="ip")
+    type: Optional[Annotated[str, VectorStoreRecordDataField()]] = Field(None, alias="type")
+    lamps: Optional[Dict[str, LampConnections]] = None
+
+    name: Optional[Annotated[str, VectorStoreRecordDataField()]] = Field(None, alias="name")
+    efficiency_full_load: Optional[Annotated[float, VectorStoreRecordDataField()]] = Field(None, alias="efficiency_full_load")
+    pdf_link: Optional[Annotated[str, VectorStoreRecordDataField()]] = None
+    converter_description: Optional[Annotated[str, VectorStoreRecordDataField()]] = 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[Annotated[str, VectorStoreRecordDataField()]] = Field(None, alias="unit")
+    price: Optional[Annotated[float, VectorStoreRecordDataField()]] = Field(None, alias="listprice")
+    life_cycle: Optional[Annotated[str, VectorStoreRecordDataField()]] = Field(None, alias="lifecycle")
+    size: Optional[Annotated[str, VectorStoreRecordDataField()]] = Field(None, alias="size")
+    ccr_amplitude: Optional[Annotated[str, VectorStoreRecordDataField()]] = Field(None, alias="ccr_amplitude")
+    dimmability: Optional[Annotated[str, VectorStoreRecordDataField()]] = Field(None, alias="dimmability")
+    dim_list_type: Optional[Annotated[str, VectorStoreRecordDataField()]] = Field(None, alias="dimlist_type")
+    gross_weight: Optional[Annotated[float, VectorStoreRecordDataField()]] = Field(None, alias="gross_weight")
+    strain_relief: Optional[Annotated[str, VectorStoreRecordDataField()]] = Field(None, alias="strain_relief")
+    embedding: Annotated[List[float], VectorStoreRecordVectorField(
+        dimensions=1536,
+        distance_function=DistanceFunction.COSINE_DISTANCE,
+        index_kind=IndexKind.DISK_ANN
+    )] = Field(default_factory=list)

plugins/converterPlugin.py

@@ -0,0 +1,96 @@
+#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)}"
+        
+    @kernel_function(
+        name = "RAG_search",
+        description="Get data based on vector similarity scores for queries regarding dimmability or in cases where SQL generation fails"
+    )
+    async def RAG_search(
+        self,
+        query: Annotated[str, "User query"]
+    ) -> str:
+        try:
+            converters = await self.db.RAG_search(query=query)
+            self.logger.info(f"Used RAG search for user query: {query}")
+            if not converters:
+                return "No 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)}"
+        

requirements.txt

@@ -0,0 +1 @@
+azure-cosmos