isa-model 0.3.9__py3-none-any.whl → 0.4.0__py3-none-any.whl

isa_model/core/services/intelligent_model_selector.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 """
-Intelligent Model Selector - Simple similarity-based model selection
+Intelligent Model Selector - Embedding-based model selection
 Uses embedding similarity matching against model descriptions and metadata
 """
 
@@ -10,44 +10,28 @@ import logging
 import asyncio
 import json
 from typing import Dict, List, Any, Optional, Tuple
-from pathlib import Path
-import yaml
 
 logger = logging.getLogger(__name__)
 
-try:
-    import asyncpg
-    from pgvector.asyncpg import register_vector
-    PGVECTOR_AVAILABLE = True
-except ImportError:
-    PGVECTOR_AVAILABLE = False
-    logger.warning("pgvector not available, model selector will use in-memory fallback")
-
-try:
-    from supabase import create_client, Client
-    SUPABASE_AVAILABLE = True
-except ImportError:
-    SUPABASE_AVAILABLE = False
-    logger.warning("Supabase not available, falling back to SQLite")
+from ..database.supabase_client import get_supabase_client
+from ...inference.ai_factory import AIFactory
 
 
 class IntelligentModelSelector:
     """
-    Simple intelligent model selector using embedding similarity
+    Intelligent model selector using embedding similarity
     
     Features:
-    - Embeds model descriptions and metadata
-    - Stores embeddings in pgvector for fast similarity search
-    - Falls back to in-memory similarity if pgvector unavailable
+    - Reads models from database registry
+    - Uses unified Supabase client
+    - Uses existing embedding service for similarity matching
     - Has default models for each service type
     """
     
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         self.config = config or {}
-        self.db_pool = None
         self.supabase_client = None
         self.embedding_service = None
-        self.model_embeddings: Dict[str, List[float]] = {}
         self.models_metadata: Dict[str, Dict[str, Any]] = {}
         
         # Default models for each service type
@@ -55,7 +39,7 @@ class IntelligentModelSelector:
             "vision": {"model_id": "gpt-4.1-mini", "provider": "openai"},
             "audio": {"model_id": "whisper-1", "provider": "openai"},
             "text": {"model_id": "gpt-4.1-mini", "provider": "openai"},
-            "image": {"model_id": "flux-schnell", "provider": "replicate"},
+            "image": {"model_id": "black-forest-labs/flux-schnell", "provider": "replicate"},
             "embedding": {"model_id": "text-embedding-3-small", "provider": "openai"},
             "omni": {"model_id": "gpt-4.1", "provider": "openai"}
         }
@@ -65,17 +49,15 @@ class IntelligentModelSelector:
     async def initialize(self):
         """Initialize the model selector"""
         try:
+            # Initialize Supabase client
+            self.supabase_client = get_supabase_client()
+            logger.info("Supabase client initialized")
+            
             # Initialize embedding service
             await self._init_embedding_service()
             
-            # Initialize database - try Supabase first, then PostgreSQL
-            if SUPABASE_AVAILABLE and self.config.get("supabase"):
-                await self._init_supabase()
-            elif PGVECTOR_AVAILABLE:
-                await self._init_database()
-            
-            # Load and embed models
-            await self._load_models()
+            # Load models from database
+            await self._load_models_from_database()
             
             logger.info("Model selector fully initialized")
             
@@ -86,199 +68,58 @@ class IntelligentModelSelector:
     async def _init_embedding_service(self):
         """Initialize embedding service for text similarity"""
         try:
-            from isa_model.inference.ai_factory import AIFactory
             factory = AIFactory.get_instance()
             self.embedding_service = factory.get_embed("text-embedding-3-small", "openai")
             logger.info("Embedding service initialized")
         except Exception as e:
             logger.warning(f"Failed to initialize embedding service: {e}")
     
-    async def _init_supabase(self):
-        """Initialize Supabase client for vector search"""
+    async def _load_models_from_database(self):
+        """Load models from database registry"""
         try:
-            supabase_config = self.config.get("supabase", {})
-            url = supabase_config.get("url")
-            key = supabase_config.get("key")
-            
-            if not url or not key:
-                # Try environment variables
-                import os
-                url = url or os.getenv("SUPABASE_URL")
-                key = key or os.getenv("SUPABASE_ANON_KEY")
+            # Get all models from database
+            result = self.supabase_client.table('models').select('*').execute()
+            models = result.data
             
