agno 2.0.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/knowledge/chunking/agentic.py

@@ -1,28 +1,31 @@
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from agno.knowledge.chunking.strategy import ChunkingStrategy
 from agno.knowledge.document.base import Document
 from agno.models.base import Model
 from agno.models.defaults import DEFAULT_OPENAI_MODEL_ID
 from agno.models.message import Message
+from agno.models.utils import get_model
 
 
 class AgenticChunking(ChunkingStrategy):
     """Chunking strategy that uses an LLM to determine natural breakpoints in the text"""
 
-    def __init__(self, model: Optional[Model] = None, max_chunk_size: int = 5000):
+    def __init__(self, model: Optional[Union[Model, str]] = None, max_chunk_size: int = 5000):
+        # Convert model string to Model instance
+        model = get_model(model)
         if model is None:
             try:
                 from agno.models.openai import OpenAIChat
             except Exception:
                 raise ValueError("`openai` isn't installed. Please install it with `pip install openai`")
             model = OpenAIChat(DEFAULT_OPENAI_MODEL_ID)
-        self.max_chunk_size = max_chunk_size
+        self.chunk_size = max_chunk_size
         self.model = model
 
     def chunk(self, document: Document) -> List[Document]:
         """Split text into chunks using LLM to determine natural breakpoints based on context"""
-        if len(document.content) <= self.max_chunk_size:
+        if len(document.content) <= self.chunk_size:
             return [document]
 
         chunks: List[Document] = []
@@ -31,22 +34,22 @@ class AgenticChunking(ChunkingStrategy):
         chunk_number = 1
 
         while remaining_text:
-            # Ask model to find a good breakpoint within max_chunk_size
-            prompt = f"""Analyze this text and determine a natural breakpoint within the first {self.max_chunk_size} characters.
+            # Ask model to find a good breakpoint within chunk_size
+            prompt = f"""Analyze this text and determine a natural breakpoint within the first {self.chunk_size} characters.
             Consider semantic completeness, paragraph boundaries, and topic transitions.
             Return only the character position number of where to break the text:
 
-            {remaining_text[: self.max_chunk_size]}"""
+            {remaining_text[: self.chunk_size]}"""
 
             try:
                 response = self.model.response([Message(role="user", content=prompt)])
                 if response and response.content:
-                    break_point = min(int(response.content.strip()), self.max_chunk_size)
+                    break_point = min(int(response.content.strip()), self.chunk_size)
                 else:
-                    break_point = self.max_chunk_size
+                    break_point = self.chunk_size
             except Exception:
                 # Fallback to max size if model fails
-                break_point = self.max_chunk_size
+                break_point = self.chunk_size
 
             # Extract chunk and update remaining text
             chunk = remaining_text[:break_point].strip()

agno/knowledge/chunking/fixed.py

@@ -7,7 +7,7 @@ from agno.knowledge.document.base import Document
 class FixedSizeChunking(ChunkingStrategy):
     """Chunking strategy that splits text into fixed-size chunks with optional overlap"""
 
-    def __init__(self, chunk_size: int = 100, overlap: int = 0):
+    def __init__(self, chunk_size: int = 5000, overlap: int = 0):
         # overlap must be less than chunk size
         if overlap >= chunk_size:
             raise ValueError(f"Invalid parameters: overlap ({overlap}) must be less than chunk size ({chunk_size}).")

agno/knowledge/chunking/semantic.py

@@ -1,16 +1,22 @@
-from typing import List, Optional
+import inspect
+from typing import Any, Dict, List, Optional
 
 from agno.knowledge.chunking.strategy import ChunkingStrategy
 from agno.knowledge.document.base import Document
 from agno.knowledge.embedder.base import Embedder
-from agno.knowledge.embedder.openai import OpenAIEmbedder
+from agno.utils.log import log_info
 
 
 class SemanticChunking(ChunkingStrategy):
     """Chunking strategy that splits text into semantic chunks using chonkie"""
 
     def __init__(self, embedder: Optional[Embedder] = None, chunk_size: int = 5000, similarity_threshold: float = 0.5):
-        self.embedder = embedder or OpenAIEmbedder(id="text-embedding-3-small")  # type: ignore
+        if embedder is None:
+            from agno.knowledge.embedder.openai import OpenAIEmbedder
+
+            embedder = OpenAIEmbedder()  # type: ignore
+            log_info("Embedder not provided, using OpenAIEmbedder as default.")
+        self.embedder = embedder
         self.chunk_size = chunk_size
         self.similarity_threshold = similarity_threshold
         self.chunker = None  # Will be initialized lazily when needed
