signalwire-agents 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

signalwire_agents/core/logging_config.py

@@ -89,28 +89,85 @@ class StructuredLoggerWrapper:
     # Also support the 'warn' alias
     warn = warning
     
+    def bind(self, **kwargs) -> 'StructuredLoggerWrapper':
+        """
+        Create a new logger instance with bound context data
+        
+        This maintains compatibility with structlog's bind() method.
+        The bound data will be included in all subsequent log messages.
+        """
+        # Create a new wrapper that includes the bound context
+        return BoundStructuredLoggerWrapper(self._logger, kwargs)
+    
     # Support direct access to underlying logger attributes if needed
     def __getattr__(self, name: str) -> Any:
         """Delegate any unknown attributes to the underlying logger"""
         return getattr(self._logger, name)
 
 
-def get_execution_mode() -> str:
+class BoundStructuredLoggerWrapper(StructuredLoggerWrapper):
+    """
+    A structured logger wrapper that includes bound context data in all messages
+    """
+    
+    def __init__(self, logger: logging.Logger, bound_data: Dict[str, Any]):
+        super().__init__(logger)
+        self._bound_data = bound_data
+    
+    def _format_structured_message(self, message: str, **kwargs) -> str:
+        """Format a message with both bound data and additional keyword arguments"""
+        # Combine bound data with additional kwargs
+        all_kwargs = {**self._bound_data, **kwargs}
+        return super()._format_structured_message(message, **all_kwargs)
+    
+    def bind(self, **kwargs) -> 'BoundStructuredLoggerWrapper':
+        """Create a new logger with additional bound context"""
+        # Combine existing bound data with new data
+        new_bound_data = {**self._bound_data, **kwargs}
+        return BoundStructuredLoggerWrapper(self._logger, new_bound_data)
+
+
+def get_execution_mode():
     """
     Determine the execution mode based on environment variables
     
     Returns:
-        'cgi' if running in CGI mode
-        'lambda' if running in AWS Lambda 
-        'server' for normal server mode
+        str: 'server', 'cgi', 'lambda', 'google_cloud_function', 'azure_function', or 'unknown'
     """
+    # Check for CGI environment
     if os.getenv('GATEWAY_INTERFACE'):
         return 'cgi'
+    
+    # Check for AWS Lambda environment
     if os.getenv('AWS_LAMBDA_FUNCTION_NAME') or os.getenv('LAMBDA_TASK_ROOT'):
         return 'lambda'
+    
+    # Check for Google Cloud Functions environment
+    if (os.getenv('FUNCTION_TARGET') or 
+        os.getenv('K_SERVICE') or 
+        os.getenv('GOOGLE_CLOUD_PROJECT')):
+        return 'google_cloud_function'
+    
+    # Check for Azure Functions environment
+    if (os.getenv('AZURE_FUNCTIONS_ENVIRONMENT') or 
+        os.getenv('FUNCTIONS_WORKER_RUNTIME') or
+        os.getenv('AzureWebJobsStorage')):
+        return 'azure_function'
+    
+    # Default to server mode
     return 'server'
 
 
