signalwire-agents 0.1.54__tar.gz → 1.0.0__tar.gz

{signalwire_agents-0.1.54/signalwire_agents.egg-info → signalwire_agents-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 0.1.54
+Version: 1.0.0
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT

{signalwire_agents-0.1.54 → signalwire_agents-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "signalwire_agents"
-version = "0.1.54"
+version = "1.0.0"
 description = "SignalWire AI Agents SDK"
 authors = [
     {name = "SignalWire Team", email = "info@signalwire.com"}

{signalwire_agents-0.1.54 → signalwire_agents-1.0.0}/signalwire_agents/__init__.py

@@ -18,7 +18,7 @@ A package for building AI agents using SignalWire's AI and SWML capabilities.
 from .core.logging_config import configure_logging
 configure_logging()
 
-__version__ = "0.1.54"
+__version__ = "1.0.0"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase

{signalwire_agents-0.1.54 → signalwire_agents-1.0.0}/signalwire_agents/cli/build_search.py

@@ -793,7 +793,7 @@ def search_command():
                         query_vector=enhanced.get('vector'),
                         enhanced_text=enhanced.get('enhanced_text', query),
                         count=args.count,
-                        distance_threshold=args.distance_threshold,
+                        similarity_threshold=args.similarity_threshold,
                         tags=tags,
                         keyword_weight=args.keyword_weight,
                         original_query=query
@@ -871,7 +871,7 @@ def search_command():
             query_vector=enhanced.get('vector'),
             enhanced_text=enhanced.get('enhanced_text', args.query),
             count=args.count,
-            distance_threshold=args.distance_threshold,
+            similarity_threshold=args.similarity_threshold,
             tags=tags,
             keyword_weight=args.keyword_weight,
             original_query=args.query  # Pass original for exact match boosting
@@ -1118,7 +1118,7 @@ def remote_command():
         'query': args.query,
         'index_name': args.index_name,
         'count': args.count,
-        'distance_threshold': args.distance_threshold
+        'similarity_threshold': args.similarity_threshold
     }
     
     if args.tags:

{signalwire_agents-0.1.54 → signalwire_agents-1.0.0}/signalwire_agents/search/pgvector_backend.py

@@ -423,7 +423,7 @@ class PgVectorSearchBackend:
             return {}
     
     def search(self, query_vector: List[float], enhanced_text: str,
-              count: int = 5, distance_threshold: float = 0.0,
+              count: int = 5, similarity_threshold: float = 0.0,
               tags: Optional[List[str]] = None,
               keyword_weight: Optional[float] = None) -> List[Dict[str, Any]]:
         """
@@ -433,7 +433,7 @@ class PgVectorSearchBackend:
             query_vector: Embedding vector for the query
             enhanced_text: Processed query text for keyword search
             count: Number of results to return
-            distance_threshold: Minimum similarity score
+            similarity_threshold: Minimum similarity score
             tags: Filter by tags
             keyword_weight: Manual keyword weight (0.0-1.0). If None, uses default weighting
             
@@ -447,33 +447,39 @@ class PgVectorSearchBackend:
         
         # Vector search
         vector_results = self._vector_search(query_vector, count * 2, tags)
-        
+
         # Keyword search
         keyword_results = self._keyword_search(enhanced_text, count * 2, tags)
-        
+
         # Metadata search
         metadata_results = self._metadata_search(query_terms, count * 2, tags)
-        
+
+
         # Merge all results
         merged_results = self._merge_all_results(vector_results, keyword_results, metadata_results, keyword_weight)
-        
+
+
         # Filter by distance threshold
         filtered_results = [
-            r for r in merged_results 
-            if r['score'] >= distance_threshold
+            r for r in merged_results
+            if r['score'] >= similarity_threshold
         ]
+
         
         # Ensure 'score' field exists for CLI compatibility
         for r in filtered_results:
             if 'score' not in r:
                 r['score'] = r.get('final_score', 0.0)
-        
+
         return filtered_results[:count]
     
     def _vector_search(self, query_vector: List[float], count: int,
                       tags: Optional[List[str]] = None) -> List[Dict[str, Any]]:
         """Perform vector similarity search"""
         with self.conn.cursor() as cursor:
+            # Set ef_search for HNSW index to ensure we get enough results
+            # ef_search must be at least as large as the LIMIT
+            cursor.execute(f"SET LOCAL hnsw.ef_search = {max(count, 40)}")
             # Build query
             query = f"""
                 SELECT id, content, filename, section, tags, metadata,
@@ -491,9 +497,9 @@ class PgVectorSearchBackend:
             
             query += " ORDER BY embedding <=> %s::vector LIMIT %s"
             params.extend([query_vector, count])
-            
+
             cursor.execute(query, params)
-            
+
             results = []
             for row in cursor.fetchall():
                 chunk_id, content, filename, section, tags_json, metadata_json, similarity = row

{signalwire_agents-0.1.54 → signalwire_agents-1.0.0}/signalwire_agents/search/query_processor.py

@@ -77,62 +77,59 @@ def load_spacy_model(language: str):
             _spacy_warning_shown = True
         return None
 
-# Global model cache
-_cached_model = None
+# Model cache - stores multiple models by name
+_model_cache = {}  # model_name -> SentenceTransformer instance
 _model_lock = None
 
 def set_global_model(model):
-    """Set the global cached model instance"""
-    global _cached_model
-    _cached_model = model
-    logger.info("Global model set for query processor")
+    """Legacy function - adds model to cache instead of setting globally"""
+    if model and hasattr(model, 'model_name'):
+        _model_cache[model.model_name] = model
+        logger.info(f"Model added to cache: {model.model_name}")
 
 def _get_cached_model(model_name: str = None):
     """Get or create cached sentence transformer model
-    
+
     Args:
         model_name: Optional model name. If not provided, uses default.
     """
-    global _cached_model, _model_lock
-    
+    global _model_cache, _model_lock
+
     # Default model
     if model_name is None:
         model_name = 'sentence-transformers/all-mpnet-base-v2'
-    
+
     # Initialize lock if needed
     if _model_lock is None:
         import threading
         _model_lock = threading.Lock()
-    
-    # Return cached model if available and same model
-    if _cached_model is not None:
-        # Check if it's the same model (simple check - assumes model has a name attribute)
-        try:
-            if hasattr(_cached_model, 'model_name') and _cached_model.model_name == model_name:
-                return _cached_model
-        except:
-            pass
-    
+
+    # Check if model is already in cache
+    if model_name in _model_cache:
+        return _model_cache[model_name]
+
     # Load model with lock to prevent race conditions
     with _model_lock:
         # Double check in case another thread loaded it
-        if _cached_model is not None:
-            try:
-                if hasattr(_cached_model, 'model_name') and _cached_model.model_name == model_name:
-                    return _cached_model
-            except:
-                pass
-            
+        if model_name in _model_cache:
+            return _model_cache[model_name]
+
         try:
             from sentence_transformers import SentenceTransformer
             logger.info(f"Loading sentence transformer model: {model_name}")
-            _cached_model = SentenceTransformer(model_name)
-            _cached_model.model_name = model_name  # Store for later comparison
-            logger.info("Model loaded and cached successfully")
-            return _cached_model
+            model = SentenceTransformer(model_name)
+            # Store the model name for identification
+            model.model_name = model_name
+            # Add to cache
+            _model_cache[model_name] = model
+            logger.info(f"Successfully loaded and cached model: {model_name}")
+            return model
         except ImportError:
             logger.error("sentence-transformers not available. Cannot load model.")
             return None
+        except Exception as e:
+            logger.error(f"Failed to load model {model_name}: {e}")
+            return None
 
 def vectorize_query(query: str, model=None, model_name: str = None):
     """

{signalwire_agents-0.1.54 → signalwire_agents-1.0.0}/signalwire_agents/search/search_engine.py

@@ -73,7 +73,7 @@ class SearchEngine:
             return {}
     
     def search(self, query_vector: List[float], enhanced_text: str, 
-              count: int = 3, distance_threshold: float = 0.0,
+              count: int = 3, similarity_threshold: float = 0.0,
               tags: Optional[List[str]] = None, 
               keyword_weight: Optional[float] = None,
               original_query: Optional[str] = None) -> List[Dict[str, Any]]:
@@ -89,7 +89,7 @@ class SearchEngine:
             query_vector: Embedding vector for the query
             enhanced_text: Processed query text for keyword search
             count: Number of results to return
-            distance_threshold: Minimum similarity score
+            similarity_threshold: Minimum similarity score
             tags: Filter by tags
             keyword_weight: Optional manual weight for keyword vs vector
             original_query: Original query for exact matching
@@ -100,7 +100,7 @@ class SearchEngine:
         
         # Use pgvector backend if available
         if self.backend == 'pgvector':
-            return self._backend.search(query_vector, enhanced_text, count, distance_threshold, tags, keyword_weight)
+            return self._backend.search(query_vector, enhanced_text, count, similarity_threshold, tags, keyword_weight)
         
         # Check for numpy/sklearn availability
         if not np or not cosine_similarity:
@@ -161,7 +161,7 @@ class SearchEngine:
         final_results = []
         for chunk_id, candidate in candidates.items():
             # Calculate final score combining all signals
-            score = self._calculate_combined_score(candidate, distance_threshold)
+            score = self._calculate_combined_score(candidate, similarity_threshold)
             candidate['final_score'] = score
             final_results.append(candidate)
         
@@ -174,9 +174,9 @@ class SearchEngine:
                            if any(tag in r['metadata'].get('tags', []) for tag in tags)]
         
         # Apply distance threshold as final filter (soft threshold already applied in scoring)
-        if distance_threshold > 0:
+        if similarity_threshold > 0:
             final_results = [r for r in final_results 
-                           if r.get('vector_distance', 0) <= distance_threshold * 1.5 
+                           if r.get('vector_distance', 0) <= similarity_threshold * 1.5 
                            or 'vector' not in r.get('sources', {})]
         
         # Boost exact matches if we have the original query
@@ -987,7 +987,7 @@ class SearchEngine:
             return []
     
     def _add_vector_scores_to_candidates(self, candidates: Dict[str, Dict], query_vector: NDArray, 
-                                       distance_threshold: float):
+                                       similarity_threshold: float):
         """Add vector similarity scores to existing candidates"""
         if not candidates or not np:
             return
@@ -1034,7 +1034,7 @@ class SearchEngine:
         except Exception as e:
             logger.error(f"Error in vector re-ranking: {e}")
     
-    def _calculate_combined_score(self, candidate: Dict, distance_threshold: float) -> float:
+    def _calculate_combined_score(self, candidate: Dict, similarity_threshold: float) -> float:
         """Calculate final score with hybrid vector + metadata weighting
 
         Hybrid approach:

{signalwire_agents-0.1.54 → signalwire_agents-1.0.0}/signalwire_agents/search/search_service.py

@@ -50,7 +50,7 @@ if BaseModel:
         query: str
         index_name: str = "default"
         count: int = 3
-        distance: float = 0.0
+        similarity_threshold: float = 0.0
         tags: Optional[List[str]] = None
         language: Optional[str] = None
 
@@ -65,13 +65,13 @@ if BaseModel:
 else:
     # Fallback classes when FastAPI is not available
     class SearchRequest:
-        def __init__(self, query: str, index_name: str = "default", count: int = 3, 
-                     distance: float = 0.0, tags: Optional[List[str]] = None, 
+        def __init__(self, query: str, index_name: str = "default", count: int = 3,
+                     similarity_threshold: float = 0.0, tags: Optional[List[str]] = None,
                      language: Optional[str] = None):
             self.query = query
             self.index_name = index_name
             self.count = count
-            self.distance = distance
+            self.similarity_threshold = similarity_threshold
             self.tags = tags
             self.language = language
 
@@ -298,16 +298,41 @@ class SearchService:
     def _load_resources(self):
         """Load embedding model and search indexes"""
         if self.backend == 'pgvector':
-            # For pgvector, we don't need to load a model locally
-            # The embeddings are already stored in the database
-            # Load search engines for each collection
+            # For pgvector, we need to load models for query embeddings
+            # Different collections might use different models
+            self.models = {}  # model_name -> SentenceTransformer instance
+            self.collection_models = {}  # collection_name -> model_name
+
+            # Load search engines for each collection and their models
             for collection_name in self.indexes.keys():
                 try:
-                    self.search_engines[collection_name] = SearchEngine(
+                    search_engine = SearchEngine(
                         backend='pgvector',
                         connection_string=self.connection_string,
                         collection_name=collection_name
                     )
+                    self.search_engines[collection_name] = search_engine
+
+                    # Get the model name from the collection config
+                    model_name = search_engine.config.get('model_name')
+                    if model_name:
+                        self.collection_models[collection_name] = model_name
+
+                        # Load the model if we haven't already
+                        if model_name not in self.models:
+                            logger.info(f"Loading model {model_name} for collection {collection_name}")
+                            try:
+                                model = SentenceTransformer(model_name)
+                                model.model_name = model_name  # Store for cache comparison
+                                self.models[model_name] = model
+                            except Exception as e:
+                                logger.error(f"Failed to load model {model_name}: {e}")
+                                raise
+                        else:
+                            logger.info(f"Using cached model {model_name} for collection {collection_name}")
+                    else:
+                        logger.warning(f"No model_name in config for collection {collection_name}")
+
                     logger.info(f"Loaded pgvector collection: {collection_name}")
                 except Exception as e:
                     logger.error(f"Error loading pgvector collection {collection_name}: {e}")
@@ -372,13 +397,21 @@ class SearchService:
             return self._query_cache[cache_key]
         
         search_engine = self.search_engines[request.index_name]
-        
+
+        # For pgvector, set the correct model globally before query processing
+        if self.backend == 'pgvector' and hasattr(self, 'collection_models'):
+            collection_model_name = self.collection_models.get(request.index_name)
+            if collection_model_name and collection_model_name in self.models:
+                # Set this model globally so query processor uses it
+                set_global_model(self.models[collection_model_name])
+                logger.debug(f"Set global model to {collection_model_name} for collection {request.index_name}")
+
         # Get model name from the search engine config
         model_name = None
         if hasattr(search_engine, 'config') and search_engine.config:
             # pgvector uses 'model_name', sqlite uses 'embedding_model'
             model_name = search_engine.config.get('model_name') or search_engine.config.get('embedding_model')
-        
+
         # Enhance query
         try:
             enhanced = preprocess_query(
@@ -401,7 +434,7 @@ class SearchService:
                 query_vector=enhanced.get('vector', []),
                 enhanced_text=enhanced['enhanced_text'],
                 count=request.count,
-                distance_threshold=request.distance,
+                similarity_threshold=request.similarity_threshold,
                 tags=request.tags
             )
         except Exception as e:

{signalwire_agents-0.1.54 → signalwire_agents-1.0.0}/signalwire_agents/skills/native_vector_search/skill.py

@@ -74,9 +74,9 @@ class NativeVectorSearchSkill(SkillBase):
                 "minimum": 1,
                 "maximum": 20
             },
-            "distance_threshold": {
+            "similarity_threshold": {
                 "type": "number",
-                "description": "Maximum distance threshold for results (0.0 = no limit)",
+                "description": "Minimum similarity score for results (0.0 = no limit, 1.0 = exact match)",
                 "default": 0.0,
                 "required": False,
                 "minimum": 0.0,
@@ -250,7 +250,7 @@ class NativeVectorSearchSkill(SkillBase):
         self.build_index = self.params.get('build_index', False)
         self.source_dir = self.params.get('source_dir')
         self.count = self.params.get('count', 5)
-        self.distance_threshold = self.params.get('distance_threshold', 0.0)
+        self.similarity_threshold = self.params.get('similarity_threshold', 0.0)
         self.tags = self.params.get('tags', [])
         self.no_results_message = self.params.get(
             'no_results_message', 
@@ -550,9 +550,12 @@ class NativeVectorSearchSkill(SkillBase):
         
         try:
             # Perform search (local or remote)
+            self.logger.info(f"DEBUG: use_remote={self.use_remote}, remote_base_url={self.remote_base_url}")
             if self.use_remote:
                 # For remote searches, let the server handle query preprocessing
+                self.logger.info(f"DEBUG: Calling _search_remote with query='{query}', count={count}")
                 results = self._search_remote(query, None, count)
+                self.logger.info(f"DEBUG: _search_remote returned {len(results)} results")
             else:
                 # For local searches, preprocess the query locally
                 from signalwire_agents.search.query_processor import preprocess_query
@@ -575,7 +578,7 @@ class NativeVectorSearchSkill(SkillBase):
                     query_vector=enhanced.get('vector', []),
                     enhanced_text=enhanced['enhanced_text'],
                     count=count,
-                    distance_threshold=self.distance_threshold,
+                    similarity_threshold=self.similarity_threshold,
                     tags=self.tags,
                     keyword_weight=self.keyword_weight,
                     original_query=query  # Pass original for exact match boosting
@@ -721,20 +724,23 @@ class NativeVectorSearchSkill(SkillBase):
                 "query": query,
                 "index_name": self.index_name,
                 "count": count,
-                "distance": self.distance_threshold,
-                "tags": self.tags,
-                "language": "en"
+                "similarity_threshold": self.similarity_threshold,
+                "tags": self.tags
             }
-            
+
+            url = f"{self.remote_base_url}/search"
+            self.logger.info(f"DEBUG: Sending POST to {url} with request: {search_request}")
+
             response = requests.post(
-                f"{self.remote_base_url}/search",
+                url,
                 json=search_request,
                 auth=self.remote_auth,
                 timeout=30
             )
-            
+
             if response.status_code == 200:
                 data = response.json()
+                self.logger.info(f"DEBUG: Got response with {len(data.get('results', []))} results")
                 # Convert remote response format to local format
                 results = []
                 for result in data.get('results', []):