signalwire-agents 0.1.37__py3-none-any.whl → 0.1.39__py3-none-any.whl

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.37"
+__version__ = "0.1.39"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase

signalwire_agents/cli/build_search.py

@@ -89,6 +89,24 @@ Examples:
   # Search via remote API
   sw-search remote http://localhost:8001 "how to create an agent" --index-name docs
   sw-search remote localhost:8001 "API reference" --index-name docs --count 3 --verbose
+
+  # PostgreSQL pgvector backend
+  sw-search ./docs \\
+    --backend pgvector \\
+    --connection-string "postgresql://user:pass@localhost/knowledge" \\
+    --output docs_collection
+
+  # Overwrite existing pgvector collection
+  sw-search ./docs \\
+    --backend pgvector \\
+    --connection-string "postgresql://user:pass@localhost/knowledge" \\
+    --output docs_collection \\
+    --overwrite
+
+  # Search in pgvector collection
+  sw-search search docs_collection "how to create an agent" \\
+    --backend pgvector \\
+    --connection-string "postgresql://user:pass@localhost/knowledge"
         """
     )
     
@@ -100,7 +118,25 @@ Examples:
     
     parser.add_argument(
         '--output', 
-        help='Output .swsearch file (default: sources.swsearch)'
+        help='Output .swsearch file (default: sources.swsearch) or collection name for pgvector'
+    )
+    
+    parser.add_argument(
+        '--backend',
+        choices=['sqlite', 'pgvector'],
+        default='sqlite',
+        help='Storage backend to use (default: sqlite)'
+    )
+    
+    parser.add_argument(
+        '--connection-string',
+        help='PostgreSQL connection string for pgvector backend'
+    )
+    
+    parser.add_argument(
+        '--overwrite',
+        action='store_true',
+        help='Overwrite existing collection (pgvector backend only)'
     )
     
     parser.add_argument(
@@ -213,18 +249,31 @@ Examples:
         print("Error: No valid sources found")
         sys.exit(1)
     
+    # Validate backend configuration
+    if args.backend == 'pgvector' and not args.connection_string:
+        print("Error: --connection-string is required for pgvector backend")
+        sys.exit(1)
+    
     # Default output filename
     if not args.output:
-        if len(valid_sources) == 1:
-            # Single source - use its name
-            source_name = valid_sources[0].stem if valid_sources[0].is_file() else valid_sources[0].name
-            args.output = f"{source_name}.swsearch"
+        if args.backend == 'sqlite':
+            if len(valid_sources) == 1:
+                # Single source - use its name
+                source_name = valid_sources[0].stem if valid_sources[0].is_file() else valid_sources[0].name
+                args.output = f"{source_name}.swsearch"
+            else:
+                # Multiple sources - use generic name
+                args.output = "sources.swsearch"
         else:
-            # Multiple sources - use generic name
-            args.output = "sources.swsearch"
+            # For pgvector, use a default collection name
+            if len(valid_sources) == 1:
+                source_name = valid_sources[0].stem if valid_sources[0].is_file() else valid_sources[0].name
+                args.output = source_name
+            else:
+                args.output = "documents"
     
-    # Ensure output has .swsearch extension
-    if not args.output.endswith('.swsearch'):
+    # Ensure output has .swsearch extension for sqlite
+    if args.backend == 'sqlite' and not args.output.endswith('.swsearch'):
         args.output += '.swsearch'
     
     # Parse lists
@@ -235,8 +284,13 @@ Examples:
     
     if args.verbose:
         print(f"Building search index:")
+        print(f"  Backend: {args.backend}")
         print(f"  Sources: {[str(s) for s in valid_sources]}")
-        print(f"  Output: {args.output}")
+        if args.backend == 'sqlite':
+            print(f"  Output file: {args.output}")
+        else:
+            print(f"  Collection name: {args.output}")
+            print(f"  Connection: {args.connection_string}")
         print(f"  File types (for directories): {file_types}")
         print(f"  Exclude patterns: {exclude_patterns}")
         print(f"  Languages: {languages}")
@@ -278,7 +332,9 @@ Examples:
             index_nlp_backend=args.index_nlp_backend,
             verbose=args.verbose,
             semantic_threshold=args.semantic_threshold,
-            topic_threshold=args.topic_threshold
+            topic_threshold=args.topic_threshold,
+            backend=args.backend,
+            connection_string=args.connection_string
         )
         
         # Build index with multiple sources
@@ -288,7 +344,8 @@ Examples:
             file_types=file_types,
             exclude_patterns=exclude_patterns,
             languages=languages,
-            tags=tags
+            tags=tags,
+            overwrite=args.overwrite if args.backend == 'pgvector' else False
         )
         
         # Validate if requested
@@ -307,7 +364,11 @@ Examples:
                 print(f"✗ Index validation failed: {validation['error']}")
                 sys.exit(1)
         
-        print(f"\n✓ Search index created successfully: {args.output}")
+        if args.backend == 'sqlite':
+            print(f"\n✓ Search index created successfully: {args.output}")
+        else:
+            print(f"\n✓ Search collection created successfully: {args.output}")
+            print(f"   Connection: {args.connection_string}")
         
     except KeyboardInterrupt:
         print("\n\nBuild interrupted by user")
@@ -359,9 +420,12 @@ def validate_command():
 
 def search_command():
     """Search within an existing search index"""
-    parser = argparse.ArgumentParser(description='Search within a .swsearch index file')
-    parser.add_argument('index_file', help='Path to .swsearch file to search')
+    parser = argparse.ArgumentParser(description='Search within a .swsearch index file or pgvector collection')
+    parser.add_argument('index_source', help='Path to .swsearch file or collection name for pgvector')
     parser.add_argument('query', help='Search query')
+    parser.add_argument('--backend', choices=['sqlite', 'pgvector'], default='sqlite',
+                       help='Storage backend (default: sqlite)')
+    parser.add_argument('--connection-string', help='PostgreSQL connection string for pgvector backend')
     parser.add_argument('--count', type=int, default=5, help='Number of results to return (default: 5)')
     parser.add_argument('--distance-threshold', type=float, default=0.0, help='Minimum similarity score (default: 0.0)')
     parser.add_argument('--tags', help='Comma-separated tags to filter by')
@@ -373,8 +437,13 @@ def search_command():
     
     args = parser.parse_args()
     
-    if not Path(args.index_file).exists():
-        print(f"Error: Index file does not exist: {args.index_file}")
+    # Validate backend configuration
+    if args.backend == 'pgvector' and not args.connection_string:
+        print("Error: --connection-string is required for pgvector backend")
+        sys.exit(1)
+    
+    if args.backend == 'sqlite' and not Path(args.index_source).exists():
+        print(f"Error: Index file does not exist: {args.index_source}")
         sys.exit(1)
     
     try:
@@ -389,9 +458,16 @@ def search_command():
         
         # Load search engine
         if args.verbose:
-            print(f"Loading search index: {args.index_file}")
+            if args.backend == 'sqlite':
+                print(f"Loading search index: {args.index_source}")
+            else:
+                print(f"Connecting to pgvector collection: {args.index_source}")
         
-        engine = SearchEngine(args.index_file)
+        if args.backend == 'sqlite':
+            engine = SearchEngine(backend='sqlite', index_path=args.index_source)
+        else:
+            engine = SearchEngine(backend='pgvector', connection_string=args.connection_string,
+                                collection_name=args.index_source)
         
         # Get index stats
         stats = engine.get_stats()

signalwire_agents/core/agent_base.py

@@ -121,9 +121,10 @@ class AgentBase(
         agent_id: Optional[str] = None,
         native_functions: Optional[List[str]] = None,
         schema_path: Optional[str] = None,
-        suppress_logs: bool = False,
+                suppress_logs: bool = False,
         enable_post_prompt_override: bool = False,
-        check_for_input_override: bool = False
+        check_for_input_override: bool = False,
+        config_file: Optional[str] = None
     ):
         """
         Initialize a new agent