+def reset_logging_configuration():
+    """
+    Reset the logging configuration flag to allow reconfiguration
+    
+    This is useful when environment variables change after initial configuration.
+    """
+    global _logging_configured
+    _logging_configured = False
+
+
 def configure_logging():
     """
     Configure logging system once, globally, based on environment variables
@@ -182,31 +239,39 @@ def _configure_off_mode():
 
 
 def _configure_stderr_mode(log_level: str):
-    """Configure logging to stderr"""
+    """Configure logging to stderr with colored formatting"""
     # Clear existing handlers
     logging.getLogger().handlers.clear()
     
     # Convert log level
     numeric_level = getattr(logging, log_level.upper(), logging.INFO)
     
-    # Configure to stderr
-    logging.basicConfig(
-        stream=sys.stderr,
-        level=numeric_level,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
+    # Create handler with colored formatter
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(ColoredFormatter())
+    
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(numeric_level)
+    root_logger.addHandler(handler)
 
 
 def _configure_default_mode(log_level: str):
-    """Configure standard logging behavior"""
+    """Configure standard logging behavior with colored formatting"""
+    # Clear existing handlers
+    logging.getLogger().handlers.clear()
+    
     # Convert log level
     numeric_level = getattr(logging, log_level.upper(), logging.INFO)
     
-    # Configure standard logging
-    logging.basicConfig(
-        level=numeric_level,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
+    # Create handler with colored formatter
+    handler = logging.StreamHandler()
+    handler.setFormatter(ColoredFormatter())
+    
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(numeric_level)
+    root_logger.addHandler(handler)
 
 
 def get_logger(name: str) -> StructuredLoggerWrapper:
@@ -229,4 +294,83 @@ def get_logger(name: str) -> StructuredLoggerWrapper:
     python_logger = logging.getLogger(name)
     
     # Wrap it with our structured logging interface
-    return StructuredLoggerWrapper(python_logger) 
+    return StructuredLoggerWrapper(python_logger)
+
+
+class ColoredFormatter(logging.Formatter):
+    """
+    A beautiful colored logging formatter that makes logs easy to read and visually appealing
+    """
+    
+    # ANSI color codes
+    COLORS = {
+        'DEBUG': '\033[36m',     # Cyan
+        'INFO': '\033[32m',      # Green  
+        'WARNING': '\033[33m',   # Yellow
+        'ERROR': '\033[31m',     # Red
+        'CRITICAL': '\033[35m',  # Magenta
+        'RESET': '\033[0m',      # Reset
+        'BOLD': '\033[1m',       # Bold
+        'DIM': '\033[2m',        # Dim
+        'WHITE': '\033[37m',     # White
+        'BLUE': '\033[34m',      # Blue
+        'BLACK': '\033[30m',     # Black (for brackets)
+    }
+    
+    def __init__(self):
+        super().__init__()
+    
+    def format(self, record):
+        # Check if we should use colors (not in raw mode, and stdout is a tty)
+        use_colors = (
+            hasattr(sys.stdout, 'isatty') and sys.stdout.isatty() and
+            os.getenv('SIGNALWIRE_LOG_MODE') != 'off' and
+            '--raw' not in sys.argv and '--dump-swml' not in sys.argv
+        )
+        
+        if use_colors:
+            # Get colors
+            level_color = self.COLORS.get(record.levelname, self.COLORS['WHITE'])
+            reset = self.COLORS['RESET']
+            dim = self.COLORS['DIM']
+            bold = self.COLORS['BOLD']
+            blue = self.COLORS['BLUE']
+            black = self.COLORS['BLACK']
+            
+            # Format timestamp in a compact, readable way
+            timestamp = self.formatTime(record, '%H:%M:%S')
+            
+            # Format level with appropriate color and consistent width
+            level_name = f"{level_color}{record.levelname:<8}{reset}"
+            
+            # Format logger name - keep it short and readable
+            logger_name = record.name
+            if len(logger_name) > 15:
+                # Truncate long logger names but keep the end (most specific part)
+                logger_name = "..." + logger_name[-12:]
+            
+            # Get function and line info if available
+            func_info = ""
+            if hasattr(record, 'funcName') and hasattr(record, 'lineno'):
+                func_name = getattr(record, 'funcName', '')
+                line_no = getattr(record, 'lineno', 0)
+                if func_name and func_name != '<module>':
+                    func_info = f" {dim}({func_name}:{line_no}){reset}"
+            
+            # Format the message
+            message = record.getMessage()
+            
+            # Create the final formatted message with a clean, readable layout
+            formatted = (
+                f"{black}[{reset}{dim}{timestamp}{reset}{black}]{reset} "
+                f"{level_name} "
+                f"{blue}{logger_name:<15}{reset}"
+                f"{func_info} "
+                f"{message}"
+            )
+            
+            return formatted
+        else:
+            # Non-colored format (fallback for files, pipes, etc.)
+            timestamp = self.formatTime(record, '%Y-%m-%d %H:%M:%S')
+            return f"{timestamp} {record.levelname:<8} {record.name} {record.getMessage()}" 

signalwire_agents/core/skill_manager.py

@@ -8,7 +8,7 @@ See LICENSE file in the project root for full license information.
 """
 
 from typing import Dict, List, Type, Any, Optional