-            if not url or not key:
-                raise ValueError("Supabase URL and key are required")
-            
-            self.supabase_client = create_client(url, key)
-            logger.info("Supabase client initialized successfully")
-            
-        except Exception as e:
-            logger.warning(f"Supabase initialization failed: {e}, using in-memory fallback")
-            self.supabase_client = None
-    
-    async def _init_database(self):
-        """Initialize pgvector database connection"""
-        try:
-            # Get database configuration
-            db_config = self.config.get("database", {
-                "host": "localhost",
-                "port": 5432,
-                "database": "isa_model", 
-                "user": "postgres",
-                "password": "password"
-            })
-            
-            # Create connection pool
-            self.db_pool = await asyncpg.create_pool(
-                host=db_config["host"],
-                port=db_config["port"], 
-                database=db_config["database"],
-                user=db_config["user"],
-                password=db_config["password"],
-                min_size=1,
-                max_size=5
-            )
-            
-            # Register vector extension
-            async with self.db_pool.acquire() as conn:
-                await register_vector(conn)
-                
-                # Create models table if not exists
-                await conn.execute("""
-                    CREATE EXTENSION IF NOT EXISTS vector;
-                    
-                    CREATE TABLE IF NOT EXISTS model_embeddings (
-                        id SERIAL PRIMARY KEY,
-                        model_id VARCHAR(255) UNIQUE NOT NULL,
-                        provider VARCHAR(100) NOT NULL,
-                        model_type VARCHAR(50) NOT NULL,
-                        description TEXT,
-                        metadata JSONB,
-                        embedding vector(1536),
-                        created_at TIMESTAMP DEFAULT NOW(),
-                        updated_at TIMESTAMP DEFAULT NOW()
-                    );
-                    
-                    CREATE INDEX IF NOT EXISTS idx_model_embeddings_similarity 
-                    ON model_embeddings USING ivfflat (embedding vector_cosine_ops);
-                """)
-            
-            logger.info("Database initialized successfully")
-            
-        except Exception as e:
-            logger.warning(f"Database initialization failed: {e}, using in-memory fallback")
-            self.db_pool = None
-    
-    async def _load_models(self):
-        """Load models from YAML configs and create embeddings"""
-        try:
-            # Get config directory
-            config_dir = Path(__file__).parent.parent.parent / "config" / "models"
-            
-            if not config_dir.exists():
-                logger.warning(f"Model config directory not found: {config_dir}")
-                return
-            
-            # Load all YAML files
-            for yaml_file in config_dir.glob("*.yaml"):
-                await self._load_models_from_file(yaml_file)
-            
-            logger.info(f"Loaded {len(self.models_metadata)} models for similarity matching")
-            
-        except Exception as e:
-            logger.error(f"Failed to load models: {e}")
-    
-    async def _load_models_from_file(self, yaml_file: Path):
-        """Load models from a specific YAML file"""
-        try:
-            with open(yaml_file, 'r', encoding='utf-8') as f:
-                data = yaml.safe_load(f)
-            
-            provider = data.get("provider", "unknown")
-            models = data.get("models", [])
+            logger.info(f"Found {len(models)} models in database registry")
             
+            # Process each model
             for model in models:
-                await self._process_model(model, provider)
+                model_id = model['model_id']
                 
-        except Exception as e:
-            logger.error(f"Failed to load models from {yaml_file}: {e}")
-    
-    async def _process_model(self, model: Dict[str, Any], provider: str):
-        """Process a single model and create embeddings"""
-        try:
-            model_id = model.get("model_id")
-            if not model_id:
-                return
+                # Parse metadata if it's a string (from JSONB)
+                metadata_raw = model.get('metadata', '{}')
+                if isinstance(metadata_raw, str):
+                    try:
+                        metadata = json.loads(metadata_raw)
+                    except json.JSONDecodeError:
+                        metadata = {}
+                else:
+                    metadata = metadata_raw if isinstance(metadata_raw, dict) else {}
+                
+                # Store model metadata
+                self.models_metadata[model_id] = {
+                    "provider": model['provider'],
+                    "model_type": model['model_type'],
+                    "metadata": metadata
+                }
             
