ai service refactor

app/service/ai_service.py

@@ -1,108 +1,108 @@
-# app/service/ai_service.py
-import json
-import logging
-from app.deps import get_vector_db
-from app.service.llm_service import LocalLLMService
-from app.service.embedding_service import embedder
-import time
+# # app/service/ai_service.py
+# import json
+# import logging
+# from app.deps import get_vector_db
+# from app.service.llm_service import LocalLLMService
+# from app.service.embedding_service import embedder
+# import time
 
-logger = logging.getLogger(__name__)
+# logger = logging.getLogger(__name__)
 
-class AIService:
-    def __init__(self):
-        try:
-            self.vector_db = get_vector_db()
-            self.vss_available = True
-            logger.info("✅ Vector DB initialized")
-        except Exception as e:
-            logger.warning(f"⚠️ Vector DB unavailable: {e}")
-            self.vector_db = None
-            self.vss_available = False
+# class AIService:
+#     def __init__(self):
+#         try:
+#             self.vector_db = get_vector_db()
+#             self.vss_available = True
+#             logger.info("✅ Vector DB initialized")
+#         except Exception as e:
+#             logger.warning(f"⚠️ Vector DB unavailable: {e}")
+#             self.vector_db = None
+#             self.vss_available = False
         
-        self.llm = llm_service
-        self.embedder = embedder
-        logger.info(f"✅ AI Service initialized (VSS: {'ENABLED' if self.vss_available else 'DISABLED'})")
+#         self.llm = llm_service
+#         self.embedder = embedder
+#         logger.info(f"✅ AI Service initialized (VSS: {'ENABLED' if self.vss_available else 'DISABLED'})")
     
-    def detect_entity_type(self, org_id: str, columns: list[str], filename: str) -> dict:
-        """Detect entity type with JSON validation and timeout"""
-        columns_str = ",".join(columns)
+#     def detect_entity_type(self, org_id: str, columns: list[str], filename: str) -> dict:
+#         """Detect entity type with JSON validation and timeout"""
+#         columns_str = ",".join(columns)
         
-        # Check cache
-        if self.vss_available:
-            cached = self.vector_db.execute("""
-                SELECT entity_type FROM vector_store.embeddings
-                WHERE org_id = ? AND content = ?
-                ORDER BY created_at DESC LIMIT 1
-            """, [org_id, columns_str]).fetchone()
+#         # Check cache
+#         if self.vss_available:
+#             cached = self.vector_db.execute("""
+#                 SELECT entity_type FROM vector_store.embeddings
+#                 WHERE org_id = ? AND content = ?
+#                 ORDER BY created_at DESC LIMIT 1
+#             """, [org_id, columns_str]).fetchone()
             
-            if cached:
-                logger.info(f"[ai_service] Cache hit: {cached[0]}")
-                return {"entity_type": cached[0], "confidence": 0.99, "cached": True}
+#             if cached:
+#                 logger.info(f"[ai_service] Cache hit: {cached[0]}")
+#                 return {"entity_type": cached[0], "confidence": 0.99, "cached": True}
         
-        # ✅ SIMPLE, CLEAR prompt for Phi-3
-        prompt = f"""You are a data classification assistant. 
+#         # ✅ SIMPLE, CLEAR prompt for Phi-3
+#         prompt = f"""You are a data classification assistant. 
         
-You MUST respond with ONLY valid JSON in this exact format:
-{{"entity_type":"sales|inventory|customer|product","confidence":0.95}}
+# You MUST respond with ONLY valid JSON in this exact format:
+# {{"entity_type":"sales|inventory|customer|product","confidence":0.95}}
 
-Dataset info:
-- Filename: {filename}
-- Columns: {columns_str}
+# Dataset info:
+# - Filename: {filename}
+# - Columns: {columns_str}
 
-Analyze and respond with ONLY JSON:"""
+# Analyze and respond with ONLY JSON:"""
         
-        logger.info(f"[ai_service] Calling LLM for {org_id}...")
+#         logger.info(f"[ai_service] Calling LLM for {org_id}...")
         
