Upload folder using huggingface_hub

.env

@@ -0,0 +1,15 @@
+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/
+
+
+AZURE_COSMOS_DB_ENDPOINT = https://tal-chatbot.documents.azure.com:443/
+AZURE_COSMOS_DB_KEY = 6XG3CwRPJeHWAufiMNbWNS2PhBfoSMtPEP5qNGPQJFulXqgJfR9K3xO1sgegOq9vkjwSgmIDqA7hACDbWIzPVA==

CosmosDBHandlers/cosmosChatHistoryHandler.py

@@ -0,0 +1,208 @@
+
+# cosmosConnector.py
+from azure.cosmos import exceptions
+from datetime import datetime, timedelta, timezone
+import uuid
+from langchain_openai import AzureOpenAIEmbeddings
+import os
+from azure.cosmos import CosmosClient, PartitionKey
+from typing import List, Optional, Dict
+import logging
+import os
+from dotenv import load_dotenv
+load_dotenv()
+# Initialize Cosmos DB containers
+
+class ChatMemoryHandler():
+    def __init__(self, logger: Optional[logging.Logger] = None):
+        self.cosmos_client = CosmosClient(
+            os.getenv("AZURE_COSMOS_DB_ENDPOINT"),
+            os.getenv("AZURE_COSMOS_DB_KEY")
+        )
+        self.logger = logger
+        self.indexing_policy = {
+            "indexingMode": "consistent",
+            "includedPaths": [{"path": "/*"}],  # Indexes all properties, including nested
+            "excludedPaths": [
+                {
+                    "path": '/"_etag"/?'
+                },
+                {
+                    "path": "/embedding/*"
+                }
+                ],
+        }
+
+
+        self.vector_embedding_policy = {
+            "vectorEmbeddings": [
+                {
+                    "path": "/embedding",
+                    "dataType": "float32",
+                    "distanceFunction": "cosine",
+                    "dimensions": 1536,
+                }
+            ]
+        }
+
+        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"]
+        )
+
+        self.database = self.cosmos_client.create_database_if_not_exists("TAL_ChatDB")
+
+        # Container for chat history
+        self.chat_container = self.database.create_container_if_not_exists(
+            id="ChatHistory",
+            partition_key=PartitionKey(path="/sessionId"),
+            indexing_policy=self.indexing_policy,
+            vector_embedding_policy=self.vector_embedding_policy
+        )
+
+        # Container for SQL queries
+        self.sql_container = self.database.create_container_if_not_exists(
+            id="GeneratedQueries", 
+            partition_key=PartitionKey(path="/queryType")
+        )
+    
+    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:
+            self.logger.error(f"Embedding generation failed: {str(e)}")
+            raise
+
+    async def log_interaction(self, session_id: str, question: str, function_used: str, answer: str):
+        try:
+            chat_item = {
+                "id": str(uuid.uuid4()),
+                "sessionId": session_id,
+                "question": question,
+                "functionUsed": function_used,
+                "answer": answer,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "embedding": await self._generate_embedding(question)
+            }
+            self.chat_container.create_item(body=chat_item)
+        except Exception as e:
+            self.logger.error(f"Failed to log chat interaction: {str(e)}")
+
+
+    async def log_sql_query(self, original_question: str, generated_sql: str):
+        try:
+            sql_item = {
+                "id": str(uuid.uuid4()),
+                "queryType": "generated",
+                "originalQuestion": original_question,
+                "generatedSql": generated_sql,
+                "executionStatus": "generated",
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+            self.sql_container.create_item(body=sql_item)
+        except Exception as e:
+            self.logger.error(f"Failed to log SQL query: {str(e)}")
+
+    async def get_semantic_faqs(self, limit: int = 5, threshold: float = 0.1) -> List[Dict]:
+        """Retrieve FAQs using vector embeddings for semantic similarity"""
+        try:            
+            query = """
+            SELECT c.question FROM c
+            """
+            raw_results = list(self.chat_container.query_items(
+                query=query,
+                enable_cross_partition_query=True,
+                max_item_count=-1
+            ))
+
+            # Group by question in Python
+            from collections import Counter
+            question_counts = Counter(item['question'] for item in raw_results)
+            top_questions = question_counts.most_common(limit)
+
+            # Generate embeddings for top questions
+            faq_embeddings = {}
+            for question_text, count in top_questions:
+                embedding = await self._generate_embedding(question_text)
+                faq_embeddings[question_text] = {
+                    'embedding': embedding,
+                    'count': count
+                }
+
+            # Cluster similar questions
+            clustered_faqs = []
+            processed = set()
+            
+            for text, data in faq_embeddings.items():
+                if text in processed:
+                    continue
+
+                query = """
+                SELECT TOP 50 c.question, VectorDistance(c.embedding, @embedding) as distance
+                FROM c
+                ORDER BY VectorDistance(c.embedding, @embedding)
+                """
+                parameters = [{"name": "@embedding", "value": data['embedding']}]
+                    
+                similar_results = list(self.chat_container.query_items(
+                    query=query,
+                    parameters=parameters,
+                    enable_cross_partition_query=True
+                ))
+                
+                similarity_threshold = threshold  
+                filtered_results = []
+                for item in similar_results:
+                    similarity = 1 - item['distance']  # Convert distance to similarity
+                    if similarity <= similarity_threshold:
+                        filtered_results.append(item['question'])
+
+                # Count occurrences of similar questions
+                similar_question_counts = Counter(filtered_results)
+                cluster_count = sum(similar_question_counts.values())
+                
+                clustered_faqs.append({
+                    "representative_question": text,
+                    "similar_questions": list(similar_question_counts.keys()),
+                    "total_occurrences": cluster_count,
+                    "similarity_scores": {q: 1 - item['distance'] for item in similar_results for q in [item['question']] if 1 - item['distance'] >= similarity_threshold}
+                })
+                
+                # Mark all similar questions as processed
+                processed.update(filtered_results)
+                clustered_faqs.append({
+                    "representative_question": text,
+                    "similar_questions": [text],
+                    "total_occurrences": data['count'],
+                    "similarity_scores": {text: 1.0}
+                })
+                processed.add(text)
+
+            return sorted(clustered_faqs[:limit], key=lambda x: x['total_occurrences'], reverse=True)
+            
+        except exceptions.CosmosHttpResponseError as ex:
+            print(f"Cosmos DB error: {ex}")
+            self.logger.error(f"Semantic FAQ retrieval failed: {str(e)}")
+            return []
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Semantic FAQ retrieval failed: {str(e)}")
+            return []
+
+
+import asyncio
+
+
+
+handler = ChatMemoryHandler()
+
+async def main():
+    faqs = await handler.get_semantic_faqs()
+    for faq in faqs:
+        
+        print("\n",faq["representative_question"],faq["similar_questions"],"\n")
+
+if __name__ == "__main__":
+    asyncio.run(main())

CosmosDBHandlers/cosmosConnector.py

@@ -0,0 +1,343 @@
+# cosmosConnector.py
+from jsonschema import ValidationError
+from langchain_openai import AzureOpenAIEmbeddings
+from models.converterModels import PowerConverter
+import os
+from azure.cosmos import CosmosClient
+from typing import List, Optional, Dict
+import logging
+import os
+from dotenv import load_dotenv
+from semantic_kernel.functions import kernel_function
+from rapidfuzz import process, fuzz
+
+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 = logging.Logger("test")
+        # 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"]
+        )
+    
+    def _fuzzy_match_lamp(self, query: str, targets: list[str], threshold=60) -> list:
+        """Advanced partial matching"""
+        from rapidfuzz import process, fuzz
+        
+        normalized_query = self._normalize_lamp_name(query)
+        normalized_targets = [self._normalize_lamp_name(t) for t in targets]
+        
+        return process.extract( 
+            normalized_query,
+            normalized_targets,
+            scorer=fuzz.token_set_ratio,
+            score_cutoff=threshold
+        )
+    
+    def _normalize_lamp_name(self,name: str) -> str:
+        """Standardize lamp names for matching"""
+        return (
+            name.lower()
+            .replace(",", ".")
+            .replace("-", " ")
+            .replace("/", " ")
+            .translate(str.maketrans("", "", "()"))
+            .strip()
+        )
+
+    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:
+            self.logger.error(f"Embedding generation failed: {str(e)}")
+            raise
+    
+    async def get_converter_info(self, artnr:int) -> PowerConverter:
+        """Get information about a converter from its artnr"""
+        try:
+            parameters = [{"name": "@artnr", "value": artnr}]
+            query = "SELECT * FROM c WHERE c.artnr = @artnr"
+            
+            # Collect results properly
+            result = self.container.query_items(
+                query=query,
+                parameters=parameters,
+                enable_cross_partition_query=True
+            )
+            
+            if not result:
+                return None
+            
+            else:
+                for r in result:
+                 converter = PowerConverter(**r)
+            
+            return converter
+            
+        except Exception as e:
+            self.logger.error(f"Failed to retrieve converter {artnr} - {e}")
+            
+
+    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:
+            self.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()
+                lamp_type = self._normalize_lamp_name(lamp_type)
+                matches = self._fuzzy_match_lamp(lamp_type, lamp_keys)
+
+                if matches:
+                    converters.append(PowerConverter(**item))
+            
+            if not converters:
+                return []
+            
+            return converters
+            
+        except Exception as e:
+            self.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"]
+            lamp_keys = list(lamps.keys())
+
+            # Fuzzy match with normalization
+            matches = self._fuzzy_match_lamp(self._normalize_lamp_name(lamp_type), lamp_keys, threshold=60)
+            if not matches:
+                raise ValueError(f"No matching lamp type found for '{lamp_type}'")
+
+            # Get best match from original keys using match index
+            best_match = lamp_keys[matches[0][2]]
+
+            return {
+                "min": int(lamps[best_match]["min"]),
+                "max": int(lamps[best_match]["max"])
+            }
+
+        except Exception as e:
+            self.logger.error(f"Failed to get lamp limits: {str(e)}")
+            raise
+    
+    async def get_converters_by_dimming(
+        self,
+        dimming_type: str,
+        voltage_current: Optional[str] = None,
+        lamp_type: Optional[str] = None,
+        threshold: int = 75
+    ) -> List[PowerConverter]:
+        """Search converters by dimming type and voltage/current/lamp_type specifications with fuzzy matching"""
+        try:
+            # Base query construction
+            query = "SELECT * FROM c WHERE IS_DEFINED(c.dimmability)"
+            results = list(self.container.query_items(
+                query=query,
+                enable_cross_partition_query=True
+            ))
+            
+            converters = []
+            for item in results:
+                # Fuzzy match converter type if specified
+                if voltage_current:
+                    item_type = item.get("type", "")
+                    item_types = item_type.split(" ")
+                    for conv_type in item_types: # handle types like 24V DC
+                        if fuzz.ratio(conv_type.lower(), voltage_current.lower()) < threshold:
+                            continue
+                if lamp_type:
+                    item_lamps = item.get("lamps", "")
+                    lamp_type = self._normalize_lamp_name(lamp_type)
+                    lamp_matches = self._fuzzy_match_lamp(lamp_type, item_lamps.keys())
+                    if not lamp_matches:
+                        continue
+
+                # Fuzzy match dimming types
+                if dimming_type!= None:
+                    dimmability = item.get("dimmability", "")
+                    match_types = dimmability.split('/')
+                    match_types += dimmability.split(" ")
+                    for option in match_types:
+                        if fuzz.ratio(option.lower().strip(), dimming_type.lower()) >= threshold:
+                            converters.append(PowerConverter(**item))
+                            break
+                else:
+                    converters.append(PowerConverter(**item))
+                    break
+            
+            self.logger.info(f"Found {len(converters)} converters matching criteria")
+            return converters
+            
+        except Exception as e:
+            self.logger.error(f"Dimming query failed: {str(e)}")
+            return []
+    
+    
+
+    async def query_converters(self, query: str) -> List[PowerConverter]:
+        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] 
+
+            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 get_converters_by_voltage_current(
+        self,
+        artnr: Optional[int] = None,
+        current: Optional[str]=None,
+        input_voltage: Optional[str] = None,
+        output_voltage: Optional[str] = None
+    ) -> List[PowerConverter]:
+        """Query converters by voltage ranges"""
+        try:
+            # Handle ARTNR lookup
+            if artnr:
+                converter = await self.get_converter_info(artnr)
+                self.logger.info(f"Used converter info returned {converter}")
+                return [converter] if converter else []
+            
+            # Parse voltage ranges
+            input_min, input_max = self._parse_voltage(input_voltage) if input_voltage else (None, None)
+            output_min, output_max = self._parse_voltage(output_voltage) if output_voltage else (None, None)
+            
+            # Build query
+            query_parts = []
+            if input_min and input_max:
+                query_parts.append(f"c.nom_input_voltage_v.min <= {input_max} AND c.nom_input_voltage_v.max >= {input_min}")
+                self.logger.info(f"c.nom_input_voltage_v.min <= {input_max} AND c.nom_input_voltage_v.max >= {input_min}")
+            if output_min and output_max:
+                query_parts.append(f"c.output_voltage_v.min <= {output_max} AND c.output_voltage_v.max >= {output_min}")
+                self.logger.info(f"c.nom_input_voltage_v.min <= {input_max} AND c.nom_input_voltage_v.max >= {input_min}")
+            if current:
+                 query_parts.append(f"c.type LIKE '%{current}%'")
+
+                
+            query = "SELECT * FROM c" + (" WHERE " + " AND ".join(query_parts) if query_parts else "")
+            
+            results = list(self.container.query_items(
+                query=query,
+                enable_cross_partition_query=True
+            ))
+            
+            return [PowerConverter(**item) for item in results]
+        
+        except Exception as e:
+            self.logger.error(f"Voltage query failed: {str(e)}")
+            return []
+
+    def _parse_voltage(self, voltage_str: str) -> tuple[float, float]:
+        import re
+        voltage_str = voltage_str.strip().replace(',', '.')
+        voltage_str = re.sub(r'[^0-9.\-]', '', voltage_str)
+        match = re.match(r"^(\d+(?:\.\d+)?)(?:-+(\d+(?:\.\d+)?))?$", voltage_str)
+        if match:
+            min_v = float(match.group(1))
+            max_v = float(match.group(2)) if match.group(2) else min_v
+            return min_v, max_v
+        else:
+            return None, None 
+
+if __name__ == "__main__":
+    handler = CosmosLampHandler()
+    # Example usage
+    import asyncio
+
+    async def main():
+        # lamps = await handler.get_compatible_lamps(930573)
+        # print("Compatible lamps:", lamps)
+
+        # converters = await handler.get_converters_by_dimming(voltage_current="350ma",lamp_type="haloled")
+        # for result in converters:
+        #     print(f"\t{result.name} (ARTNR: {result.artnr})")
+        #     print(f"\tLamp types: {', '.join(result.lamps.keys())}\n")
+
+        
+
+        conv = await handler.get_converters_by_lamp_type("boa")
+        print([c.artnr for c in conv])
+        limits = await handler.get_lamp_limits(930544, "boa")  
+        print("Lamp limits:", limits)
+        # hybrid_results = await handler.hybrid_search("give me converters for boa wc which cost less than 50 ")
+        # print("Hybrid search results:")
+        # for result in hybrid_results:
+        #     print(f"\t{result.converter_description} (ARTNR: {result.artnr})")
+        #     print(f"\ttypes: {result.type}")
+        #     print(f"\tprice: {result.price}")
+        #     print(f'\tpdf_link: {result.pdf_link}\n')
+
+    asyncio.run(main())