-            # Create searchable text from description and metadata
-            description = model.get("metadata", {}).get("description", "")
-            specialized_tasks = model.get("metadata", {}).get("specialized_tasks", [])
-            capabilities = model.get("capabilities", [])
+            # Check embeddings status
+            embeddings_result = self.supabase_client.table('model_embeddings').select('model_id').execute()
+            existing_embeddings = {row['model_id'] for row in embeddings_result.data}
             
-            # Combine all text for embedding
-            search_text = f"{description} "
-            search_text += f"Capabilities: {', '.join(capabilities)} "
-            search_text += f"Tasks: {', '.join(specialized_tasks)}"
+            logger.info(f"Found {len(existing_embeddings)} model embeddings")
+            logger.info(f"Loaded {len(self.models_metadata)} models for similarity matching")
             
-            # Create embedding
-            if self.embedding_service:
-                try:
-                    embedding = await self.embedding_service.create_text_embedding(search_text)
-                    
-                    # Store model metadata
-                    self.models_metadata[model_id] = {
-                        "provider": provider,
-                        "model_type": model.get("model_type"),
-                        "capabilities": capabilities,
-                        "metadata": model.get("metadata", {}),
-                        "search_text": search_text
-                    }
-                    
-                    # Store embedding
-                    if self.db_pool:
-                        await self._store_model_embedding(model_id, provider, model, embedding)
-                    else:
-                        self.model_embeddings[model_id] = embedding
-                        
-                except Exception as e:
-                    logger.warning(f"Failed to create embedding for {model_id}: {e}")
+            # Warn if models don't have embeddings
+            missing_embeddings = set(self.models_metadata.keys()) - existing_embeddings
+            if missing_embeddings:
+                logger.warning(f"Models without embeddings: {list(missing_embeddings)}")
+                logger.warning("Embeddings are generated during startup. Consider restarting the service.")
             
         except Exception as e:
-            logger.error(f"Failed to process model {model.get('model_id', 'unknown')}: {e}")
+            logger.error(f"Failed to load models from database: {e}")
     
-    async def _store_model_embedding(
-        self, 
-        model_id: str, 
-        provider: str, 
-        model: Dict[str, Any], 
-        embedding: List[float]
-    ):
-        """Store model embedding in database"""
-        try:
-            async with self.db_pool.acquire() as conn:
-                await conn.execute("""
-                    INSERT INTO model_embeddings 
-                    (model_id, provider, model_type, description, metadata, embedding)
-                    VALUES ($1, $2, $3, $4, $5, $6)
-                    ON CONFLICT (model_id) 
-                    DO UPDATE SET 
-                        provider = $2,
-                        model_type = $3,
-                        description = $4,
-                        metadata = $5,
-                        embedding = $6,
-                        updated_at = NOW()
-                """, 
-                    model_id,
-                    provider,
-                    model.get("model_type"),
-                    model.get("metadata", {}).get("description", ""),
-                    json.dumps(model.get("metadata", {})),
-                    embedding
-                )
-                
-        except Exception as e:
-            logger.error(f"Failed to store embedding for {model_id}: {e}")
     
     async def select_model(
         self,
@@ -304,13 +145,8 @@ class IntelligentModelSelector:
             
             request_embedding = await self.embedding_service.create_text_embedding(request)
             
-            # Find similar models
-            if self.supabase_client:
-                candidates = await self._find_similar_models_supabase(request_embedding, service_type)
-            elif self.db_pool:
-                candidates = await self._find_similar_models_db(request_embedding, service_type)
-            else:
-                candidates = await self._find_similar_models_memory(request_embedding, service_type)
+            # Find similar models using Supabase
+            candidates = await self._find_similar_models_supabase(request_embedding, service_type)
             
             if not candidates:
                 return self._get_default_selection(service_type, "No suitable models found")
@@ -338,127 +174,60 @@ class IntelligentModelSelector:
         request_embedding: List[float], 
         service_type: str
     ) -> List[Dict[str, Any]]:
-        """Find similar models using Supabase RPC function"""
+        """Find similar models using Supabase and embedding service similarity"""
         try:
-            # Use the RPC function we created in SQL
-            result = self.supabase_client.rpc(
-                'search_similar_models',
-                {
-                    'query_embedding': request_embedding,
-                    'similarity_threshold': 0.3,  # Minimum similarity threshold
-                    'match_count': 10,
-                    'filter_model_type': service_type
-                }
-            ).execute()
-            
-            candidates = []
-            for row in result.data:
-                candidates.append({
-                    "model_id": row["model_id"],
-                    "provider": row["provider"],
-                    "model_type": row["model_type"],
-                    "similarity": float(row["similarity"]),
-                    "description": row.get("description", "")
-                })
+            # Get all model embeddings from database
+            embeddings_result = self.supabase_client.table('model_embeddings').select('*').execute()
+            model_embeddings = embeddings_result.data
             
-            return candidates
+            if not model_embeddings:
+                logger.warning("No model embeddings found in database")
+                return []
             
-        except Exception as e:
-            logger.error(f"Supabase similarity search failed: {e}")
-            return []
-    
-    async def _find_similar_models_db(
-        self, 
-        request_embedding: List[float], 
-        service_type: str
-    ) -> List[Dict[str, Any]]:
-        """Find similar models using database"""
-        try:
-            async with self.db_pool.acquire() as conn:
-                # Query for similar models
-                rows = await conn.fetch("""
-                    SELECT 
-                        model_id, 
-                        provider, 
-                        model_type,
-                        description,
-                        metadata,
-                        1 - (embedding <=> $1) as similarity
-                    FROM model_embeddings
-                    WHERE model_type = $2 OR model_type = 'omni'
-                    ORDER BY embedding <=> $1
-                    LIMIT 10
-                """, request_embedding, service_type)
-                
-                candidates = []
-                for row in rows:
-                    candidates.append({
-                        "model_id": row["model_id"],
-                        "provider": row["provider"],
-                        "model_type": row["model_type"],
-                        "similarity": float(row["similarity"]),
-                        "description": row["description"]
-                    })
-                
-                return candidates
-                
-        except Exception as e:
-            logger.error(f"Database similarity search failed: {e}")
-            return []
-    
-    async def _find_similar_models_memory(
-        self, 
-        request_embedding: List[float], 
-        service_type: str
-    ) -> List[Dict[str, Any]]:
-        """Find similar models using in-memory search"""
-        try:
+            # Calculate similarity for each model
             candidates = []
-            
-            for model_id, embedding in self.model_embeddings.items():
-                metadata = self.models_metadata.get(model_id, {})
-                model_type = metadata.get("model_type")
+            for model_embed in model_embeddings:
+                model_id = model_embed['model_id']
+                model_embedding = model_embed['embedding']
+                
+                # Get model metadata
+                model_metadata = self.models_metadata.get(model_id, {})
+                model_type = model_metadata.get('model_type')
                 
                 # Filter by service type (including omni models)
-                if model_type not in [service_type, "omni"]:
+                if model_type not in [service_type, 'omni']:
                     continue
                 
-                # Calculate cosine similarity
-                similarity = self._cosine_similarity(request_embedding, embedding)
-                
-                candidates.append({
-                    "model_id": model_id,
-                    "provider": metadata.get("provider"),
-                    "model_type": model_type,
-                    "similarity": similarity,
-                    "description": metadata.get("metadata", {}).get("description", "")
-                })
+                # Calculate similarity using embedding service
+                try:
+                    similarity_result = await self.embedding_service.invoke(
+                        input_data="",  # Not used for similarity task
+                        task="similarity",
+                        embedding1=request_embedding,
+                        embedding2=model_embedding
+                    )
+                    similarity = similarity_result['similarity']
+                    
+                    candidates.append({
+                        "model_id": model_id,
+                        "provider": model_embed['provider'],
+                        "model_type": model_type,
+                        "similarity": similarity,
+                        "description": model_embed.get('description', '')
+                    })
+                    
+                except Exception as e:
+                    logger.warning(f"Failed to calculate similarity for {model_id}: {e}")
+                    continue
             
             # Sort by similarity score
             candidates.sort(key=lambda x: x["similarity"], reverse=True)
-            return candidates[:10]
+            return candidates[:10]  # Return top 10
             
         except Exception as e:
-            logger.error(f"Memory similarity search failed: {e}")
+            logger.error(f"Supabase similarity search failed: {e}")
             return []
     