-        try:
-            # ✅ TIMEOUT WRAPPER (5 seconds max)
-            start_time = time.time()
-            response_text = self.llm.generate(prompt, max_tokens=50, temperature=0.1)
-            elapsed = time.time() - start_time
+#         try:
+#             # ✅ TIMEOUT WRAPPER (5 seconds max)
+#             start_time = time.time()
+#             response_text = self.llm.generate(prompt, max_tokens=50, temperature=0.1)
+#             elapsed = time.time() - start_time
             
-            logger.info(f"[ai_service] LLM responded in {elapsed:.2f}s: {response_text}")
+#             logger.info(f"[ai_service] LLM responded in {elapsed:.2f}s: {response_text}")
             
-            # ✅ AGGRESSIVE JSON cleaning
-            response_text = response_text.strip()
-            if "```json" in response_text:
-                response_text = response_text.split("```json")[1].split("```")[0].strip()
-            elif "```" in response_text:
-                response_text = response_text.split("```")[1].split("```")[0].strip()
+#             # ✅ AGGRESSIVE JSON cleaning
+#             response_text = response_text.strip()
+#             if "```json" in response_text:
+#                 response_text = response_text.split("```json")[1].split("```")[0].strip()
+#             elif "```" in response_text:
+#                 response_text = response_text.split("```")[1].split("```")[0].strip()
             
-            # ✅ Remove any stray text before/after JSON
-            if "{" in response_text and "}" in response_text:
-                response_text = response_text[response_text.find("{"):response_text.rfind("}")+1]
+#             # ✅ Remove any stray text before/after JSON
+#             if "{" in response_text and "}" in response_text:
+#                 response_text = response_text[response_text.find("{"):response_text.rfind("}")+1]
             
-            logger.info(f"[ai_service] Cleaned response: {response_text}")
+#             logger.info(f"[ai_service] Cleaned response: {response_text}")
             
-            # ✅ PARSE with error handling
-            result = json.loads(response_text)
+#             # ✅ PARSE with error handling
+#             result = json.loads(response_text)
             
-            # ✅ Normalize
-            result["entity_type"] = result["entity_type"].upper()
-            result["confidence"] = float(result["confidence"])
+#             # ✅ Normalize
+#             result["entity_type"] = result["entity_type"].upper()
+#             result["confidence"] = float(result["confidence"])
             
-            # ✅ Cache it
-            if self.vss_available:
-                try:
-                    embedding = self.embedder.generate(columns_str)
-                    self.vector_db.execute("""
-                        INSERT INTO vector_store.embeddings (org_id, content, embedding, entity_type)
-                        VALUES (?, ?, ?, ?)
-                    """, [org_id, columns_str, embedding, result["entity_type"]])
-                    logger.info(f"[ai_service] Cached for {org_id}")
-                except Exception as e:
-                    logger.warning(f"[ai_service] Cache insert failed: {e}")
+#             # ✅ Cache it
+#             if self.vss_available:
+#                 try:
+#                     embedding = self.embedder.generate(columns_str)
+#                     self.vector_db.execute("""
+#                         INSERT INTO vector_store.embeddings (org_id, content, embedding, entity_type)
+#                         VALUES (?, ?, ?, ?)
+#                     """, [org_id, columns_str, embedding, result["entity_type"]])
+#                     logger.info(f"[ai_service] Cached for {org_id}")
+#                 except Exception as e:
+#                     logger.warning(f"[ai_service] Cache insert failed: {e}")
             
-            return result
+#             return result
             
-        except Exception as e:
-            logger.error(f"[ai_service] ❌ Detection failed: {e}", exc_info=True)
-            # ✅ SAFE FALLBACK (never crash)
-            return {
-                "entity_type": "SALES", 
-                "confidence": 0.50, 
-                "error": str(e),
-                "fallback": True
-            }
+#         except Exception as e:
+#             logger.error(f"[ai_service] ❌ Detection failed: {e}", exc_info=True)
+#             # ✅ SAFE FALLBACK (never crash)
+#             return {
+#                 "entity_type": "SALES", 
+#                 "confidence": 0.50, 
+#                 "error": str(e),
+#                 "fallback": True
+#             }
 
-ai_service = AIService()
+# ai_service = AIService()