README.md

@@ -1,12 +1,6 @@
 ---
 title: SemanticKernelFinal
-emoji: 🦀
-colorFrom: indigo
-colorTo: red
+app_file: chatbot-gradio.py
 sdk: gradio
-sdk_version: 5.34.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,482 @@
+import logging
+import uuid
+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
+from plugins.chatMemoryPlugin import ChatMemoryPlugin
+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")
+))
+
+
+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", "SET"]):
+            return "Invalid operation"
+
+        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:
+            - c.type (e.g., '350mA') - for queries related to current (mA) always refer to c.type 
+            - c.artnr (numeric (int) article number e.g., 930546)
+            - c.output_voltage_v: dictionary with min/max values for output voltage
+            - c.output_voltage_v.min (e.g., 15)
+            - c.output_voltage_v.max (e.g., 40)
+            - c.nom_input_voltage_v: dictionary with min/max values for input voltage
+            - c.nom_input_voltage_v.min (e.g., 198)
+            - c.nom_input_voltage_v.max (e.g., 264)
+            - c.lamps: dictionary with min/max values for lamp types for this converter
+            - c.lamps["lamp_name"].min (e.g., 1)
+            - c.lamps["lamp_name"].max (e.g., 10)
+            - c.class (safety class)
+            - c.dimmability (e.g. if not dimmable 'NOT DIMMABLE'. if supports dimming, 'DALI/TOUCHDIM','MAINS DIM LC', '1-10V','CASAMBI' etc)
+            - c.listprice (e.g., 58)
+            - c.lifecycle (e.g., 'Active')
+            - c.size (e.g., '150x30x30')
+            - c.dimlist_type (e.g., 'DALI')
+            - c.pdf_link (link to product PDF)
+            - c.converter_description (e.g., 'POWERLED CONVERTER REMOTE 180mA 8W IP20 1-10V')
+            - c.ip (Ingress Protection, integer values e.g., 20,67)
+            - c.efficiency_full_load (e.g., 0.9)
+            - c.name (e.g., 'Power Converter 350mA')
+            - c.unit (e.g., 'PC')
+            - c.strain_relief (e.g., "NO", "YES")
+        Example document for reference:
+        c = {{
+            "id": "8797fff0-e0a8-4e23-aad0-06209881b1d3",
+            "type": "350mA",
+            "artnr": 984500,
+            "converter_description": "POWERLED CONVERTER REMOTE 350mA 18W IP20 DALI/TOUCHDIM",
+            "strain_relief": "YES",
+            "location": "INDOOR",
+            "dimmability": "DALI/TOUCHDIM",
+            "ccr_amplitude": "YES",
+            "efficiency_full_load": 0.85,
+            "ip": 20,
+            "class": 2,
+            "nom_input_voltage_v": {{"min": 220, "max": 240}},
+            "output_voltage_v": {{"min": 9, "max": 52}},
+            "barcode": "54 15233 15690 8",
+            "name": "POWERLED REMOTE CONVERTER (18.2W) TOUCH DALI DIM 350mA",
+            "listprice": 47,
+            "unit": "PC",
+            "lifecycle": "A",
+            "pdf_link": "...",
+            "lamps": {{
+                "Single led XPE": {{"min": 3, "max": 15}},
+                "Thinksmall/floorspot WC luxeon MX": {{"min": 1, "max": 4}},
+                "*MIX 6 monocolor": {{"min": 1, "max": 2}},
+                "Cedrus quantum": {{"min": 1, "max": 2}},
+                "*MIX 6 halosphere": {{"min": 1, "max": 2}},
+                "MIX 13 monocolor": {{"min": 1, "max": 1}},
+                "MIX 13 halosphere": {{"min": 1, "max": 1}},
+                "ORBITAL monocolor": {{"min": 1, "max": 1}},
+                "ORBITAL halosphere": {{"min": 1, "max": 1}},
+                "Beaufort²": {{"min": 1, "max": 1}},
+                "Beaufort": {{"min": 1, "max": 1}},
+                "Haloled": {{"min": 1, "max": 4}},
+                "B4": {{"min": 1, "max": 4}},
+                "MIX 26 monocolor": {{"min": 1, "max": 1}},
+                "*BOA WC": {{"min": 1, "max": 5}}
+            }},
+            "size": "160*42*30"
+        }}
+        SQL Guidelines (if needed):
+            - Always use SELECT * and never individual fields
+            - When current like 350mA is detected, always query the c.type field
+            - Always refer to fields in SELECT or 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
+            - For lamp compatibility: Use WHERE IS_DEFINED(c.lamps["lamp_name"]) to check if a specific lamp is supported, or WHERE IS_DEFINED(c.lamps) for any lamp support.
+                                    
+        Examples:
+            - What is the price of 40063 : SELECT * FROM c WHERE c.artnr=40063
+            - Give me converters with an output voltage range of exactly 2-25 : SELECT * FROM c WHERE c.output_voltage_v.min=2 AND c.output_voltage_v.max=25
+            - Find converters with an input voltage range of exactly 90-264 : SELECT * FROM c WHERE c.nom_input_voltage_v.min = 90 AND c.nom_input_voltage_v.max = 264
+            - Find converters that support a specific lamp type (e.g., "B4") : SELECT * FROM c WHERE IS_DEFINED(c.lamps["B4"])
+            - Find converters that support any lamp (check for lamp compatibility) : SELECT * FROM c WHERE IS_DEFINED(c.lamps)
+            - Find converters with a specific IP rating (e.g., 67): SELECT * FROM c WHERE c.ip = 67
+            - List of 350mA converters compatible with Haloled: SELECT * FROM c WHERE IS_DEFINED(c.lamps["Haloled"]) ANlist oD c.type="350mA"
+            - List 700mA drivers: SELECT * FROM c WHERE c.type="700mA"
+        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}")
+        log_sql_func = kernel.get_function("ChatMemoryPlugin", "log_sql_query")
+
+        await kernel.invoke(
+            function=log_sql_func,
+            original_question=question,
+            generated_sql=response
+        )
+        
+        return str(response)
+
+
+# Register plugins
+kernel.add_plugin(ConverterPlugin(logger=logger), "CosmosDBPlugin")
+kernel.add_plugin(ChatMemoryPlugin(logger=logger), "ChatMemoryPlugin")
+kernel.add_plugin(NL2SQLPlugin(), "NL2SQLPlugin")
+
+# Updated query handler using function calling
+async def handle_query(user_input: str):
+    session_id = str(uuid.uuid4()) 
+    
+    settings = AzureChatPromptExecutionSettings(
+            function_choice_behavior=FunctionChoiceBehavior.Auto(auto_invoke=True)        
+        )
+    
+    ARTNR_PATTERN = r'\b\d{6}\b'
+    
+    prompt = f"""
+    You are a product catalog customer service chatbot for TAL BV. Answer questions about converters, their specifications and lamps. Process this user query:
+    {user_input}
+
+    artnr Pattern: {ARTNR_PATTERN}
+    
+    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
+    - get_converters_by_dimming: use when question contains dimming types WITHOUT artnr (if query contains mains c, dali, 1-10v, mains)
+    - get_converters_by_voltage_current: use for questions about input or output voltage
+    
+    Decision Flow:
+    1. Identify synonyms :
+        output voltage = voltage forward = forward voltage = Vf
+        Driver = ledconverter = converter = power supply = gear
+        lamps = luminares
+        ip = Ingress Protection and NOT INPUT VOLTAGE
+    
+    2. Check for explicit dimming types (dali/1-10V/mains/casambi):
+        - If found → use get_converters_by_dimming
+        - Include lamp_type parameter if lamp is mentioned
+
+    3. 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
+    - "drivers on 24V output" → get_converters_by_voltage_current
+    - "drivers on 350ma"  → get_converters_by_voltage_current
+    
+    4. Use SQL generation ONLY when:
+    - Query contains schema keywords: price, type, ip, efficiency, size, class, strain relief, lifecycle,
+    - Combining multiple conditions (AND/OR/NOT)
+    - Needs complex filtering/sorting
+    - Requesting technical specifications for a specific converter like "dimming type of converter [artnr]", "size of [artnr]"
+    
+    5. NEVER
+        - use get_converters_by_dimming when artnr Pattern is detected
+        - use get_converters_by_lamp_type when dimming type like dali, mains is mentioned
+        - use "ipXX" as input_voltage parameter in get_converters_by_voltage_current
+        - interpret "ip" as input voltage (IP = Ingress Protection)
+    
+    6. For IP ratings:
+        - Extract using regex: r'ip[\s]?(\d+)'
+        - Use SQL: SELECT * FROM c WHERE c.ip = X
+        - NEVER route to voltage-related functions
+    
+    6. If you cannot identify any relevant keywords, respond with a friendly message clarifying what you are and what they can ask for."
+    7. If no results are recieved, give an apologetic reason. Never respond with SQL query suggestions.
+    
+    Examples:
+    User: "Show IP67 converters under €100" → generate_sql
+    User: "What lamps are compatible with 930560?" → get_compatible_lamps
+    User: "List of 1p20 drivers for haloled single on track" → get_converters_by_lamp_type(lamp_type="haloled single on track") → inspect returned converters
+    User: "List 700mA drivers with ip20 rating"  → get_converters_by_voltage_current(current = "700mA") → inspect returned converters
+    User: "List of 350mA drivers" → get_converters_by_voltage_current(current = "350mA")
+    User: "What converters are compatible with haloled lamps?" → get_converters_by_lamp_type
+    User: "Voltage range for 930562" → generate_sql
+    User: "Dimming type of 930581"  → generate_sql
+    User: "List of dali drivers on 24V output?" → get_converters_by_dimming"
+    User: 'List of 24V drivers for ledline medium power → get_converters_by_dimming(dimming_type=None, lamp_type="ledline medium power",voltage_current="24V")(or) get_converters_by_lamp_type(lamp_type="ledline medium power") → inspect returned converters '
+    """
+    try:
+        result = await kernel.invoke_prompt(
+            prompt=prompt,
+            settings=settings
+        )
+        
+        log_func = kernel.get_function("ChatMemoryPlugin", "log_interaction")
+        await log_func.invoke(
+            kernel=kernel,
+            session_id=session_id,
+            question=user_input,
+            function_used="handle_query",
+            answer=str(result)
+        )
+        
+        return str(result)
+    
+    except Exception as e:
+        # Handle errors properly
+        error_func = kernel.get_function("ChatMemoryPlugin", "log_interaction")
+        await error_func.invoke(
+            kernel=kernel,
+            session_id=session_id,
+            question=user_input,
+            function_used="error",
+            answer=str(e)
+        )
+        raise
+
+# # Example usage
+# async def main():
+#     # cm = ChatMemoryPlugin(logger)
+#     # await cm.get_semantic_faqs()
+
+#    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())
+
+# --- 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.4);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: all 0.3s ease;
+}
+
+#chatbot-panel {
+    position: fixed;
+    bottom: 10vw;
+    right: 2vw;
+    z-index: 10000;
+    width: 95vw;
+    max-width: 600px;
+    height: 90vh;
+    max-height: 700px;
+    background-color: #ffffff;
+    border-radius: 20px;
+    box-shadow: 0 4px 24px rgba(0, 0, 0, 0.25);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    font-family: 'Arial', sans-serif;
+}
+
+@media (max-width: 600px) {
+    #chatbot-panel {
+        width: 100vw;
+        height: 100vh;
+        right: 0;
+        bottom: 0;
+        border-radius: 0;
+    }
+    #chatbot-toggle-btn {
+        right: 10px;
+        bottom: 10px;
+        width: 48px;
+        height: 48px;
+        font-size: 24px;
+    }
+}
+
+#chatbot-panel.hide {
+    display: none !important;
+}
+
+#chat-header {
+    background-color: #ED1C24;
+    color: white;
+    padding: 20px;
+    font-weight: bold;
+    font-size: 22px;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    width: 100%;
+    box-sizing: border-box;
+}
+
+#chat-header img {
+    border-radius: 50%;
+    width: 40px;
+    height: 40px;
+}
+
+.gr-chatbot {
+    flex: 1;
+    overflow-y: auto;
+    padding: 20px;
+    background-color: #f9f9f9;
+    border-top: 1px solid #eee;
+    border-bottom: 1px solid #eee;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+    box-sizing: border-box;
+}
+
+.gr-textbox {
+    padding: 16px 20px;
+    background-color: #fff;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    border-top: 1px solid #eee;
+    box-sizing: border-box;
+}
+
+.gr-textbox textarea {
+    flex: 1;
+    resize: none;
+    padding: 12px;
+    background-color: white;
+    border: 1px solid #ccc;
+    border-radius: 8px;
+    font-family: inherit;
+    font-size: 16px;
+    box-sizing: border-box;
+    height: 48px;
+    line-height: 1.5;
+}
+
+.gr-textbox button {
+    background-color: #ED1C24;
+    border: none;
+    color: white;
+    border-radius: 8px;
+    padding: 12px 20px;
+    cursor: pointer;
+    font-weight: bold;
+    transition: background-color 0.3s ease;
+    font-size: 16px;
+}
+
+.gr-textbox button:hover {
+    background-color: #c4161c;
+}
+
+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")
+        send = gr.Button("Send")
+        # 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
+    send.click(respond, [msg, chatbot], [msg,chatbot])
+    msg.submit(respond, [msg, chatbot], [msg, chatbot])
+    toggle_btn.click(toggle_panel, outputs=chat_panel)
+
+demo.launch()

