signalwire-agents 0.1.46__py3-none-any.whl → 0.1.48__py3-none-any.whl

signalwire_agents/core/agent_base.py

@@ -250,20 +250,9 @@ 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
-        }
+        # Initialize LLM params as empty - only send if explicitly set
+        self._prompt_llm_params = {}
+        self._post_prompt_llm_params = {}
         
         # Dynamic configuration callback
         self._dynamic_config_callback = None
@@ -692,7 +681,7 @@ class AgentBase(
                     "parameters": func._ensure_parameter_structure()
                 }
                 
-                # Add wait_file if present (SignalWire SWML expects wait_file, not fillers)
+                # Add wait_file if present (audio/video file URL)
                 if hasattr(func, 'wait_file') and func.wait_file:
                     wait_file_url = func.wait_file
                     # If wait_file is a relative URL, convert it to absolute using agent's base URL
@@ -704,9 +693,10 @@ class AgentBase(
                             wait_file_url = '/' + wait_file_url
                         wait_file_url = f"{base_url}{wait_file_url}"
                     function_entry["wait_file"] = wait_file_url
-                elif func.fillers:
-                    # Backward compatibility: use fillers as wait_file if wait_file not specified
-                    function_entry["wait_file"] = func.fillers
+                
+                # Add fillers if present (text phrases to say while processing)
+                if hasattr(func, 'fillers') and func.fillers:
+                    function_entry["fillers"] = func.fillers
                 
                 # Add wait_file_loops if present
                 if hasattr(func, 'wait_file_loops') and func.wait_file_loops is not None:
@@ -833,27 +823,29 @@ class AgentBase(
                 
                 # 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
-                        }
+                    # Only add LLM params if explicitly set
+                    if agent_to_use._prompt_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
+                # Only add LLM parameters to post_prompt if explicitly set
                 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
-                        }
+                    # Only add LLM params if explicitly set
+                    if agent_to_use._post_prompt_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

@@ -372,28 +372,22 @@ class AIConfigMixin:
             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':
+    def set_prompt_llm_params(self, **params) -> '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
+        Accepts any parameters which will be passed through to the SignalWire server.
+        The server will validate and apply parameters based on the target model's capabilities.
+        
+        Common parameters include:
+            temperature: Randomness setting. Lower values make output more deterministic.
+            top_p: Alternative to temperature. Controls nucleus sampling.
+            barge_confidence: ASR confidence to interrupt. Higher values make it harder to interrupt.
+            presence_penalty: Topic diversity. Positive values encourage new topics.
+            frequency_penalty: Repetition control. Positive values reduce repetition.
+        
+        Note: Parameters are model-specific and will be validated by the server.
+        Invalid parameters for the selected model will be handled/ignored by the server.
         
         Returns:
             Self for method chaining
@@ -405,57 +399,28 @@ class AIConfigMixin:
                 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
+        # Accept any parameters without validation
+        if params:
+            self._prompt_llm_params.update(params)
         
         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':
+    def set_post_prompt_llm_params(self, **params) -> '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
+        Accepts any parameters which will be passed through to the SignalWire server.
+        The server will validate and apply parameters based on the target model's capabilities.
+        
+        Common parameters include:
+            temperature: Randomness setting. Lower values make output more deterministic.
+            top_p: Alternative to temperature. Controls nucleus sampling.
+            presence_penalty: Topic diversity. Positive values encourage new topics.
+            frequency_penalty: Repetition control. Positive values reduce repetition.
+        
+        Note: Parameters are model-specific and will be validated by the server.
+        Invalid parameters for the selected model will be handled/ignored by the server.
+        barge_confidence is not applicable to post-prompt.
         
         Returns:
             Self for method chaining
@@ -466,28 +431,8 @@ class AIConfigMixin:
                 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
+        # Accept any parameters without validation
+        if params:
+            self._post_prompt_llm_params.update(params)
         
         return self

signalwire_agents/core/swaig_function.py

@@ -57,8 +57,8 @@ class SWAIGFunction:
         self.description = description
         self.parameters = parameters or {}
         self.secure = secure
-        self.fillers = fillers  # Keep for backward compatibility
-        self.wait_file = wait_file or fillers  # Use wait_file if provided, else fall back to fillers
+        self.fillers = fillers  # Text phrases to say while processing
+        self.wait_file = wait_file  # URL to audio/video file to play while waiting
         self.wait_file_loops = wait_file_loops
         self.webhook_url = webhook_url
         self.required = required or []

signalwire_agents/search/__init__.py