-import logging
+from signalwire_agents.core.logging_config import get_logger
 from signalwire_agents.core.skill_base import SkillBase
 
 class SkillManager:
@@ -17,7 +17,7 @@ class SkillManager:
     def __init__(self, agent):
         self.agent = agent
         self.loaded_skills: Dict[str, SkillBase] = {}
-        self.logger = logging.getLogger("skill_manager")
+        self.logger = get_logger("skill_manager")
         
     def load_skill(self, skill_name: str, skill_class: Type[SkillBase] = None, params: Optional[Dict[str, Any]] = None) -> tuple[bool, str]:
         """

signalwire_agents/core/swml_service.py

@@ -24,51 +24,11 @@ import types
 from typing import Dict, List, Any, Optional, Union, Callable, Tuple, Type
 from urllib.parse import urlparse
 
-# Import and configure structlog
-try:
-    import structlog
-    
-    # Only configure if not already configured
-    if not hasattr(structlog, "_configured") or not structlog._configured:
-        structlog.configure(
-            processors=[
-                structlog.stdlib.filter_by_level,
-                structlog.stdlib.add_logger_name,
-                structlog.stdlib.add_log_level,
-                structlog.stdlib.PositionalArgumentsFormatter(),
-                structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S"),
-                structlog.processors.StackInfoRenderer(),
-                structlog.processors.format_exc_info,
-                structlog.processors.UnicodeDecoder(),
-                structlog.dev.ConsoleRenderer()
-            ],
-            context_class=dict,
-            logger_factory=structlog.stdlib.LoggerFactory(),
-            wrapper_class=structlog.stdlib.BoundLogger,
-            cache_logger_on_first_use=True,
-        )
-        
-        # Set up root logger with structlog
-        logging.basicConfig(
-            format="%(message)s",
-            stream=sys.stdout,
-            level=logging.INFO,
-        )
-        
-        # Mark as configured to avoid duplicate configuration
-        structlog._configured = True
-    
-    # Create the module logger
-    logger = structlog.get_logger("swml_service")
-    
-except ImportError:
-    # Fallback to standard logging if structlog is not available
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-        stream=sys.stdout
-    )
-    logger = logging.getLogger("swml_service")
+# Import centralized logging system
+from signalwire_agents.core.logging_config import get_logger
+
+# Create the module logger using centralized system
+logger = get_logger("swml_service")
 
 try:
     import fastapi

signalwire_agents/search/document_processor.py

@@ -74,29 +74,42 @@ logger = logging.getLogger(__name__)
 class DocumentProcessor:
     """Enhanced document processor with smart chunking capabilities"""
     
-    def __init__(self, chunking_strategy: str = 'sentence', 
-                 max_sentences_per_chunk: int = 50,
-                 chunk_size: int = 50, 
-                 overlap_size: int = 10,
-                 split_newlines: Optional[int] = None):
+    def __init__(
+        self,
+        chunking_strategy: str = 'sentence',
+        max_sentences_per_chunk: int = 5,
+        chunk_size: int = 50,
+        chunk_overlap: int = 10,
+        split_newlines: Optional[int] = None,
+        index_nlp_backend: str = 'nltk',
+        verbose: bool = False,
+        semantic_threshold: float = 0.5,
+        topic_threshold: float = 0.3
+    ):
         """
-        Initialize document processor with chunking strategy
+        Initialize document processor
         
         Args:
-            chunking_strategy: 'sentence', 'sliding', 'paragraph', or 'page'
-            max_sentences_per_chunk: For sentence strategy (default: 50)
+            chunking_strategy: Strategy for chunking documents ('sentence', 'sliding', 'paragraph', 'page', 'semantic', 'topic', 'qa')
+            max_sentences_per_chunk: For sentence strategy (default: 5)
             chunk_size: For sliding strategy - words per chunk (default: 50)
-            overlap_size: For sliding strategy - overlap in words (default: 10)
+            chunk_overlap: For sliding strategy - overlap in words (default: 10)
             split_newlines: For sentence strategy - split on multiple newlines (optional)
