isa-model 0.3.91__py3-none-any.whl → 0.4.3__py3-none-any.whl

isa_model/inference/services/embedding/isa_embed_service.py

@@ -0,0 +1,305 @@
+"""
+ISA Embedding Service
+
+ISA reranking service using deployed Jina Reranker v2 via Modal
+"""
+
+import logging
+from typing import Dict, Any, List, Optional
+
+try:
+    import modal
+    MODAL_AVAILABLE = True
+except ImportError:
+    MODAL_AVAILABLE = False
+    modal = None
+
+from isa_model.inference.services.embedding.base_embed_service import BaseEmbedService
+
+logger = logging.getLogger(__name__)
+
+class ISAEmbedService(BaseEmbedService):
+    """
+    ISA Embedding Service - calls ISA deployed reranking models
+    
+    Supported features:
+    - Document reranking (Jina Reranker v2 via Modal)
+    - Future: embedding generation
+    - Future: semantic similarity computation
+    """
+    
+    def __init__(self, 
+                 rerank_modal_app_name: str = "isa-embed-rerank",
+                 timeout: int = 30):
+        """
+        Initialize ISA Embedding service
+        
+        Args:
+            rerank_modal_app_name: Modal reranking app name
+            timeout: Request timeout in seconds
+        """
+        # For now, skip BaseService initialization to avoid config validation
+        # TODO: Properly configure ISA provider in config system
+        self.provider_name = "isa"
+        self.model_name = "isa-jina-reranker-v2-service"
+        self.rerank_modal_app_name = rerank_modal_app_name
+        self.timeout = timeout
+        
+        # Initialize Modal client
+        if MODAL_AVAILABLE:
+            try:
+                # Get deployed Modal application
+                self.modal_app = modal.App.lookup(rerank_modal_app_name)
+                logger.info(f"Connected to Modal rerank app: {rerank_modal_app_name}")
+                
+                self.modal_service = True  # Mark service as available
+                logger.info("Modal rerank app connection established")
+                    
+            except Exception as e:
+                logger.warning(f"Failed to connect to Modal rerank app: {e}")
+                self.modal_app = None
+                self.modal_service = None
+        else:
+            logger.warning("Modal SDK not available")
+            self.modal_app = None
+            self.modal_service = None
+        
+        # Service statistics
+        self.request_count = 0
+        self.total_cost = 0.0
+        
+    async def rerank_documents(
+        self, 
+        query: str, 
+        documents: List[str], 
+        top_k: Optional[int] = None,
+        return_documents: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Rerank documents using Jina Reranker v2
+        
+        Args:
+            query: Query string
+            documents: List of documents to rerank
+            top_k: Return top k results (None = all)
+            return_documents: Whether to include document content in results
+            
+        Returns:
+            Reranking results
+        """
+        try:
+            if not self.modal_app or not self.modal_service:
+                return {
+                    'success': False,
+                    'provider': 'ISA',
+                    'service': 'isa-embed-rerank',
+                    'error': 'Modal rerank app or service not available'
+                }
+            
+            # Call reranking service directly via Modal SDK
+            result = await self._call_rerank_service(query, documents, top_k, return_documents)
+            
+            if result and result.get('success', False):
+                self.request_count += 1
+                
+                # Record cost
+                if 'billing' in result:
+                    cost = result['billing'].get('estimated_cost_usd', 0)
+                    self.total_cost += cost
+                
+                # Format response to match expected structure
+                formatted_result = {
+                    'success': True,
+                    'provider': 'ISA',
+                    'service': 'isa-embed-rerank',
+                    'result': {
+                        'results': result.get('results', []),
+                        'processing_time': result.get('processing_time'),
+                        'billing': result.get('billing', {}),
+                        'query': result.get('query'),
+                        'num_documents': result.get('num_documents'),
+                        'returned_count': result.get('returned_count')
+                    },
+                    'metadata': {
+                        'model_used': result.get('model'),
+                        'provider': result.get('provider', 'ISA'),
+                        'billing': result.get('billing', {})
+                    }
+                }
+                return formatted_result
+            else:
+                return {
+                    'success': False,
+                    'provider': 'ISA',
+                    'service': 'isa-embed-rerank',
+                    'error': f'Rerank service returned error: {result.get("error", "Unknown error") if result else "No response"}',
+                    'details': result
+                }
+                
+        except Exception as e:
+            logger.error(f"ISA document reranking failed: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                'success': False,
+                'provider': 'ISA',
+                'service': 'isa-embed-rerank',
+                'error': str(e)
+            }
+    
+    async def _call_rerank_service(
+        self, 
+        query: str, 
+        documents: List[str], 
+        top_k: Optional[int], 
+        return_documents: bool
+    ) -> Dict[str, Any]:
+        """
+        Call reranking service via Modal SDK
+        """
+        try:
+            import modal
+            
+            logger.info("Calling Jina Reranker v2 service via Modal SDK...")
+            
+            # Correct Modal SDK usage: call deployed class method
+            ISAEmbedRerankService = modal.Cls.from_name(
+                app_name=self.rerank_modal_app_name,
+                name="ISAEmbedRerankService"
+            )
+            
+            # Create instance and call method
+            instance = ISAEmbedRerankService()
+            result = instance.rerank_documents.remote(
+                query=query,
+                documents=documents,
+                top_k=top_k,
+                return_documents=return_documents
+            )
+            
+            logger.info("Modal rerank SDK call successful")
+            return result
+                        
+        except Exception as e:
+            logger.error(f"Modal rerank SDK call failed: {e}")
+            return {
+                'success': False,
+                'error': f'Modal rerank SDK error: {str(e)}'
+            }
+    
+    # ==================== Embedding methods (future implementation) ====================
+    
+    async def create_text_embedding(self, text: str) -> List[float]:
+        """Create single text embedding - not yet implemented"""
+        raise NotImplementedError("Text embedding not yet implemented in ISA service")
+    
+    async def create_text_embeddings(self, texts: List[str]) -> List[List[float]]:
+        """Create multiple text embeddings - not yet implemented"""
+        raise NotImplementedError("Text embeddings not yet implemented in ISA service")
+    
+    async def create_chunks(self, text: str, metadata: Optional[Dict] = None) -> List[Dict]:
+        """Create text chunks with embeddings - not yet implemented"""
+        raise NotImplementedError("Text chunking not yet implemented in ISA service")
+    
+    async def compute_similarity(self, embedding1: List[float], embedding2: List[float]) -> float:
+        """Compute embedding similarity - not yet implemented"""
+        raise NotImplementedError("Similarity computation not yet implemented in ISA service")
+    
+    async def find_similar_texts(
+        self, 
+        query_embedding: List[float], 
+        candidate_embeddings: List[List[float]], 
+        top_k: int = 5
+    ) -> List[Dict[str, Any]]:
+        """Find similar texts - not yet implemented"""
+        raise NotImplementedError("Similar text search not yet implemented in ISA service")
+    
+    def get_embedding_dimension(self) -> int:
+        """Get embedding dimension - not applicable for rerank-only service"""
+        raise NotImplementedError("Embedding dimension not available for rerank-only service")
+    
+    def get_max_input_length(self) -> int:
+        """Get maximum input length"""
+        return 1024  # Jina Reranker v2 max length
+    
+    # ==================== Service management methods ====================
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Check ISA reranking service health"""
+        try:
+            # Simple health check: call reranking service
+            test_result = await self.rerank_documents(
+                query="test",
+                documents=["test document"],
+                top_k=1,
+                return_documents=False
+            )
+            
+            return {
+                'success': True,
+                'provider': 'ISA',
+                'service': 'isa-embed-rerank',
+                'status': 'healthy' if test_result.get('success') else 'error',
+                'rerank_service': test_result.get('success', False),
+                'usage_stats': {
+                    'total_requests': self.request_count,
+                    'total_cost_usd': round(self.total_cost, 6)
+                }
+            }
+                
+        except Exception as e:
+            return {
+                'success': False,
+                'provider': 'ISA',
+                'service': 'isa-embed-rerank',
+                'status': 'error',
+                'error': str(e)
+            }
+    
+    async def get_usage_stats(self) -> Dict[str, Any]:
+        """Get usage statistics"""
+        try:
+            modal_stats = {}
+            
+            # Try to get Modal service statistics
+            if self.modal_app:
+                try:
+                    # Can extend to get Modal service stats
+                    pass
+                except Exception as e:
+                    logger.warning(f"Failed to get Modal stats: {e}")
+            
+            return {
+                'provider': 'ISA',
+                'service': 'isa-embed-rerank',
+                'client_stats': {
+                    'total_requests': self.request_count,
+                    'total_cost_usd': round(self.total_cost, 6)
+                },
+                'modal_stats': modal_stats,
+                'combined_cost': round(self.total_cost, 6)
+            }
+            
+        except Exception as e:
+            return {
+                'provider': 'ISA', 
+                'service': 'isa-embed-rerank',
+                'error': str(e)
+            }
+    
+    def get_supported_tasks(self) -> List[str]:
+        """Get supported task list"""
+        return [
+            'rerank',           # Document reranking
+            'rerank_documents', # Document reranking (alias)
+            'document_ranking'  # Document ranking (alias)
+        ]
+    
+    def get_supported_formats(self) -> List[str]:
+        """Get supported formats"""
+        return ['text']  # Text only
+    
+    async def close(self):
+        """Cleanup resources"""
+        # Modal client doesn't need explicit closure
+        pass

isa_model/inference/services/embedding/ollama_embed_service.py

@@ -4,6 +4,7 @@ import asyncio
 from typing import List, Dict, Any, Optional
 
 from isa_model.inference.services.embedding.base_embed_service import BaseEmbedService
+from isa_model.core.config.config_manager import ConfigManager
 
 logger = logging.getLogger(__name__)
 
@@ -21,9 +22,20 @@ class OllamaEmbedService(BaseEmbedService):
         
         # Initialize HTTP client with provider configuration
         try:
-            host = provider_config.get("host", "localhost")
-            port = provider_config.get("port", 11434)
-            base_url = f"http://{host}:{port}"
+            config_manager = ConfigManager()
+            # Use Consul discovery with fallback
+            default_base_url = config_manager.get_ollama_url()
+            
+            if "base_url" in provider_config:
+                base_url = provider_config["base_url"]
+            else:
+                host = provider_config.get("host", "localhost")
+                port = provider_config.get("port", 11434)
+                base_url = provider_config.get("base_url", f"http://{host}:{port}")
+                
+            # Use config manager default (Consul discovery) if still not set
+            if base_url == f"http://localhost:11434":
+                base_url = default_base_url
             
             self.client = httpx.AsyncClient(base_url=base_url, timeout=30.0)
             

isa_model/inference/services/embedding/openai_embed_service.py

@@ -129,11 +129,9 @@ class OpenAIEmbedService(BaseEmbedService):
             logger.error(f"Error creating text embeddings: {e}")
             raise
     
-    async def create_chunks(self, text: str, metadata: Optional[Dict] = None) -> List[Dict]:
+    async def create_chunks(self, text: str, metadata: Optional[Dict] = None, chunk_size: int = 400, overlap: int = 50, **kwargs) -> List[Dict]:
         """Create text chunks with embeddings"""
-        # Chunk size optimized for OpenAI models (roughly 512 tokens)
-        chunk_size = 400  # words
-        overlap = 50      # word overlap between chunks
+        # Use provided chunk_size and overlap, or defaults optimized for OpenAI models
         
         words = text.split()
         if not words:

isa_model/inference/services/embedding/resilient_embed_service.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Resilient Embedding Service - Provides fallback mechanisms for embedding operations
+Automatically handles OpenAI API failures with local embedding alternatives
+"""
+
+import logging
+import random
+import numpy as np
+from typing import List, Dict, Any, Optional, Union
+from openai import APIConnectionError, APITimeoutError, RateLimitError, AuthenticationError
+
+from isa_model.inference.services.embedding.openai_embed_service import OpenAIEmbedService
+from isa_model.inference.services.embedding.base_embed_service import BaseEmbedService
+
+logger = logging.getLogger(__name__)
+
+class ResilientEmbedService(BaseEmbedService):
+    """
+    Resilient embedding service with automatic fallback mechanisms
+    
+    When OpenAI service fails, automatically falls back to:
+    1. Simple TF-IDF based embeddings
+    2. Random embeddings (for testing/demo purposes)
+    """
+    
+    def __init__(self, provider_name: str = "openai", model_name: str = "text-embedding-3-small", **kwargs):
+        super().__init__(provider_name, model_name, **kwargs)
+        
+        # Try to initialize OpenAI service
+        self.primary_service = None
+        self.fallback_mode = False
+        
+        try:
+            self.primary_service = OpenAIEmbedService(provider_name, model_name, **kwargs)
+            logger.info("✅ Primary OpenAI embedding service initialized")
+        except Exception as e:
+            logger.warning(f"Failed to initialize OpenAI service, starting in fallback mode: {e}")
+            self.fallback_mode = True
+        
+        # Initialize TF-IDF vectorizer for fallback
+        self._init_fallback_vectorizer()
+    
+    def _init_fallback_vectorizer(self):
+        """Initialize TF-IDF vectorizer for fallback embeddings"""
+        try:
+            from sklearn.feature_extraction.text import TfidfVectorizer
+            
+            # Use a simple TF-IDF vectorizer with limited features
+            self.tfidf_vectorizer = TfidfVectorizer(
+                max_features=1536,  # Match OpenAI dimensions
+                stop_words='english',
+                ngram_range=(1, 2),
+                lowercase=True,
+                strip_accents='unicode'
+            )
+            
+            # Pre-fit with some common words to ensure consistency
+            common_words = [
+                "hello world", "machine learning", "artificial intelligence",
+                "data science", "natural language processing", "computer vision",
+                "deep learning", "neural networks", "text analysis",
+                "information retrieval", "semantic search", "embeddings"
+            ]
+            self.tfidf_vectorizer.fit(common_words)
+            self.tfidf_available = True
+            logger.info("✅ TF-IDF fallback vectorizer initialized")
+            
+        except ImportError:
+            logger.warning("scikit-learn not available, using random embeddings as fallback")
+            self.tfidf_available = False
+    
+    def _generate_fallback_embedding(self, text: str, dimension: int = 1536) -> List[float]:
+        """Generate fallback embedding for a single text"""
+        
+        if self.tfidf_available and hasattr(self, 'tfidf_vectorizer'):
+            try:
+                # Use TF-IDF for more meaningful embeddings
+                tfidf_vector = self.tfidf_vectorizer.transform([text]).toarray()[0]
+                
+                # Pad or truncate to desired dimension
+                if len(tfidf_vector) < dimension:
+                    padding = [0.0] * (dimension - len(tfidf_vector))
+                    tfidf_vector = np.concatenate([tfidf_vector, padding])
+                elif len(tfidf_vector) > dimension:
+                    tfidf_vector = tfidf_vector[:dimension]
+                
+                # Normalize to unit vector
+                norm = np.linalg.norm(tfidf_vector)
+                if norm > 0:
+                    tfidf_vector = tfidf_vector / norm
+                
+                return tfidf_vector.tolist()
+                
+            except Exception as e:
+                logger.warning(f"TF-IDF fallback failed: {e}, using random embedding")
+        
+        # Random embedding as last resort (normalized)
+        random.seed(hash(text) % (2**32))  # Deterministic based on text
+        embedding = [random.gauss(0, 1) for _ in range(dimension)]
+        
+        # Normalize to unit vector
+        norm = np.sqrt(sum(x*x for x in embedding))
+        if norm > 0:
+            embedding = [x/norm for x in embedding]
+        
+        return embedding
+    
+    async def create_text_embedding(self, text: str) -> List[float]:
+        """Create embedding for single text with fallback"""
+        
+        # Try primary service first if available
+        if not self.fallback_mode and self.primary_service:
+            try:
+                result = await self.primary_service.create_text_embedding(text)
+                logger.debug("✅ Used primary OpenAI service")
+                return result
+                
+            except (APIConnectionError, APITimeoutError) as e:
+                logger.warning(f"OpenAI connection issue, switching to fallback: {e}")
+                self.fallback_mode = True
+            except RateLimitError as e:
+                logger.warning(f"OpenAI rate limit hit, using fallback: {e}")
+            except AuthenticationError as e:
+                logger.error(f"OpenAI authentication failed, switching to fallback: {e}")
+                self.fallback_mode = True
+            except Exception as e:
+                logger.warning(f"OpenAI service error, using fallback: {e}")
+        
+        # Use fallback embedding
+        logger.info(f"Using fallback embedding for text: {text[:50]}...")
+        return self._generate_fallback_embedding(text)
+    
+    async def create_text_embeddings(self, texts: List[str]) -> List[List[float]]:
+        """Create embeddings for multiple texts with fallback"""
+        if not texts:
+            return []
+        
+        # Try primary service first if available
+        if not self.fallback_mode and self.primary_service:
+            try:
+                result = await self.primary_service.create_text_embeddings(texts)
+                logger.debug(f"✅ Used primary OpenAI service for {len(texts)} texts")
+                return result
+                
+            except (APIConnectionError, APITimeoutError) as e:
+                logger.warning(f"OpenAI connection issue, switching to fallback: {e}")
+                self.fallback_mode = True
+            except RateLimitError as e:
+                logger.warning(f"OpenAI rate limit hit, using fallback: {e}")
+            except AuthenticationError as e:
+                logger.error(f"OpenAI authentication failed, switching to fallback: {e}")
+                self.fallback_mode = True
+            except Exception as e:
+                logger.warning(f"OpenAI service error, using fallback: {e}")
+        
+        # Use fallback embeddings
+        logger.info(f"Using fallback embeddings for {len(texts)} texts")
+        return [self._generate_fallback_embedding(text) for text in texts]
+    
+    async def create_chunks(self, text: str, metadata: Optional[Dict] = None, 
+                          chunk_size: int = 400, overlap: int = 50, **kwargs) -> List[Dict]:
+        """Create text chunks with embeddings (with fallback)"""
+        words = text.split()
+        if not words:
+            return []
+        
+        chunks = []
+        chunk_texts = []
+        
+        for i in range(0, len(words), chunk_size - overlap):
+            chunk_words = words[i:i + chunk_size]
+            chunk_text = " ".join(chunk_words)
+            chunk_texts.append(chunk_text)
+            
+            chunks.append({
+                "text": chunk_text,
+                "start_index": i,
+                "end_index": min(i + chunk_size, len(words)),
+                "metadata": metadata or {}
+            })
+        
+        # Get embeddings for all chunks
+        embeddings = await self.create_text_embeddings(chunk_texts)
+        
+        # Add embeddings to chunks
+        for chunk, embedding in zip(chunks, embeddings):
+            chunk["embedding"] = embedding
+            chunk["fallback_used"] = self.fallback_mode
+        
+        return chunks
+    
+    async def compute_similarity(self, embedding1: List[float], embedding2: List[float]) -> float:
+        """Compute cosine similarity between two embeddings"""
+        import math
+        
+        try:
+            dot_product = sum(a * b for a, b in zip(embedding1, embedding2))
+            norm1 = math.sqrt(sum(a * a for a in embedding1))
+            norm2 = math.sqrt(sum(b * b for b in embedding2))
+            
+            if norm1 * norm2 == 0:
+                return 0.0
+                
+            return dot_product / (norm1 * norm2)
+        except Exception as e:
+            logger.error(f"Error computing similarity: {e}")
+            return 0.0
+    
+    async def find_similar_texts(
+        self, 
+        query_embedding: List[float], 
+        candidate_embeddings: List[List[float]], 
+        top_k: int = 5
+    ) -> List[Dict[str, Any]]:
+        """Find most similar texts based on embeddings"""
+        try:
+            similarities = []
+            
+            for i, candidate in enumerate(candidate_embeddings):
+                similarity = await self.compute_similarity(query_embedding, candidate)
+                similarities.append({
+                    "index": i, 
+                    "similarity": similarity
+                })
+            
+            # Sort by similarity in descending order and return top_k
+            similarities.sort(key=lambda x: x["similarity"], reverse=True)
+            return similarities[:top_k]
+            
+        except Exception as e:
+            logger.error(f"Error finding similar texts: {e}")
+            return []
+    
+    def get_embedding_dimension(self) -> int:
+        """Get the dimension of embeddings produced by this service"""
+        return 1536  # Standard dimension for consistency
+    
+    def get_max_input_length(self) -> int:
+        """Get maximum input text length supported"""
+        return 8192
+    
+    def is_fallback_mode(self) -> bool:
+        """Check if service is running in fallback mode"""
+        return self.fallback_mode
+    
+    def get_service_status(self) -> Dict[str, Any]:
+        """Get current service status and capabilities"""
+        return {
+            "primary_service_available": not self.fallback_mode and self.primary_service is not None,
+            "fallback_mode": self.fallback_mode,
+            "tfidf_available": self.tfidf_available,
+            "provider": self.provider_name,
+            "model": self.model_name,
+            "embedding_dimension": self.get_embedding_dimension(),
+            "max_input_length": self.get_max_input_length()
+        }
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Health check with detailed status"""
+        status = self.get_service_status()
+        
+        # Test embedding generation
+        try:
+            test_embedding = await self.create_text_embedding("test")
+            status["embedding_test"] = {
+                "success": True,
+                "dimension": len(test_embedding),
+                "fallback_used": self.fallback_mode
+            }
+        except Exception as e:
+            status["embedding_test"] = {
+                "success": False,
+                "error": str(e)
+            }
+        
+        return status
+    
+    async def close(self):
+        """Cleanup resources"""
+        if self.primary_service:
+            await self.primary_service.close()
+        logger.info("ResilientEmbedService has been closed.")