@@ -68,6 +68,8 @@ if _SEARCH_AVAILABLE:
         from .index_builder import IndexBuilder
         from .search_engine import SearchEngine
         from .search_service import SearchService
+        from .models import MODEL_ALIASES, DEFAULT_MODEL, resolve_model_alias
+        from .migration import SearchIndexMigrator
         
         __all__ = [
             'preprocess_query',
@@ -75,7 +77,11 @@ if _SEARCH_AVAILABLE:
             'DocumentProcessor',
             'IndexBuilder',
             'SearchEngine',
-            'SearchService'
+            'SearchService',
+            'MODEL_ALIASES',
+            'DEFAULT_MODEL',
+            'resolve_model_alias',
+            'SearchIndexMigrator'
         ]
     except ImportError as e:
         # Some search components failed to import

signalwire_agents/search/document_processor.py

@@ -140,6 +140,8 @@ class DocumentProcessor:
             return self._chunk_by_topics(content, filename, file_type)
         elif self.chunking_strategy == 'qa':
             return self._chunk_by_qa_optimization(content, filename, file_type)
+        elif self.chunking_strategy == 'json':
+            return self._chunk_from_json(content, filename, file_type)
         else:
             # Fallback to sentence-based chunking
             return self._chunk_by_sentences(content, filename, file_type)
@@ -1022,4 +1024,106 @@ class DocumentProcessor:
             ))
         
         return chunks if chunks else [self._create_chunk(content, filename, "QA Section 1",
-                                                       metadata={'chunk_method': 'qa_optimized', 'chunk_index': 0})] 
+                                                       metadata={'chunk_method': 'qa_optimized', 'chunk_index': 0})]
+    
+    def _chunk_from_json(self, content: str, filename: str, file_type: str) -> List[Dict[str, Any]]:
+        """
+        Create chunks from pre-processed JSON content
+        
+        This strategy expects content to be a JSON string with the following structure:
+        {
+            "chunks": [
+                {
+                    "chunk_id": "unique_id",
+                    "type": "content|toc",
+                    "content": "text content",
+                    "metadata": {
+                        "url": "https://...",
+                        "section_number": 1,
+                        "related_toc": "toc_id",
+                        ...
+                    }
+                },
+                ...
+            ]
+        }
+        
+        Args:
+            content: JSON string containing pre-chunked content
+            filename: Name of the source file
+            file_type: Should be 'json'
+            
+        Returns:
+            List of chunk dictionaries formatted for the search index
+        """
+        try:
+            # Parse JSON content
+            data = json.loads(content)
+            
+            if not isinstance(data, dict) or 'chunks' not in data:
+                logger.error(f"Invalid JSON structure in {filename}: expected 'chunks' key")
+                # Fallback to treating it as plain text
+                return self._chunk_by_sentences(content, filename, file_type)
+            
+            chunks = []
+            for idx, json_chunk in enumerate(data['chunks']):
+                if not isinstance(json_chunk, dict) or 'content' not in json_chunk:
+                    logger.warning(f"Skipping invalid chunk {idx} in {filename}")
+                    continue
+                
+                # Extract metadata from JSON chunk
+                json_metadata = json_chunk.get('metadata', {})
+                chunk_type = json_chunk.get('type', 'content')
+                
+                # Build chunk metadata (excluding tags which go at top level)
+                metadata = {
+                    'chunk_method': 'json',
+                    'chunk_index': idx,
+                    'chunk_type': chunk_type,
+                    'original_chunk_id': json_chunk.get('chunk_id', f'chunk_{idx}')
+                }
+                
+                # Extract tags before merging metadata
+                tags = json_metadata.get('tags', [])
+                
+                # Merge JSON metadata (this includes all fields including tags)
+                # We'll keep tags in metadata for backward compatibility but also set at top level
+                metadata.update(json_metadata)
+                
+                # Determine section name
+                if chunk_type == 'toc':
+                    section = f"TOC: {json_chunk.get('content', '')[:50]}"
+                else:
+                    section = json_metadata.get('section', f"Section {json_metadata.get('section_number', idx + 1)}")
+                
+                # Create chunk with proper structure
+                chunk = self._create_chunk(
+                    content=json_chunk['content'],
+                    filename=filename,
+                    section=section,
+                    metadata=metadata
+                )
+                
+                # Set tags at the top level for proper tag filtering
+                if tags:
+                    chunk['tags'] = tags
+                elif chunk_type == 'toc':
+                    # For TOC entries, add special tags if none provided
+                    chunk['tags'] = ['toc', 'navigation']
+                
+                chunks.append(chunk)
+            
+            if not chunks:
+                logger.warning(f"No valid chunks found in JSON file {filename}")
+                return self._chunk_by_sentences(str(data), filename, file_type)
+            
+            logger.info(f"Created {len(chunks)} chunks from JSON file {filename}")
+            return chunks
+            
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse JSON in {filename}: {e}")
+            # Fallback to sentence chunking
+            return self._chunk_by_sentences(content, filename, file_type)
+        except Exception as e:
+            logger.error(f"Unexpected error processing JSON chunks in {filename}: {e}")
+            return self._chunk_by_sentences(content, filename, file_type) 