@@ -26,11 +32,37 @@ class SemanticChunking(ChunkingStrategy):
                     "Please install it using `pip install chonkie` to use SemanticChunking."
                 )
 
-            self.chunker = SemanticChunker(
-                embedding_model=self.embedder.id,  # type: ignore
-                chunk_size=self.chunk_size,
-                threshold=self.similarity_threshold,
-            )
+            # Build arguments dynamically based on chonkie's supported signature
+            params: Dict[str, Any] = {
+                "chunk_size": self.chunk_size,
+                "threshold": self.similarity_threshold,
+            }
+
+            try:
+                sig = inspect.signature(SemanticChunker)
+                param_names = set(sig.parameters.keys())
+
+                # Prefer passing a callable to avoid Chonkie initializing its own client
+                if "embedding_fn" in param_names:
+                    params["embedding_fn"] = self.embedder.get_embedding  # type: ignore[attr-defined]
+                    # If chonkie allows specifying dimensions, provide them
+                    if "embedding_dimensions" in param_names and getattr(self.embedder, "dimensions", None):
+                        params["embedding_dimensions"] = self.embedder.dimensions  # type: ignore[attr-defined]
+                elif "embedder" in param_names:
+                    # Some versions may accept an embedder object directly
+                    params["embedder"] = self.embedder
+                else:
+                    # Fallback to model id
+                    params["embedding_model"] = getattr(self.embedder, "id", None) or "text-embedding-3-small"
+
+                self.chunker = SemanticChunker(**params)
+            except Exception:
+                # As a final fallback, use the original behavior
+                self.chunker = SemanticChunker(
+                    embedding_model=getattr(self.embedder, "id", None) or "text-embedding-3-small",
+                    chunk_size=self.chunk_size,
+                    threshold=self.similarity_threshold,
+                )
 
     def chunk(self, document: Document) -> List[Document]:
         """Split document into semantic chunks using chonkie"""

agno/knowledge/chunking/strategy.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import List
+from typing import List, Optional
 
 from agno.knowledge.document.base import Document
 
@@ -60,7 +60,13 @@ class ChunkingStrategyFactory:
     """Factory for creating chunking strategy instances."""
 
     @classmethod
-    def create_strategy(cls, strategy_type: ChunkingStrategyType, **kwargs) -> ChunkingStrategy:
+    def create_strategy(
+        cls,
+        strategy_type: ChunkingStrategyType,
+        chunk_size: Optional[int] = None,
+        overlap: Optional[int] = None,
+        **kwargs,
+    ) -> ChunkingStrategy:
         """Create an instance of the chunking strategy with the given parameters."""
         strategy_map = {
             ChunkingStrategyType.AGENTIC_CHUNKER: cls._create_agentic_chunking,
@@ -71,51 +77,89 @@ class ChunkingStrategyFactory:
             ChunkingStrategyType.ROW_CHUNKER: cls._create_row_chunking,
             ChunkingStrategyType.MARKDOWN_CHUNKER: cls._create_markdown_chunking,
         }
-        return strategy_map[strategy_type](**kwargs)
+        return strategy_map[strategy_type](chunk_size=chunk_size, overlap=overlap, **kwargs)
 
     @classmethod
-    def _create_agentic_chunking(cls, **kwargs) -> ChunkingStrategy:
+    def _create_agentic_chunking(
+        cls, chunk_size: Optional[int] = None, overlap: Optional[int] = None, **kwargs
+    ) -> ChunkingStrategy:
         from agno.knowledge.chunking.agentic import AgenticChunking
 
-        # Map chunk_size to max_chunk_size for AgenticChunking
-        if "chunk_size" in kwargs and "max_chunk_size" not in kwargs:
-            kwargs["max_chunk_size"] = kwargs.pop("chunk_size")
+        # AgenticChunking accepts max_chunk_size (not chunk_size) and no overlap
+        if chunk_size is not None:
+            kwargs["max_chunk_size"] = chunk_size
+        # Remove overlap since AgenticChunking doesn't support it
         return AgenticChunking(**kwargs)
 
     @classmethod
-    def _create_document_chunking(cls, **kwargs) -> ChunkingStrategy:
+    def _create_document_chunking(
+        cls, chunk_size: Optional[int] = None, overlap: Optional[int] = None, **kwargs
+    ) -> ChunkingStrategy:
         from agno.knowledge.chunking.document import DocumentChunking
 