improvements.txt

@@ -0,0 +1,24 @@
+remove sql query in chatbot reply upon query failure
+size formatting in reply
+new gradio frontend
+remove unecessary fields in return to save computing power
+List of drivers compatible with only b4 on 350mA? 
+List of drivers compatible with only haloled on 350mA and add min and max. qty of luminaires? 
+commonly asked questions/queries?
+improve error message
+implement lamp name normalisation in geenrate query too idk how
+lamp name recognition for names like haloled single on track
+User: list of drivers on 350mA that support B4
+[2025-06-13 11:56:59,151 - kernel:229 - INFO] Found 0 converters matching criteria
+[2025-06-13 11:56:59,151 - kernel:89 - INFO] Used get_converters_by_dimming with dimming type: 350mA
+                                                                     voltage_current: None
+                                                                     lamp_type: B4
+I'm just a technical assistant for TAL BV. Please let me know if you have any questio
+caching
+
+
+improved scoring based [artial matchig for lamp search]
+
+chat memory/ caching for query generation
+
+fix generate query logging for errors/badrequests

models/converterModels.py

@@ -0,0 +1,56 @@
+# 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)
+        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)
+        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")
+
+    strain_relief: Optional[str] = Field(None, alias="strain_relief")
+    gross_weight: Optional[float] = Field(None, alias="gross_weight")
+
+    model_config = ConfigDict(
+        populate_by_name=True,  # Critical fix
+
+        extra="ignore"  
+    )

