agno 2.3.22__py3-none-any.whl → 2.3.24__py3-none-any.whl

agno/db/sqlite/schemas.py

@@ -111,25 +111,36 @@ TRACE_TABLE_SCHEMA = {
     "created_at": {"type": String, "nullable": False, "index": True},  # ISO 8601 datetime string
 }
 
-SPAN_TABLE_SCHEMA = {
-    "span_id": {"type": String, "primary_key": True, "nullable": False},
-    "trace_id": {
-        "type": String,
-        "nullable": False,
-        "index": True,
-        "foreign_key": "agno_traces.trace_id",  # Foreign key to traces table
-    },
-    "parent_span_id": {"type": String, "nullable": True, "index": True},
-    "name": {"type": String, "nullable": False},
-    "span_kind": {"type": String, "nullable": False},
-    "status_code": {"type": String, "nullable": False},
-    "status_message": {"type": String, "nullable": True},
-    "start_time": {"type": String, "nullable": False, "index": True},  # ISO 8601 datetime string
-    "end_time": {"type": String, "nullable": False},  # ISO 8601 datetime string
-    "duration_ms": {"type": BigInteger, "nullable": False},
-    "attributes": {"type": JSON, "nullable": True},
-    "created_at": {"type": String, "nullable": False, "index": True},  # ISO 8601 datetime string
-}
+
+def _get_span_table_schema(traces_table_name: str = "agno_traces") -> dict[str, Any]:
+    """Get the span table schema with the correct foreign key reference.
+
+    Args:
+        traces_table_name: The name of the traces table to reference in the foreign key.
+
+    Returns:
+        The span table schema dictionary.
+    """
+    return {
+        "span_id": {"type": String, "primary_key": True, "nullable": False},
+        "trace_id": {
+            "type": String,
+            "nullable": False,
+            "index": True,
+            "foreign_key": f"{traces_table_name}.trace_id",
+        },
+        "parent_span_id": {"type": String, "nullable": True, "index": True},
+        "name": {"type": String, "nullable": False},
+        "span_kind": {"type": String, "nullable": False},
+        "status_code": {"type": String, "nullable": False},
+        "status_message": {"type": String, "nullable": True},
+        "start_time": {"type": String, "nullable": False, "index": True},  # ISO 8601 datetime string
+        "end_time": {"type": String, "nullable": False},  # ISO 8601 datetime string
+        "duration_ms": {"type": BigInteger, "nullable": False},
+        "attributes": {"type": JSON, "nullable": True},
+        "created_at": {"type": String, "nullable": False, "index": True},  # ISO 8601 datetime string
+    }
+
 
 CULTURAL_KNOWLEDGE_TABLE_SCHEMA = {
     "id": {"type": String, "primary_key": True, "nullable": False},
@@ -152,16 +163,21 @@ VERSIONS_TABLE_SCHEMA = {
 }
 
 
-def get_table_schema_definition(table_type: str) -> dict[str, Any]:
+def get_table_schema_definition(table_type: str, traces_table_name: str = "agno_traces") -> dict[str, Any]:
     """
     Get the expected schema definition for the given table.
 
     Args:
         table_type (str): The type of table to get the schema for.
+        traces_table_name (str): The name of the traces table (used for spans foreign key).
 
     Returns:
         Dict[str, Any]: Dictionary containing column definitions for the table
     """
+    # Handle spans table specially to resolve the foreign key reference
+    if table_type == "spans":
+        return _get_span_table_schema(traces_table_name)
+
     schemas = {
         "sessions": SESSION_TABLE_SCHEMA,
         "evals": EVAL_TABLE_SCHEMA,
@@ -169,7 +185,6 @@ def get_table_schema_definition(table_type: str) -> dict[str, Any]:
         "memories": USER_MEMORY_TABLE_SCHEMA,
         "knowledge": KNOWLEDGE_TABLE_SCHEMA,
         "traces": TRACE_TABLE_SCHEMA,
-        "spans": SPAN_TABLE_SCHEMA,
         "culture": CULTURAL_KNOWLEDGE_TABLE_SCHEMA,
         "versions": VERSIONS_TABLE_SCHEMA,
     }

agno/db/sqlite/sqlite.py

@@ -173,7 +173,8 @@ class SqliteDb(BaseDb):
             Table: SQLAlchemy Table object
         """
         try:
-            table_schema = get_table_schema_definition(table_type).copy()
+            # Pass traces_table_name for spans table foreign key resolution
+            table_schema = get_table_schema_definition(table_type, traces_table_name=self.trace_table_name).copy()
 
             columns: List[Column] = []
             indexes: List[str] = []
@@ -197,12 +198,7 @@ class SqliteDb(BaseDb):
 
                 # Handle foreign key constraint
                 if "foreign_key" in col_config:
-                    fk_ref = col_config["foreign_key"]
-                    # For spans table, dynamically replace the traces table reference
-                    # with the actual trace table name configured for this db instance
-                    if table_type == "spans" and "trace_id" in fk_ref:
-                        fk_ref = f"{self.trace_table_name}.trace_id"
-                    column_args.append(ForeignKey(fk_ref))
+                    column_args.append(ForeignKey(col_config["foreign_key"]))
 
                 columns.append(Column(*column_args, **column_kwargs))  # type: ignore
 

agno/knowledge/chunking/markdown.py

@@ -1,6 +1,7 @@
 import os
+import re
 import tempfile
-from typing import List
+from typing import List, Union
 
 try:
     from unstructured.chunking.title import chunk_by_title  # type: ignore
@@ -13,17 +14,83 @@ from agno.knowledge.document.base import Document
 
 
 class MarkdownChunking(ChunkingStrategy):
-    """A chunking strategy that splits markdown based on structure like headers, paragraphs and sections"""
-
-    def __init__(self, chunk_size: int = 5000, overlap: int = 0):
+    """A chunking strategy that splits markdown based on structure like headers, paragraphs and sections
+
+    Args:
+        chunk_size: Maximum size of each chunk in characters
+        overlap: Number of characters to overlap between chunks
+        split_on_headings: Controls heading-based splitting behavior:
+            - False: Use size-based chunking (default)
+            - True: Split on all headings (H1-H6)
+            - int: Split on headings at or above this level (1-6)
+                  e.g., 2 splits on H1 and H2, keeping H3-H6 content together
+    """
+
+    def __init__(self, chunk_size: int = 5000, overlap: int = 0, split_on_headings: Union[bool, int] = False):
         self.chunk_size = chunk_size
         self.overlap = overlap
+        self.split_on_headings = split_on_headings
+
+        # Validate split_on_headings parameter
+        # Note: In Python, isinstance(False, int) is True, so we exclude booleans explicitly
+        if isinstance(split_on_headings, int) and not isinstance(split_on_headings, bool):
+            if not (1 <= split_on_headings <= 6):
+                raise ValueError("split_on_headings must be between 1 and 6 when using integer value")
+
+    def _split_by_headings(self, content: str) -> List[str]:
+        """
+        Split markdown content by headings, keeping each heading with its content.
+        Returns a list of sections where each section starts with a heading.
+
+        When split_on_headings is an int, only splits on headings at or above that level.
+        For example, split_on_headings=2 splits on H1 and H2, keeping H3-H6 content together.
+        """
+        # Determine which heading levels to split on
+        if isinstance(self.split_on_headings, int) and not isinstance(self.split_on_headings, bool):
+            # Split on headings at or above this level (1 to split_on_headings)
+            max_heading_level = self.split_on_headings
+            heading_pattern = rf"^#{{{1},{max_heading_level}}}\s+.+$"
+        else:
+            # split_on_headings is True: split on all headings (# to ######)
+            heading_pattern = r"^#{1,6}\s+.+$"
+
+        # Split content while keeping the delimiter (heading)
+        # Use non-capturing group for the pattern to avoid extra capture groups
+        parts = re.split(f"({heading_pattern})", content, flags=re.MULTILINE)
+
+        sections = []
+        current_section = ""
+
+        for part in parts:
+            if not part or not part.strip():
+                continue
+
+            # Check if this part is a heading
+            if re.match(heading_pattern, part.strip(), re.MULTILINE):
+                # Save previous section if exists
+                if current_section.strip():
+                    sections.append(current_section.strip())
+                # Start new section with this heading
+                current_section = part
+            else:
+                # Add content to current section
+                current_section += "\n\n" + part if current_section else part
+
+        # Don't forget the last section
+        if current_section.strip():
+            sections.append(current_section.strip())
+
+        return sections if sections else [content]
 
     def _partition_markdown_content(self, content: str) -> List[str]:
         """
         Partition markdown content and return a list of text chunks.
         Falls back to paragraph splitting if the markdown chunking fails.
         """
+        # When split_on_headings is True or an int, use regex-based splitting to preserve headings
+        if self.split_on_headings:
+            return self._split_by_headings(content)
+
         try:
             # Create a temporary file with the markdown content.
             # This is the recommended usage of the unstructured library.
@@ -38,7 +105,6 @@ class MarkdownChunking(ChunkingStrategy):
                     raw_paragraphs = content.split("\n\n")
                     return [self.clean_text(para) for para in raw_paragraphs]
 
-                # Chunk by title with some default values
                 chunked_elements = chunk_by_title(
                     elements=elements,
                     max_characters=self.chunk_size,
@@ -74,7 +140,13 @@ class MarkdownChunking(ChunkingStrategy):
 
     def chunk(self, document: Document) -> List[Document]:
         """Split markdown document into chunks based on markdown structure"""
-        if not document.content or len(document.content) <= self.chunk_size:
+        # If content is empty, return as-is
+        if not document.content:
+            return [document]
+
+        # When split_on_headings is enabled, always split by headings regardless of size
+        # Only skip chunking for small content when using size-based chunking
+        if not self.split_on_headings and len(document.content) <= self.chunk_size:
             return [document]
 
         # Split using markdown chunking logic, or fallback to paragraphs
@@ -90,7 +162,20 @@ class MarkdownChunking(ChunkingStrategy):
             section = section.strip()
             section_size = len(section)
 
-            if current_size + section_size <= self.chunk_size:
+            # When split_on_headings is True or an int, each section becomes its own chunk
+            if self.split_on_headings:
+                meta_data = chunk_meta_data.copy()
+                meta_data["chunk"] = chunk_number
+                chunk_id = None
+                if document.id:
+                    chunk_id = f"{document.id}_{chunk_number}"
+                elif document.name:
+                    chunk_id = f"{document.name}_{chunk_number}"
+                meta_data["chunk_size"] = section_size
+
+                chunks.append(Document(id=chunk_id, name=document.name, meta_data=meta_data, content=section))
+                chunk_number += 1
+            elif current_size + section_size <= self.chunk_size:
                 current_chunk.append(section)
                 current_size += section_size
             else:
@@ -114,7 +199,8 @@ class MarkdownChunking(ChunkingStrategy):
                 current_chunk = [section]
                 current_size = section_size
 
-        if current_chunk:
+        # Handle remaining content (only when not split_on_headings)
+        if current_chunk and not self.split_on_headings:
             meta_data = chunk_meta_data.copy()
             meta_data["chunk"] = chunk_number
             chunk_id = None

agno/knowledge/chunking/semantic.py

@@ -17,7 +17,7 @@ except ImportError:
 from agno.knowledge.chunking.strategy import ChunkingStrategy
 from agno.knowledge.document.base import Document
 from agno.knowledge.embedder.base import Embedder
-from agno.utils.log import log_info
+from agno.utils.log import log_debug
 
 
 def _get_chonkie_embedder_wrapper(embedder: Embedder):
@@ -87,7 +87,7 @@ class SemanticChunking(ChunkingStrategy):
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
             embedder = OpenAIEmbedder()  # type: ignore
-            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+            log_debug("Embedder not provided, using OpenAIEmbedder as default.")
         self.embedder = embedder
         self.chunk_size = chunk_size
         self.similarity_threshold = similarity_threshold