+        # DocumentChunking accepts both chunk_size and overlap
+        if chunk_size is not None:
+            kwargs["chunk_size"] = chunk_size
+        if overlap is not None:
+            kwargs["overlap"] = overlap
         return DocumentChunking(**kwargs)
 
     @classmethod
-    def _create_recursive_chunking(cls, **kwargs) -> ChunkingStrategy:
+    def _create_recursive_chunking(
+        cls, chunk_size: Optional[int] = None, overlap: Optional[int] = None, **kwargs
+    ) -> ChunkingStrategy:
         from agno.knowledge.chunking.recursive import RecursiveChunking
 
+        # RecursiveChunking accepts both chunk_size and overlap
+        if chunk_size is not None:
+            kwargs["chunk_size"] = chunk_size
+        if overlap is not None:
+            kwargs["overlap"] = overlap
         return RecursiveChunking(**kwargs)
 
     @classmethod
-    def _create_semantic_chunking(cls, **kwargs) -> ChunkingStrategy:
+    def _create_semantic_chunking(
+        cls, chunk_size: Optional[int] = None, overlap: Optional[int] = None, **kwargs
+    ) -> ChunkingStrategy:
         from agno.knowledge.chunking.semantic import SemanticChunking
 
+        # SemanticChunking accepts chunk_size but not overlap
+        if chunk_size is not None:
+            kwargs["chunk_size"] = chunk_size
+        # Remove overlap since SemanticChunking doesn't support it
         return SemanticChunking(**kwargs)
 
     @classmethod
-    def _create_fixed_chunking(cls, **kwargs) -> ChunkingStrategy:
+    def _create_fixed_chunking(
+        cls, chunk_size: Optional[int] = None, overlap: Optional[int] = None, **kwargs
+    ) -> ChunkingStrategy:
         from agno.knowledge.chunking.fixed import FixedSizeChunking
 
+        # FixedSizeChunking accepts both chunk_size and overlap
+        if chunk_size is not None:
+            kwargs["chunk_size"] = chunk_size
+        if overlap is not None:
+            kwargs["overlap"] = overlap
         return FixedSizeChunking(**kwargs)
 
     @classmethod
-    def _create_row_chunking(cls, **kwargs) -> ChunkingStrategy:
+    def _create_row_chunking(
+        cls, chunk_size: Optional[int] = None, overlap: Optional[int] = None, **kwargs
+    ) -> ChunkingStrategy:
         from agno.knowledge.chunking.row import RowChunking
 
-        # Remove chunk_size if present since RowChunking doesn't use it
-        kwargs.pop("chunk_size", None)
+        # RowChunking doesn't accept chunk_size or overlap, only skip_header and clean_rows
         return RowChunking(**kwargs)
 
     @classmethod
-    def _create_markdown_chunking(cls, **kwargs) -> ChunkingStrategy:
+    def _create_markdown_chunking(
+        cls, chunk_size: Optional[int] = None, overlap: Optional[int] = None, **kwargs
+    ) -> ChunkingStrategy:
         from agno.knowledge.chunking.markdown import MarkdownChunking
 
+        # MarkdownChunking accepts both chunk_size and overlap
+        if chunk_size is not None:
+            kwargs["chunk_size"] = chunk_size
+        if overlap is not None:
+            kwargs["overlap"] = overlap
         return MarkdownChunking(**kwargs)

agno/knowledge/embedder/aws_bedrock.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from agno.exceptions import AgnoError, ModelProviderError
 from agno.knowledge.embedder.base import Embedder
-from agno.utils.log import log_error, logger
+from agno.utils.log import log_error, log_warning
 
 try:
     from boto3 import client as AwsClient
@@ -69,6 +69,11 @@ class AwsBedrockEmbedder(Embedder):
     client_params: Optional[Dict[str, Any]] = None
     client: Optional[AwsClient] = None
 