plugins/chatMemoryPlugin.py

@@ -0,0 +1,42 @@
+#converterPlugin.py
+from datetime import datetime
+from typing import Annotated, Dict, List, Optional
+import uuid
+from CosmosDBHandlers.cosmosConnector import CosmosLampHandler
+from semantic_kernel.functions import kernel_function
+from CosmosDBHandlers.cosmosChatHistoryHandler import ChatMemoryHandler
+class ChatMemoryPlugin:
+    def __init__(self, logger):
+        self.logger = logger
+        self.chat_memory_handler = ChatMemoryHandler(logger)
+
+    @kernel_function(name="log_interaction", description="Logs chat interactions")
+    async def log_interaction(self, session_id: str, question: str, function_used: str, answer: str):
+
+        try:
+            await self.chat_memory_handler.log_interaction(session_id=session_id,
+                                                           question=question,
+                                                           function_used=function_used,
+                                                           answer=answer)
+        except Exception as e:
+            self.logger.error(f"Failed to log chat interaction: {str(e)}")
+
+    @kernel_function(name="log_sql_query", description="Logs generated SQL queries")
+    async def log_sql_query(self, original_question: str, generated_sql: str):
+        
+        try:
+            await self.chat_memory_handler.log_sql_query(original_question=original_question,
+                                                         generated_sql=generated_sql)
+        except Exception as e:
+            self.logger.error(f"Failed to log SQL query: {str(e)}")
+    
+
+    async def get_semantic_faqs(self, limit:int=5, threshold: float = 0.1) -> List[Dict]:
+        """Retrieve FAQs using vector embeddings for semantic similarity"""
+        try:
+            faqs_dict = await self.chat_memory_handler.get_semantic_faqs(limit=limit, threshold=threshold)
+            faqs = [faq["representative_question"] for faq in faqs_dict]
+            self.logger.info(faqs)
+        except Exception as e:
+            self.logger.error(f"Semantic FAQ retrieval failed: {str(e)}")
+            return []