signalwire_agents/search/index_builder.py

@@ -55,7 +55,7 @@ class IndexBuilder:
         
         Args:
             model_name: Name of the sentence transformer model to use
-            chunking_strategy: Strategy for chunking documents ('sentence', 'sliding', 'paragraph', 'page', 'semantic', 'topic', 'qa')
+            chunking_strategy: Strategy for chunking documents ('sentence', 'sliding', 'paragraph', 'page', 'semantic', 'topic', 'qa', 'json')
             max_sentences_per_chunk: For sentence strategy (default: 5)
             chunk_size: For sliding strategy - words per chunk (default: 50)
             chunk_overlap: For sliding strategy - overlap in words (default: 10)
@@ -85,9 +85,6 @@ class IndexBuilder:
         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'")
@@ -105,6 +102,50 @@ class IndexBuilder:
             topic_threshold=self.topic_threshold
         )
     
+    def _extract_metadata_from_json_content(self, content: str) -> tuple[Dict[str, Any], str]:
+        """
+        Extract metadata from JSON content if present
+        
+        Returns:
+            (metadata_dict, metadata_text)
+        """
+        metadata_dict = {}
+        
+        # Try to extract metadata from JSON structure in content
+        if '"metadata":' in content:
+            try:
+                # Look for metadata object in content
+                import re
+                # Find all metadata objects
+                pattern = r'"metadata"\s*:\s*(\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\})'
+                matches = re.finditer(pattern, content)
+                
+                for match in matches:
+                    try:
+                        json_metadata = json.loads(match.group(1))
+                        # Merge all found metadata
+                        if isinstance(json_metadata, dict):
+                            metadata_dict.update(json_metadata)
+                    except:
+                        pass
+            except Exception as e:
+                logger.debug(f"Error extracting JSON metadata: {e}")
+        
+        # Create searchable text from all metadata keys and values
+        metadata_text_parts = []
+        for key, value in metadata_dict.items():
+            # Add key
+            metadata_text_parts.append(str(key))
+            # Add value(s)
+            if isinstance(value, list):
+                metadata_text_parts.extend(str(v) for v in value)
+            else:
+                metadata_text_parts.append(str(value))
+        
+        metadata_text = ' '.join(metadata_text_parts).lower()
+        
+        return metadata_dict, metadata_text
+    
     def _load_model(self):
         """Load embedding model (lazy loading)"""
         if self.model is None:
@@ -147,6 +188,7 @@ class IndexBuilder:
         
         # Process documents
         chunks = []
+        print(f"Processing {len(files)} files...")
         for file_path in files:
             try:
                 # For individual files, use the file's parent as the base directory
@@ -154,8 +196,8 @@ class IndexBuilder:
                 base_dir = self._get_base_directory_for_file(file_path, sources)
                 file_chunks = self._process_file(file_path, base_dir, tags)
                 chunks.extend(file_chunks)
-                if self.verbose:
-                    print(f"Processed {file_path}: {len(file_chunks)} chunks")
+                if self.verbose or file_path.suffix == '.json':
+                    print(f"  {file_path}: {len(file_chunks)} chunks")
             except Exception as e:
                 logger.error(f"Error processing {file_path}: {e}")
                 if self.verbose:
@@ -171,7 +213,9 @@ class IndexBuilder:
         # Generate embeddings
         self._load_model()
         if self.verbose:
-            print("Generating embeddings...")
+            print(f"Generating embeddings for {len(chunks)} chunks...")
+        else:
+            print(f"Generating embeddings for {len(chunks)} chunks...")
         
         for i, chunk in enumerate(chunks):
             try:
@@ -183,15 +227,33 @@ class IndexBuilder:
                 )
                 
                 chunk['processed_content'] = processed['enhanced_text']