-    def _cosine_similarity(self, vec1: List[float], vec2: List[float]) -> float:
-        """Calculate cosine similarity between two vectors"""
-        try:
-            import math
-            
-            dot_product = sum(a * b for a, b in zip(vec1, vec2))
-            norm1 = math.sqrt(sum(a * a for a in vec1))
-            norm2 = math.sqrt(sum(b * b for b in vec2))
-            
-            if norm1 * norm2 == 0:
-                return 0.0
-                
-            return dot_product / (norm1 * norm2)
-            
-        except Exception:
-            return 0.0
-    
     def _get_default_selection(self, service_type: str, reason: str) -> Dict[str, Any]:
         """Get default model selection"""
         default = self.default_models.get(service_type, self.default_models["vision"])
@@ -474,50 +243,15 @@ class IntelligentModelSelector:
     async def get_available_models(self, service_type: Optional[str] = None) -> List[Dict[str, Any]]:
         """Get list of available models"""
         try:
-            if self.supabase_client:
-                # Query Supabase
-                query = self.supabase_client.table("model_embedding").select("model_id, provider, model_type, description, metadata")
-                
-                if service_type:
-                    query = query.or_(f"model_type.eq.{service_type},model_type.eq.omni")
-                
-                result = query.order("model_id").execute()
-                return result.data
-                
-            elif self.db_pool:
-                async with self.db_pool.acquire() as conn:
-                    if service_type:
-                        rows = await conn.fetch("""
-                            SELECT model_id, provider, model_type, description, metadata
-                            FROM model_embeddings 
-                            WHERE model_type = $1 OR model_type = 'omni'
-                            ORDER BY model_id
-                        """, service_type)
-                    else:
-                        rows = await conn.fetch("""
-                            SELECT model_id, provider, model_type, description, metadata
-                            FROM model_embeddings 
-                            ORDER BY model_type, model_id
-                        """)
-                    
-                    return [dict(row) for row in rows]
+            if service_type:
+                # Filter by service type
+                query = self.supabase_client.table('models').select('*').or_(f'model_type.eq.{service_type},model_type.eq.omni')
             else:
-                # In-memory fallback
-                models = []
-                for model_id, metadata in self.models_metadata.items():
-                    model_type = metadata.get("model_type")
-                    if service_type and model_type not in [service_type, "omni"]:
-                        continue
-                    
-                    models.append({
-                        "model_id": model_id,
-                        "provider": metadata.get("provider"),
-                        "model_type": model_type,
-                        "description": metadata.get("metadata", {}).get("description", ""),
-                        "metadata": metadata.get("metadata", {})
-                    })
-                
-                return models
+                # Get all models
+                query = self.supabase_client.table('models').select('*')
+            
+            result = query.order('model_id').execute()
+            return result.data
                 
         except Exception as e:
             logger.error(f"Failed to get available models: {e}")
@@ -525,12 +259,9 @@ class IntelligentModelSelector:
     
     async def close(self):
         """Clean up resources"""
-        if self.db_pool:
-            await self.db_pool.close()
-            logger.info("Database connection closed")
-        if self.supabase_client:
-            # Supabase client doesn't need explicit closing
-            logger.info("Supabase client cleaned up")
+        if self.embedding_service:
+            await self.embedding_service.close()
+            logger.info("Embedding service closed")
 
 
 # Singleton instance

isa_model/core/storage/hf_storage.py

@@ -21,7 +21,7 @@ try:
 except ImportError:
     HF_HUB_AVAILABLE = False
 
-from ..model_storage import ModelStorage
+from ..models.model_storage import ModelStorage
 
 logger = logging.getLogger(__name__)
 

isa_model/core/types.py

@@ -33,6 +33,10 @@ class ModelCapability(str, Enum):
     IMAGE_GENERATION = "image_generation"
     IMAGE_ANALYSIS = "image_analysis"
     AUDIO_TRANSCRIPTION = "audio_transcription"
+    AUDIO_REALTIME = "audio_realtime"
+    SPEECH_TO_TEXT = "speech_to_text"
+    TEXT_TO_SPEECH = "text_to_speech"
+    CONVERSATION = "conversation"
     IMAGE_UNDERSTANDING = "image_understanding"
     UI_DETECTION = "ui_detection"
     OCR = "ocr"
@@ -56,6 +60,9 @@ class ServiceType(str, Enum):
     EMBEDDING = "embedding"
     VISION = "vision"
     AUDIO = "audio"
+    AUDIO_STT = "audio_stt"
+    AUDIO_TTS = "audio_tts"
+    AUDIO_REALTIME = "audio_realtime"
     IMAGE_GEN = "image_gen"
 
 class ServiceStatus(str, Enum):