plugins/converterPlugin.py

@@ -0,0 +1,143 @@
+#converterPlugin.py
+from typing import Annotated, Optional
+from CosmosDBHandlers.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(
+            name = "get_converter_info",
+            description="Get information about a converter using its artnr (partition key)"
+    )
+    async def get_converter_info(self, artnr:int) -> str:
+        try:
+            converter = await self.db.get_converter_info(artnr)
+            self.logger.info(f"Used get_converter_info with artrn: {artnr}")
+            return  f"{converter.model_dump()})"
+        except Exception as e:
+            f"Failed to retrieve converter {artnr} - {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"
+        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.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_converters_by_dimming",
+            description="Find converters of a specified dimming type"
+    )
+    async def get_converters_by_dimming(
+        self,
+        dimming_type: Annotated[str, "Dimming type mentioned like dali, mains, 1-10v"],
+        voltage_current: Annotated[str | None,"Voltage or current specification like 350mA, 24V DC"] = None,
+        lamp_type: Annotated[str | None, "Lamp model (e.g., Haloled, B4)"] = None,
+        threshold: int = 75) -> str:
+        """Search converters by dimming type with technical specifications"""
+        try:
+            converters = await self.db.get_converters_by_dimming(
+                                                    dimming_type=dimming_type,
+                                                    voltage_current=voltage_current,
+                                                    lamp_type=lamp_type,
+                                                    threshold=threshold)
+            self.logger.info(f"""Used get_converters_by_dimming with dimming type: {dimming_type}
+                                                                     voltage_current: {voltage_current}
+                                                                     lamp_type: {lamp_type}""")
+            if not converters:
+                return "No relavent converters found"
+            return "\n".join([f"{c.model_dump()})" for c in converters]) if converters else "No converters found"
+            
+        
+        except Exception as e:
+            return f"Error returning 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="get_converters_by_voltage",
+        description="Get converters that have the mentioned input/output voltage range or current"
+    )
+    async def get_converters_by_voltage_current(
+        self,
+        artnr: Annotated[int, ""] = None,
+        current: Annotated[str, "Current like 350mA, 700mA"]=None,
+        input_voltage: Annotated[str, "Input voltage range like '198-464' NEVER ip"] = None,
+        output_voltage: Annotated[str, "Output voltage range like '24', '2-25'"] = None
+    ) -> str:
+        try:
+            converters = await self.db.get_converters_by_voltage_current(artnr=artnr,
+                                                                current=current,
+                                                                input_voltage=input_voltage,
+                                                                output_voltage=output_voltage)
+            self.logger.info(f"""Used get_converters_by_voltage_current with input_voltage: {input_voltage}
+                                                                     output_voltage: {output_voltage}
+                                                                     current: {current}
+                                                                     artnr: {artnr}""")
+            if not converters:
+                return "No relavent converters found"
+            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"  

requirements.txt

@@ -0,0 +1,3 @@
+semantic-kernel
+azure-cosmos
+rapidfuzz