-                chunk['keywords'] = processed.get('keywords', [])
+                
+                # Include tags in keywords for better search matching
+                keywords = processed.get('keywords', [])
+                chunk_tags = chunk.get('tags', [])
+                if chunk_tags:
+                    # Add tags to keywords list for FTS matching
+                    keywords.extend(chunk_tags)
+                    # Remove duplicates while preserving order
+                    keywords = list(dict.fromkeys(keywords))
+                
+                chunk['keywords'] = keywords
+                
+                # For embedding, include tags in the text for better semantic matching
+                embedding_text = processed['enhanced_text']
+                if chunk_tags:
+                    # Append tags to the text for embedding generation
+                    embedding_text += " " + " ".join(chunk_tags)
                 
                 # Generate embedding (suppress progress bar)
-                embedding = self.model.encode(processed['enhanced_text'], show_progress_bar=False)
+                embedding = self.model.encode(embedding_text, show_progress_bar=False)
                 chunk['embedding'] = embedding.tobytes()
                 
-                if self.verbose and (i + 1) % 50 == 0:
+                # Show progress more frequently
+                show_every = 50 if len(chunks) > 500 else max(10, len(chunks) // 10)
+                if (i + 1) % show_every == 0 or (i + 1) == len(chunks):
                     progress_pct = ((i + 1) / len(chunks)) * 100
-                    print(f"Generated embeddings: {i + 1}/{len(chunks)} chunks ({progress_pct:.1f}%)")
+                    print(f"  Progress: {i + 1}/{len(chunks)} chunks ({progress_pct:.1f}%)")
                     
             except Exception as e:
                 logger.error(f"Error processing chunk {i}: {e}")
@@ -485,6 +547,7 @@ class IndexBuilder:
                     end_line INTEGER,
                     tags TEXT,
                     metadata TEXT,
+                    metadata_text TEXT,  -- Searchable text representation of all metadata
                     chunk_hash TEXT UNIQUE,
                     created_at TEXT DEFAULT CURRENT_TIMESTAMP
                 )
@@ -494,6 +557,7 @@ class IndexBuilder:
                 CREATE VIRTUAL TABLE chunks_fts USING fts5(
                     processed_content,
                     keywords,
+                    metadata_text,
                     content='chunks',
                     content_rowid='id'
                 )
@@ -555,13 +619,47 @@ class IndexBuilder:
                 # Prepare data
                 keywords_json = json.dumps(chunk.get('keywords', []))
                 tags_json = json.dumps(chunk.get('tags', []))
-                metadata_json = json.dumps(chunk.get('metadata', {}))
+                
+                # Extract metadata from JSON content and merge with chunk metadata
+                json_metadata, json_metadata_text = self._extract_metadata_from_json_content(chunk['content'])
+                chunk_metadata = chunk.get('metadata', {})
+                
+                # Merge metadata: chunk metadata takes precedence
+                merged_metadata = {**json_metadata, **chunk_metadata}
+                metadata_json = json.dumps(merged_metadata)
+                
+                # Create comprehensive metadata_text including tags
+                metadata_text_parts = []
+                
+                # Add metadata text from JSON content
+                if json_metadata_text:
+                    metadata_text_parts.append(json_metadata_text)
+                
+                # Add tags
+                tags = chunk.get('tags', [])
+                if tags:
+                    metadata_text_parts.extend(str(tag).lower() for tag in tags)
+                
+                # Add section if present
+                if chunk.get('section'):
+                    metadata_text_parts.append(chunk['section'].lower())
+                
+                # Add any additional metadata values
+                for key, value in chunk_metadata.items():
+                    if key not in json_metadata:  # Avoid duplicates
+                        metadata_text_parts.append(str(key).lower())
+                        if isinstance(value, list):
+                            metadata_text_parts.extend(str(v).lower() for v in value)
+                        else:
+                            metadata_text_parts.append(str(value).lower())
+                
+                metadata_text = ' '.join(metadata_text_parts)
                 
                 cursor.execute('''
                     INSERT OR IGNORE INTO chunks (
                         content, processed_content, keywords, language, embedding,
-                        filename, section, start_line, end_line, tags, metadata, chunk_hash
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                        filename, section, start_line, end_line, tags, metadata, metadata_text, chunk_hash
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 ''', (
                     chunk['content'],
                     chunk.get('processed_content', chunk['content']),
@@ -574,6 +672,7 @@ class IndexBuilder:
                     chunk.get('end_line'),
                     tags_json,
                     metadata_json,
+                    metadata_text,
                     chunk_hash
                 ))