+            index_nlp_backend: NLP backend for indexing (default: 'nltk')
+            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)
         """
         self.chunking_strategy = chunking_strategy
         self.max_sentences_per_chunk = max_sentences_per_chunk
         self.chunk_size = chunk_size
-        self.overlap_size = overlap_size
+        self.chunk_overlap = chunk_overlap
         self.split_newlines = split_newlines
+        self.semantic_threshold = semantic_threshold
+        self.topic_threshold = topic_threshold
         
         # Legacy support for old character-based chunking
-        self.chunk_overlap = overlap_size
+        self.chunk_overlap = chunk_overlap
     
     def create_chunks(self, content: str, filename: str, 
                      file_type: str) -> List[Dict[str, Any]]:
@@ -121,6 +134,12 @@ class DocumentProcessor:
             return self._chunk_by_paragraphs(content, filename, file_type)
         elif self.chunking_strategy == 'page':
             return self._chunk_by_pages(content, filename, file_type)
+        elif self.chunking_strategy == 'semantic':
+            return self._chunk_by_semantic(content, filename, file_type)
+        elif self.chunking_strategy == 'topic':
+            return self._chunk_by_topics(content, filename, file_type)
+        elif self.chunking_strategy == 'qa':
+            return self._chunk_by_qa_optimization(content, filename, file_type)
         else:
             # Fallback to sentence-based chunking
             return self._chunk_by_sentences(content, filename, file_type)
@@ -674,7 +693,7 @@ class DocumentProcessor:
         chunk_index = 0
         
         # Create overlapping chunks
-        for i in range(0, len(words), self.chunk_size - self.overlap_size):
+        for i in range(0, len(words), self.chunk_size - self.chunk_overlap):
             chunk_words = words[i:i + self.chunk_size]
             if chunk_words:
                 chunk_content = ' '.join(chunk_words)
@@ -686,7 +705,7 @@ class DocumentProcessor:
                         'chunk_method': 'sliding_window',
                         'chunk_index': chunk_index,
                         'chunk_size_words': self.chunk_size,
-                        'overlap_size_words': self.overlap_size,
+                        'overlap_size_words': self.chunk_overlap,
                         'start_word': i,
                         'end_word': i + len(chunk_words)
                     }
@@ -761,4 +780,246 @@ class DocumentProcessor:
                     }
                 ))
         
-        return chunks 
+        return chunks
+    
+    def _chunk_by_semantic(self, content: str, filename: str, file_type: str) -> List[Dict[str, Any]]:
+        """Chunk based on semantic similarity between sentences"""
+        if isinstance(content, list):
+            content = '\n'.join(content)
+        
+        # Get sentences
+        if sent_tokenize:
+            sentences = sent_tokenize(content)
+        else:
+            sentences = content.split('. ')
+            sentences = [s.strip() + '.' for s in sentences if s.strip()]
+        
+        if len(sentences) <= 1:
+            return [self._create_chunk(content, filename, "Section 1", 
+                                     metadata={'chunk_method': 'semantic', 'chunk_index': 0})]
+        
+        # Generate embeddings for sentences (using the same model as the index)
+        try:
+            from sentence_transformers import SentenceTransformer
+            from sklearn.metrics.pairwise import cosine_similarity
+            import numpy as np
+            
+            model = SentenceTransformer('sentence-transformers/all-mpnet-base-v2')
+            embeddings = model.encode(sentences, show_progress_bar=False)
+            
+            # Calculate similarity between adjacent sentences
+            similarities = []
+            for i in range(len(embeddings) - 1):
+                sim = cosine_similarity([embeddings[i]], [embeddings[i + 1]])[0][0]
+                similarities.append(sim)
+            
+            # Find split points where similarity drops below threshold
+            split_points = [0]
+            for i, sim in enumerate(similarities):
+                if sim < self.semantic_threshold:
+                    split_points.append(i + 1)
+            split_points.append(len(sentences))
+            
+            # Create chunks
+            chunks = []
+            for i in range(len(split_points) - 1):
+                start_idx = split_points[i]
+                end_idx = split_points[i + 1]
+                chunk_sentences = sentences[start_idx:end_idx]
+                
+                # Ensure minimum chunk size
+                if len(chunk_sentences) < 2 and i > 0:
+                    # Merge with previous chunk
+                    chunks[-1]['content'] += ' ' + ' '.join(chunk_sentences)
+                    continue
+                    
+                chunk_content = ' '.join(chunk_sentences)
+                chunks.append(self._create_chunk(
+                    content=chunk_content,
+                    filename=filename,
+                    section=f"Semantic Section {i+1}",
+                    metadata={
+                        'chunk_method': 'semantic',
+                        'chunk_index': i,
+                        'semantic_threshold': self.semantic_threshold,
+                        'sentence_count': len(chunk_sentences)
+                    }
+                ))
+            
+            return chunks if chunks else [self._create_chunk(content, filename, "Section 1",
+                                                           metadata={'chunk_method': 'semantic', 'chunk_index': 0})]
+            
+        except ImportError:
+            # Fallback to sentence-based chunking
+            return self._chunk_by_sentences(content, filename, file_type)
+
+    def _chunk_by_topics(self, content: str, filename: str, file_type: str) -> List[Dict[str, Any]]:
+        """Chunk based on topic changes using keyword analysis"""
+        if isinstance(content, list):
+            content = '\n'.join(content)
+        
+        if sent_tokenize:
+            sentences = sent_tokenize(content)
+        else:
+            sentences = content.split('. ')
+            sentences = [s.strip() + '.' for s in sentences if s.strip()]
+            
+        if len(sentences) <= 3:
+            return [self._create_chunk(content, filename, "Topic 1",
+                                     metadata={'chunk_method': 'topic', 'chunk_index': 0})]
+        
+        try:
+            # Simple topic detection using keyword overlap
+            from collections import Counter
+            import re
+            
+            # Extract keywords from each sentence
+            sentence_keywords = []
+            for sentence in sentences:
+                # Simple keyword extraction (could be enhanced with NLP)
+                words = re.findall(r'\b[a-zA-Z]{3,}\b', sentence.lower())
+                # Filter common words (basic stopwords)
+                stopwords = {'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'had', 'her', 'was', 'one', 'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'its', 'may', 'new', 'now', 'old', 'see', 'two', 'who', 'boy', 'did', 'man', 'way', 'she', 'use', 'her', 'many', 'oil', 'sit', 'set', 'run', 'eat', 'far', 'sea', 'eye', 'ask', 'own', 'say', 'too', 'any', 'try', 'us', 'an', 'as', 'at', 'be', 'he', 'if', 'in', 'is', 'it', 'my', 'of', 'on', 'or', 'to', 'up', 'we', 'go', 'no', 'so', 'am', 'by', 'do', 'me'}
+                keywords = [w for w in words if w not in stopwords and len(w) > 3]
+                sentence_keywords.append(set(keywords))
+            
+            # Find topic boundaries based on keyword overlap
+            chunks = []
+            current_chunk = [sentences[0]]
+            current_keywords = sentence_keywords[0]
+            
+            for i in range(1, len(sentences)):
+                # Calculate keyword overlap with current chunk
+                overlap = len(current_keywords.intersection(sentence_keywords[i]))
+                total_keywords = len(current_keywords.union(sentence_keywords[i]))
+                
+                if total_keywords > 0:
+                    similarity = overlap / total_keywords
+                else:
+                    similarity = 0
+                
+                # If similarity is low, start new chunk
+                if similarity < self.topic_threshold and len(current_chunk) >= 2:
+                    chunk_content = ' '.join(current_chunk)
+                    chunks.append(self._create_chunk(
+                        content=chunk_content,
+                        filename=filename,
+                        section=f"Topic {len(chunks)+1}",
+                        metadata={
+                            'chunk_method': 'topic',
+                            'chunk_index': len(chunks),
+                            'topic_keywords': list(current_keywords)[:10],  # Top keywords
+                            'sentence_count': len(current_chunk),
+                            'topic_threshold': self.topic_threshold
+                        }
+                    ))
+                    current_chunk = [sentences[i]]
+                    current_keywords = sentence_keywords[i]
+                else:
+                    current_chunk.append(sentences[i])
+                    current_keywords = current_keywords.union(sentence_keywords[i])
+            
+            # Add final chunk
+            if current_chunk:
+                chunk_content = ' '.join(current_chunk)
+                chunks.append(self._create_chunk(
+                    content=chunk_content,
+                    filename=filename,
+                    section=f"Topic {len(chunks)+1}",
+                    metadata={
+                        'chunk_method': 'topic',
+                        'chunk_index': len(chunks),
+                        'topic_keywords': list(current_keywords)[:10],
+                        'sentence_count': len(current_chunk),
+                        'topic_threshold': self.topic_threshold
+                    }
+                ))
+            
+            return chunks if chunks else [self._create_chunk(content, filename, "Topic 1",
+                                                           metadata={'chunk_method': 'topic', 'chunk_index': 0})]
+            
+        except Exception:
+            # Fallback to sentence-based chunking
+            return self._chunk_by_sentences(content, filename, file_type)
+
+    def _chunk_by_qa_optimization(self, content: str, filename: str, file_type: str) -> List[Dict[str, Any]]:
+        """Create chunks optimized for question-answering"""
+        if isinstance(content, list):
+            content = '\n'.join(content)
+        
+        if sent_tokenize:
+            sentences = sent_tokenize(content)
+        else:
+            sentences = content.split('. ')
+            sentences = [s.strip() + '.' for s in sentences if s.strip()]
+        
+        # Patterns that indicate Q&A structure
+        question_patterns = [
+            r'\?',  # Questions
+            r'^(what|how|why|when|where|who|which|can|does|is|are|will|would|should)',
+            r'(step|steps|process|procedure|method|way to)',
+            r'(example|examples|instance|case)',
+            r'(definition|meaning|refers to|means)',
+        ]
+        
+        chunks = []
+        current_chunk = []
+        current_context = []
+        
+        for i, sentence in enumerate(sentences):
+            sentence_lower = sentence.lower().strip()
+            
+            # Check if this sentence contains Q&A indicators
+            is_qa_relevant = any(re.search(pattern, sentence_lower) for pattern in question_patterns)
+            
+            if is_qa_relevant or len(current_chunk) == 0:
+                current_chunk.append(sentence)
+                # Add surrounding context (previous and next sentences)
+                if i > 0 and sentences[i-1] not in current_chunk:
+                    current_context.append(sentences[i-1])
+                if i < len(sentences) - 1:
+                    current_context.append(sentences[i+1])
+            else:
+                current_chunk.append(sentence)
+            
+            # Create chunk when we have enough content or reach a natural break
+            if (len(current_chunk) >= 3 and 
+                (i == len(sentences) - 1 or  # Last sentence
+                 sentence.endswith('.') and len(current_chunk) >= 5)):  # Natural break
+                
+                # Combine chunk with context
+                full_content = current_context + current_chunk
+                chunk_content = ' '.join(full_content)
+                
+                chunks.append(self._create_chunk(
+                    content=chunk_content,
+                    filename=filename,
+                    section=f"QA Section {len(chunks)+1}",
+                    metadata={
+                        'chunk_method': 'qa_optimized',
+                        'chunk_index': len(chunks),
+                        'has_question': any('?' in s for s in current_chunk),
+                        'has_process': any(re.search(r'(step|process|method)', s.lower()) for s in current_chunk),
+                        'sentence_count': len(full_content)
+                    }
+                ))
+                
+                current_chunk = []
+                current_context = []
+        
+        # Handle remaining content
+        if current_chunk:
+            chunk_content = ' '.join(current_context + current_chunk)
+            chunks.append(self._create_chunk(
+                content=chunk_content,
+                filename=filename,
+                section=f"QA Section {len(chunks)+1}",
+                metadata={
+                    'chunk_method': 'qa_optimized',
+                    'chunk_index': len(chunks),
+                    'sentence_count': len(current_context + current_chunk)
+                }
+            ))
+        
+        return chunks if chunks else [self._create_chunk(content, filename, "QA Section 1",
+                                                       metadata={'chunk_method': 'qa_optimized', 'chunk_index': 0})]