+    def __post_init__(self):
+        if self.enable_batch:
+            log_warning("AwsBedrockEmbedder does not support batch embeddings, setting enable_batch to False")
+            self.enable_batch = False
+
     def get_client(self) -> AwsClient:
         """
         Returns an AWS Bedrock client.
@@ -220,10 +225,10 @@ class AwsBedrockEmbedder(Embedder):
                     # Fallback to the first available embedding type
                     for embedding_type in response["embeddings"]:
                         return response["embeddings"][embedding_type][0]
-            logger.warning("No embeddings found in response")
+            log_warning("No embeddings found in response")
             return []
         except Exception as e:
-            logger.warning(f"Error extracting embeddings: {e}")
+            log_warning(f"Error extracting embeddings: {e}")
             return []
 
     def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict[str, Any]]]:
@@ -286,7 +291,7 @@ class AwsBedrockEmbedder(Embedder):
                         # Fallback to the first available embedding type
                         for embedding_type in response_body["embeddings"]:
                             return response_body["embeddings"][embedding_type][0]
-                logger.warning("No embeddings found in response")
+                log_warning("No embeddings found in response")
                 return []
         except ClientError as e:
             log_error(f"Unexpected error calling Bedrock API: {str(e)}")

agno/knowledge/embedder/azure_openai.py

@@ -154,3 +154,57 @@ class AzureOpenAIEmbedder(Embedder):
         embedding = response.data[0].embedding
         usage = response.usage
         return embedding, usage.model_dump()
+
+    async def async_get_embeddings_batch_and_usage(
+        self, texts: List[str]
+    ) -> Tuple[List[List[float]], List[Optional[Dict]]]:
+        """
+        Get embeddings and usage for multiple texts in batches.
+
+        Args:
+            texts: List of text strings to embed
+
+        Returns:
+            Tuple of (List of embedding vectors, List of usage dictionaries)
+        """
+        all_embeddings = []
+        all_usage = []
+        logger.info(f"Getting embeddings and usage for {len(texts)} texts in batches of {self.batch_size}")
+
+        for i in range(0, len(texts), self.batch_size):
+            batch_texts = texts[i : i + self.batch_size]
+
+            req: Dict[str, Any] = {
+                "input": batch_texts,
+                "model": self.id,
+                "encoding_format": self.encoding_format,
+            }
+            if self.user is not None:
+                req["user"] = self.user
+            if self.id.startswith("text-embedding-3"):
+                req["dimensions"] = self.dimensions
+            if self.request_params:
+                req.update(self.request_params)
+
+            try:
+                response: CreateEmbeddingResponse = await self.aclient.embeddings.create(**req)
+                batch_embeddings = [data.embedding for data in response.data]
+                all_embeddings.extend(batch_embeddings)
+
+                # For each embedding in the batch, add the same usage information
+                usage_dict = response.usage.model_dump() if response.usage else None
+                all_usage.extend([usage_dict] * len(batch_embeddings))
+            except Exception as e:
+                logger.warning(f"Error in async batch embedding: {e}")
+                # Fallback to individual calls for this batch
+                for text in batch_texts:
+                    try:
+                        embedding, usage = await self.async_get_embedding_and_usage(text)
+                        all_embeddings.append(embedding)
+                        all_usage.append(usage)
+                    except Exception as e2:
+                        logger.warning(f"Error in individual async embedding fallback: {e2}")
+                        all_embeddings.append([])
+                        all_usage.append(None)
+
+        return all_embeddings, all_usage

agno/knowledge/embedder/base.py

@@ -7,6 +7,8 @@ class Embedder:
     """Base class for managing embedders"""
 
     dimensions: Optional[int] = 1536
+    enable_batch: bool = False
+    batch_size: int = 100  # Number of texts to process in each API call
 
     def get_embedding(self, text: str) -> List[float]:
         raise NotImplementedError

agno/knowledge/embedder/cohere.py

@@ -1,8 +1,9 @@
+import time
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from agno.knowledge.embedder.base import Embedder
-from agno.utils.log import logger
+from agno.utils.log import log_debug, log_error, log_info, log_warning
 
 try:
     from cohere import AsyncClient as AsyncCohereClient
@@ -22,6 +23,7 @@ class CohereEmbedder(Embedder):
     client_params: Optional[Dict[str, Any]] = None
     cohere_client: Optional[CohereClient] = None
     async_client: Optional[AsyncCohereClient] = None
+    exponential_backoff: bool = False  # Enable exponential backoff on rate limits
 
     @property
     def client(self) -> CohereClient:
@@ -61,6 +63,111 @@ class CohereEmbedder(Embedder):
             request_params.update(self.request_params)
         return self.client.embed(texts=[text], **request_params)
 
+    def _get_batch_request_params(self) -> Dict[str, Any]:
+        """Get request parameters for batch embedding calls."""
+        request_params: Dict[str, Any] = {}
+
+        if self.id:
+            request_params["model"] = self.id
+        if self.input_type:
+            request_params["input_type"] = self.input_type
+        if self.embedding_types:
+            request_params["embedding_types"] = self.embedding_types
+        if self.request_params:
+            request_params.update(self.request_params)
+
+        return request_params
+
+    def _is_rate_limit_error(self, error: Exception) -> bool:
+        """Check if the error is a rate limiting error."""
+        if hasattr(error, "status_code") and error.status_code == 429:
+            return True
+        error_str = str(error).lower()
+        return any(
+            phrase in error_str
+            for phrase in ["rate limit", "too many requests", "429", "trial key", "api calls / minute"]
+        )
+
+    def _exponential_backoff_sleep(self, attempt: int, base_delay: float = 1.0) -> None:
+        """Sleep with exponential backoff."""
+        delay = base_delay * (2**attempt) + (time.time() % 1)  # Add jitter
+        log_debug(f"Rate limited, waiting {delay:.2f} seconds before retry (attempt {attempt + 1})")
+        time.sleep(delay)
+
+    async def _async_rate_limit_backoff_sleep(self, attempt: int) -> None:
+        """Async version of rate-limit-aware backoff for APIs with per-minute limits."""
+        import asyncio
+
+        # For 40 req/min APIs like Cohere Trial, we need longer waits
+        if attempt == 0:
+            delay = 15.0  # Wait 15 seconds (1/4 of minute window)
+        elif attempt == 1:
+            delay = 30.0  # Wait 30 seconds (1/2 of minute window)
+        else:
+            delay = 60.0  # Wait full minute for window reset
+
+        # Add small jitter
+        delay += time.time() % 3
+
+        log_debug(
+            f"Async rate limit backoff, waiting {delay:.1f} seconds for rate limit window reset (attempt {attempt + 1})"
+        )
+        await asyncio.sleep(delay)
+
+    async def _async_batch_with_retry(
+        self, texts: List[str], max_retries: int = 3
+    ) -> Tuple[List[List[float]], List[Optional[Dict]]]:
+        """Execute async batch embedding with rate-limit-aware backoff for rate limiting."""
+
+        log_debug(f"Starting async batch retry for {len(texts)} texts with max_retries={max_retries}")
+
+        for attempt in range(max_retries + 1):
+            try:
+                request_params = self._get_batch_request_params()
+                response: Union[
+                    EmbeddingsFloatsEmbedResponse, EmbeddingsByTypeEmbedResponse
+                ] = await self.aclient.embed(texts=texts, **request_params)
+
+                # Extract embeddings from response
+                if isinstance(response, EmbeddingsFloatsEmbedResponse):
+                    batch_embeddings = response.embeddings
+                elif isinstance(response, EmbeddingsByTypeEmbedResponse):
+                    batch_embeddings = response.embeddings.float_ if response.embeddings.float_ else []
+                else:
+                    log_warning("No embeddings found in response")
+                    batch_embeddings = []
+
+                # Extract usage information
+                usage = response.meta.billed_units if response.meta else None
+                usage_dict = usage.model_dump() if usage else None
+                all_usage = [usage_dict] * len(batch_embeddings)
+
+                log_debug(f"Async batch embedding succeeded on attempt {attempt + 1}")
+                return batch_embeddings, all_usage
+
+            except Exception as e:
+                if self._is_rate_limit_error(e):
+                    if not self.exponential_backoff:
+                        log_warning(
+                            "Rate limit detected. To enable automatic backoff retry, set enable_backoff=True when creating the embedder."
+                        )
+                        raise e
+
+                    log_info(f"Async rate limit detected on attempt {attempt + 1}")
+                    if attempt < max_retries:
+                        await self._async_rate_limit_backoff_sleep(attempt)
+                        continue
+                    else:
+                        log_warning(f"Async max retries ({max_retries}) reached for rate limiting")
+                        raise e
+                else:
+                    log_debug(f"Async non-rate-limit error on attempt {attempt + 1}: {e}")
+                    raise e
+
+        # This should never be reached, but just in case
+        log_error("Could not create embeddings. End of retry loop reached.")
+        return [], []
+
     def get_embedding(self, text: str) -> List[float]:
         response: Union[EmbeddingsFloatsEmbedResponse, EmbeddingsByTypeEmbedResponse] = self.response(text=text)
         try:
@@ -69,10 +176,10 @@ class CohereEmbedder(Embedder):
             elif isinstance(response, EmbeddingsByTypeEmbedResponse):
                 return response.embeddings.float_[0] if response.embeddings.float_ else []
             else:
-                logger.warning("No embeddings found")
+                log_warning("No embeddings found")
                 return []
         except Exception as e:
-            logger.warning(e)
+            log_warning(e)
             return []
 
     def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict[str, Any]]]:
@@ -110,10 +217,10 @@ class CohereEmbedder(Embedder):
             elif isinstance(response, EmbeddingsByTypeEmbedResponse):
                 return response.embeddings.float_[0] if response.embeddings.float_ else []
             else:
-                logger.warning("No embeddings found")
+                log_warning("No embeddings found")
                 return []
         except Exception as e:
-            logger.warning(e)
+            log_warning(e)
             return []
 
     async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict[str, Any]]]:
@@ -142,3 +249,75 @@ class CohereEmbedder(Embedder):
         if usage:
             return embedding, usage.model_dump()
         return embedding, None
+
+    async def async_get_embeddings_batch_and_usage(
+        self, texts: List[str]
+    ) -> Tuple[List[List[float]], List[Optional[Dict]]]:
+        """
+                Get embeddings and usage for multiple texts in batches (async version).
+
+                Args:
+                    texts: List of text strings to embed
+
+                Returns:
+        s, List of usage dictionaries)
+        """
+        all_embeddings = []
+        all_usage = []
+        log_info(f"Getting embeddings and usage for {len(texts)} texts in batches of {self.batch_size} (async)")
+
+        for i in range(0, len(texts), self.batch_size):
+            batch_texts = texts[i : i + self.batch_size]
+
+            try:
+                # Use retry logic for batch processing
+                batch_embeddings, batch_usage = await self._async_batch_with_retry(batch_texts)
+                all_embeddings.extend(batch_embeddings)
+                all_usage.extend(batch_usage)
+
+            except Exception as e:
+                log_warning(f"Async batch embedding failed after retries: {e}")
+
+                # Check if this is a rate limit error and backoff is disabled
+                if self._is_rate_limit_error(e) and not self.exponential_backoff:
+                    log_warning("Rate limit hit and backoff is disabled. Failing immediately.")
+                    raise e
+
+                # Only fall back to individual calls for non-rate-limit errors
+                # For rate limit errors, we should reduce batch size instead
+                if self._is_rate_limit_error(e):
+                    log_warning("Rate limit hit even after retries. Consider reducing batch_size or upgrading API key.")
+                    # Try with smaller batch size
+                    if len(batch_texts) > 1:
+                        smaller_batch_size = max(1, len(batch_texts) // 2)
+                        log_info(f"Retrying with smaller batch size: {smaller_batch_size}")
+                        for j in range(0, len(batch_texts), smaller_batch_size):
+                            small_batch = batch_texts[j : j + smaller_batch_size]
+                            try:
+                                small_embeddings, small_usage = await self._async_batch_with_retry(small_batch)
+                                all_embeddings.extend(small_embeddings)
+                                all_usage.extend(small_usage)
+                            except Exception as e3:
+                                log_error(f"Failed even with reduced batch size: {e3}")
+                                # Fall back to empty results for this batch
+                                all_embeddings.extend([[] for _ in small_batch])
+                                all_usage.extend([None for _ in small_batch])
+                    else:
+                        # Single item already failed, add empty result
+                        log_debug("Single item failed, adding empty result")
+                        all_embeddings.append([])
+                        all_usage.append(None)
+                else:
+                    # For non-rate-limit errors, fall back to individual calls
+                    log_debug("Non-rate-limit error, falling back to individual calls")
+                    for text in batch_texts:
+                        try:
+                            embedding, usage = await self.async_get_embedding_and_usage(text)
+                            all_embeddings.append(embedding)
+                            all_usage.append(usage)
+                        except Exception as e2:
+                            log_warning(f"Error in individual async embedding fallback: {e2}")
+                            all_embeddings.append([])
+                            all_usage.append(None)
+
+        return all_embeddings, all_usage

agno/knowledge/embedder/fastembed.py

@@ -23,7 +23,7 @@ class FastEmbedEmbedder(Embedder):
     """Using BAAI/bge-small-en-v1.5 model, more models available: https://qdrant.github.io/fastembed/examples/Supported_Models/"""
 
     id: str = "BAAI/bge-small-en-v1.5"
-    dimensions: int = 384
+    dimensions: Optional[int] = 384
 
     def get_embedding(self, text: str) -> List[float]:
         model = TextEmbedding(model_name=self.id)