@@ -147,6 +148,7 @@ class AgentBase(
             suppress_logs: Whether to suppress structured logs
             enable_post_prompt_override: Whether to enable post-prompt override
             check_for_input_override: Whether to enable check-for-input override
+            config_file: Optional path to configuration file
         """
         # Import SWMLService here to avoid circular imports
         from signalwire_agents.core.swml_service import SWMLService
@@ -154,14 +156,24 @@ class AgentBase(
         # If schema_path is not provided, we'll let SWMLService find it through its _find_schema_path method
         # which will be called in its __init__
         
+        # Load service configuration from config file before initializing SWMLService
+        service_config = self._load_service_config(config_file, name)
+        
+        # Apply service config values, with constructor parameters taking precedence
+        final_route = route if route != "/" else service_config.get('route', route)
+        final_host = host if host != "0.0.0.0" else service_config.get('host', host)
+        final_port = port if port != 3000 else service_config.get('port', port)
+        final_name = service_config.get('name', name)
+        
         # Initialize the SWMLService base class
         super().__init__(
-            name=name,
-            route=route,
-            host=host,
-            port=port,
+            name=final_name,
+            route=final_route,
+            host=final_host,
+            port=final_port,
             basic_auth=basic_auth,
-            schema_path=schema_path
+            schema_path=schema_path,
+            config_file=config_file
         )
         
         # Log the schema path if found and not suppressing logs
@@ -238,6 +250,20 @@ class AgentBase(
         self._params = {}
         self._global_data = {}
         self._function_includes = []
+        # Initialize with default LLM params
+        self._prompt_llm_params = {
+            'temperature': 0.3,
+            'top_p': 1.0,
+            'barge_confidence': 0.0,
+            'presence_penalty': 0.1,
+            'frequency_penalty': 0.1
+        }
+        self._post_prompt_llm_params = {
+            'temperature': 0.0,
+            'top_p': 1.0,
+            'presence_penalty': 0.0,
+            'frequency_penalty': 0.0
+        }
         
         # Dynamic configuration callback
         self._dynamic_config_callback = None
@@ -248,6 +274,30 @@ class AgentBase(
         # Initialize contexts system
         self._contexts_builder = None
         self._contexts_defined = False
+    
+    @staticmethod
+    def _load_service_config(config_file: Optional[str], service_name: str) -> dict:
+        """Load service configuration from config file if available"""
+        from signalwire_agents.core.config_loader import ConfigLoader
+        
+        # Find config file
+        if not config_file:
+            config_file = ConfigLoader.find_config_file(service_name)
+        
+        if not config_file:
+            return {}
+            
+        # Load config
+        config_loader = ConfigLoader([config_file])
+        if not config_loader.has_config():
+            return {}
+        
+        # Get service section
+        service_config = config_loader.get_section('service')
+        if service_config:
+            return service_config
+            
+        return {}
         
         # Initialize SWAIG query params for dynamic config
         self._swaig_query_params = {}
@@ -763,6 +813,30 @@ class AgentBase(
                 # Add global_data if any
                 if agent_to_use._global_data:
                     ai_config["global_data"] = agent_to_use._global_data
+                
+                # Always add LLM parameters to prompt
+                if "prompt" in ai_config:
+                    # Update existing prompt with LLM params
+                    if isinstance(ai_config["prompt"], dict):
+                        ai_config["prompt"].update(agent_to_use._prompt_llm_params)
+                    elif isinstance(ai_config["prompt"], str):
+                        # Convert string prompt to dict format
+                        ai_config["prompt"] = {
+                            "text": ai_config["prompt"],
+                            **agent_to_use._prompt_llm_params
+                        }
+                    
+                # Always add LLM parameters to post_prompt if post_prompt exists
+                if post_prompt and "post_prompt" in ai_config:
+                    # Update existing post_prompt with LLM params
+                    if isinstance(ai_config["post_prompt"], dict):
+                        ai_config["post_prompt"].update(agent_to_use._post_prompt_llm_params)
+                    elif isinstance(ai_config["post_prompt"], str):
+                        # Convert string post_prompt to dict format
+                        ai_config["post_prompt"] = {
+                            "text": ai_config["post_prompt"],
+                            **agent_to_use._post_prompt_llm_params
+                        }
                     
             except ValueError as e:
                 if not agent_to_use._suppress_logs:

signalwire_agents/core/mixins/ai_config_mixin.py

@@ -370,4 +370,124 @@ class AIConfigMixin:
                         valid_includes.append(include)
             
             self._function_includes = valid_includes
+        return self
+    
+    def set_prompt_llm_params(
+        self,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        barge_confidence: Optional[float] = None,
+        presence_penalty: Optional[float] = None,
+        frequency_penalty: Optional[float] = None
+    ) -> 'AgentBase':
+        """
+        Set LLM parameters for the main prompt.
+        
+        Args:
+            temperature: Randomness setting (0.0-1.5). Lower values make output more deterministic.
+                        Default: 0.3
+            top_p: Alternative to temperature (0.0-1.0). Controls nucleus sampling.
+                   Default: 1.0
+            barge_confidence: ASR confidence to interrupt (0.0-1.0). Higher values make it harder to interrupt.
+                             Default: 0.0
+            presence_penalty: Topic diversity (-2.0 to 2.0). Positive values encourage new topics.
+                             Default: 0.1
+            frequency_penalty: Repetition control (-2.0 to 2.0). Positive values reduce repetition.
+                              Default: 0.1
+        
+        Returns:
+            Self for method chaining
+            
+        Example:
+            agent.set_prompt_llm_params(
+                temperature=0.7,
+                top_p=0.9,
+                barge_confidence=0.6
+            )
+        """
+        # Validate and set temperature
+        if temperature is not None:
+            if not 0.0 <= temperature <= 1.5:
+                raise ValueError("temperature must be between 0.0 and 1.5")
+            self._prompt_llm_params['temperature'] = temperature
+        
+        # Validate and set top_p
+        if top_p is not None:
+            if not 0.0 <= top_p <= 1.0:
+                raise ValueError("top_p must be between 0.0 and 1.0")
+            self._prompt_llm_params['top_p'] = top_p
+        
+        # Validate and set barge_confidence
+        if barge_confidence is not None:
+            if not 0.0 <= barge_confidence <= 1.0:
+                raise ValueError("barge_confidence must be between 0.0 and 1.0")
+            self._prompt_llm_params['barge_confidence'] = barge_confidence
+        
+        # Validate and set presence_penalty
+        if presence_penalty is not None:
+            if not -2.0 <= presence_penalty <= 2.0:
+                raise ValueError("presence_penalty must be between -2.0 and 2.0")
+            self._prompt_llm_params['presence_penalty'] = presence_penalty
+        
+        # Validate and set frequency_penalty
+        if frequency_penalty is not None:
+            if not -2.0 <= frequency_penalty <= 2.0:
+                raise ValueError("frequency_penalty must be between -2.0 and 2.0")
+            self._prompt_llm_params['frequency_penalty'] = frequency_penalty
+        
+        return self
+    
+    def set_post_prompt_llm_params(
+        self,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        presence_penalty: Optional[float] = None,
+        frequency_penalty: Optional[float] = None
+    ) -> 'AgentBase':
+        """
+        Set LLM parameters for the post-prompt.
+        
+        Args:
+            temperature: Randomness setting (0.0-1.5). Lower values make output more deterministic.
+                        Default: 0.0
+            top_p: Alternative to temperature (0.0-1.0). Controls nucleus sampling.
+                   Default: 1.0
+            presence_penalty: Topic diversity (-2.0 to 2.0). Positive values encourage new topics.
+                             Default: 0.0
+            frequency_penalty: Repetition control (-2.0 to 2.0). Positive values reduce repetition.
+                              Default: 0.0
+        
+        Returns:
+            Self for method chaining
+            
+        Example:
+            agent.set_post_prompt_llm_params(
+                temperature=0.5,  # More deterministic for post-prompt
+                top_p=0.9
+            )
+        """
+        # Validate and set temperature
+        if temperature is not None:
+            if not 0.0 <= temperature <= 1.5:
+                raise ValueError("temperature must be between 0.0 and 1.5")
+            self._post_prompt_llm_params['temperature'] = temperature
+        
+        # Validate and set top_p
+        if top_p is not None:
+            if not 0.0 <= top_p <= 1.0:
+                raise ValueError("top_p must be between 0.0 and 1.0")
+            self._post_prompt_llm_params['top_p'] = top_p
+        
+        # Validate and set presence_penalty
+        if presence_penalty is not None:
+            if not -2.0 <= presence_penalty <= 2.0:
+                raise ValueError("presence_penalty must be between -2.0 and 2.0")
+            self._post_prompt_llm_params['presence_penalty'] = presence_penalty
+        
+        # Validate and set frequency_penalty
+        if frequency_penalty is not None:
+            if not -2.0 <= frequency_penalty <= 2.0:
+                raise ValueError("frequency_penalty must be between -2.0 and 2.0")
+            self._post_prompt_llm_params['frequency_penalty'] = frequency_penalty
+        
         return self

signalwire_agents/core/skill_manager.py

@@ -45,6 +45,53 @@ class SkillManager:
                 self.logger.error(error_msg)
                 return False, error_msg
         
+        # Validate that the skill has a proper parameter schema
+        if not hasattr(skill_class, 'get_parameter_schema') or not callable(getattr(skill_class, 'get_parameter_schema')):
+            error_msg = f"Skill '{skill_name}' must have get_parameter_schema() classmethod"
+            self.logger.error(error_msg)
+            return False, error_msg
+        
+        try:
+            # Validate the parameter schema
+            schema = skill_class.get_parameter_schema()
+            if not isinstance(schema, dict):
+                error_msg = f"Skill '{skill_name}'.get_parameter_schema() must return a dictionary"
+                self.logger.error(error_msg)
+                return False, error_msg
+                
+            # Ensure it's not an empty schema
+            if not schema:
+                error_msg = f"Skill '{skill_name}'.get_parameter_schema() returned empty dictionary"
+                self.logger.error(error_msg)
+                return False, error_msg
+            
+            # Check if the skill has overridden the method
+            from signalwire_agents.core.skill_base import SkillBase
+            skill_method = getattr(skill_class, 'get_parameter_schema', None)
+            base_method = getattr(SkillBase, 'get_parameter_schema', None)
+            
+            if skill_method and base_method:
+                # For class methods, check the underlying function
+                skill_func = skill_method.__func__ if hasattr(skill_method, '__func__') else skill_method
+                base_func = base_method.__func__ if hasattr(base_method, '__func__') else base_method
+                
+                if skill_func is base_func:
+                    # Get base schema to check if skill added any parameters
+                    base_schema = SkillBase.get_parameter_schema()
+                    if set(schema.keys()) == set(base_schema.keys()):
+                        error_msg = f"Skill '{skill_name}' must override get_parameter_schema() to define its specific parameters"
+                        self.logger.error(error_msg)
+                        return False, error_msg
+                
+        except AttributeError as e:
+            error_msg = f"Skill '{skill_name}' must properly implement get_parameter_schema() classmethod"
+            self.logger.error(error_msg)
+            return False, error_msg
+        except Exception as e:
+            error_msg = f"Skill '{skill_name}'.get_parameter_schema() failed: {e}"
+            self.logger.error(error_msg)
+            return False, error_msg
+        
         try:
             # Create skill instance with parameters to get the instance key
             skill_instance = skill_class(self.agent, params)

signalwire_agents/search/index_builder.py

@@ -46,7 +46,9 @@ class IndexBuilder:
         index_nlp_backend: str = 'nltk',
         verbose: bool = False,
         semantic_threshold: float = 0.5,
-        topic_threshold: float = 0.3
+        topic_threshold: float = 0.3,
+        backend: str = 'sqlite',
+        connection_string: Optional[str] = None
     ):
         """
         Initialize the index builder
@@ -62,6 +64,8 @@ class IndexBuilder:
             verbose: Whether to enable verbose logging (default: False)
             semantic_threshold: Similarity threshold for semantic chunking (default: 0.5)
             topic_threshold: Similarity threshold for topic chunking (default: 0.3)
+            backend: Storage backend ('sqlite' or 'pgvector') (default: 'sqlite')
+            connection_string: PostgreSQL connection string for pgvector backend
         """
         self.model_name = model_name
         self.chunking_strategy = chunking_strategy
@@ -73,8 +77,17 @@ class IndexBuilder:
         self.verbose = verbose
         self.semantic_threshold = semantic_threshold
         self.topic_threshold = topic_threshold
+        self.backend = backend
+        self.connection_string = connection_string
         self.model = None
         
+        # Validate backend
+        if self.backend not in ['sqlite', 'pgvector']:
+            raise ValueError(f"Invalid backend '{self.backend}'. Must be 'sqlite' or 'pgvector'")
+        
+        if self.backend == 'pgvector' and not self.connection_string:
+            raise ValueError("connection_string is required for pgvector backend")
+        
         # Validate NLP backend
         if self.index_nlp_backend not in ['nltk', 'spacy']:
             logger.warning(f"Invalid index_nlp_backend '{self.index_nlp_backend}', using 'nltk'")
@@ -109,7 +122,8 @@ class IndexBuilder:
     
     def build_index_from_sources(self, sources: List[Path], output_file: str, 
                                 file_types: List[str], exclude_patterns: Optional[List[str]] = None,
-                                languages: List[str] = None, tags: Optional[List[str]] = None):
+                                languages: List[str] = None, tags: Optional[List[str]] = None,
+                                overwrite: bool = False):
         """
         Build complete search index from multiple sources (files and directories)
         
@@ -191,13 +205,18 @@ class IndexBuilder:
                 else:
                     chunk['embedding'] = b''
         
-        # Create SQLite database
-        sources_info = [str(s) for s in sources]
-        self._create_database(output_file, chunks, languages or ['en'], sources_info, file_types)
-        
-        if self.verbose:
-            print(f"Index created: {output_file}")
-            print(f"Total chunks: {len(chunks)}")
+        # Store chunks based on backend
+        if self.backend == 'sqlite':
+            # Create SQLite database
+            sources_info = [str(s) for s in sources]
+            self._create_database(output_file, chunks, languages or ['en'], sources_info, file_types)
+            
+            if self.verbose:
+                print(f"Index created: {output_file}")
+                print(f"Total chunks: {len(chunks)}")
+        else:
+            # Use pgvector backend
+            self._store_chunks_pgvector(chunks, output_file, languages or ['en'], overwrite)
 
     def build_index(self, source_dir: str, output_file: str, 
                    file_types: List[str], exclude_patterns: Optional[List[str]] = None,
@@ -607,4 +626,80 @@ class IndexBuilder:
             }
             
         except Exception as e:
-            return {"valid": False, "error": str(e)} 
+            return {"valid": False, "error": str(e)}
+    
+    def _store_chunks_pgvector(self, chunks: List[Dict[str, Any]], collection_name: str,
+                              languages: List[str], overwrite: bool = False):
+        """
+        Store chunks in pgvector backend
+        
+        Args:
+            chunks: List of processed chunks
+            collection_name: Name for the collection (from output_file parameter)
+            languages: List of supported languages
+        """
+        from .pgvector_backend import PgVectorBackend
+        
+        # Extract collection name from the provided name
+        if collection_name.endswith('.swsearch'):
+            collection_name = collection_name[:-9]  # Remove .swsearch extension
+        
+        # Clean collection name for PostgreSQL
+        import re
+        collection_name = re.sub(r'[^a-zA-Z0-9_]', '_', collection_name)
+        
+        if self.verbose:
+            print(f"Storing chunks in pgvector collection: {collection_name}")
+        
+        # Create backend instance
+        backend = PgVectorBackend(self.connection_string)
+        
+        try:
+            # Get embedding dimensions from model
+            if self.model:
+                embedding_dim = self.model.get_sentence_embedding_dimension()
+            else:
+                embedding_dim = 768  # Default for all-mpnet-base-v2
+            
+            # Delete existing collection if overwrite is requested
+            if overwrite:
+                if self.verbose:
+                    print(f"Dropping existing collection: {collection_name}")
+                backend.delete_collection(collection_name)
+            
+            # Create schema
+            backend.create_schema(collection_name, embedding_dim)
+            
+            # Convert embeddings from bytes to numpy arrays
+            for chunk in chunks:
+                if chunk.get('embedding') and isinstance(chunk['embedding'], bytes):
+                    if np:
+                        chunk['embedding'] = np.frombuffer(chunk['embedding'], dtype=np.float32)
+                    else:
+                        # If numpy not available, leave as bytes
+                        pass
+            
+            # Prepare config
+            config = {
+                'model_name': self.model_name,
+                'embedding_dimensions': embedding_dim,
+                'chunking_strategy': self.chunking_strategy,
+                'languages': languages,
+                'metadata': {
+                    'max_sentences_per_chunk': self.max_sentences_per_chunk,
+                    'chunk_size': self.chunk_size,
+                    'chunk_overlap': self.chunk_overlap,
+                    'index_nlp_backend': self.index_nlp_backend
+                }
+            }
+            
+            # Store chunks
+            backend.store_chunks(chunks, collection_name, config)
+            
+            if self.verbose:
+                stats = backend.get_stats(collection_name)
+                print(f"Stored {stats['total_chunks']} chunks in pgvector")
+                print(f"Collection: {collection_name}")
+                
+        finally:
+            backend.close()