agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/knowledge/embedder/openai.py

@@ -0,0 +1,195 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+from typing_extensions import Literal
+
+from agno.knowledge.embedder.base import Embedder
+from agno.utils.log import log_info, log_warning
+
+try:
+    from openai import AsyncOpenAI
+    from openai import OpenAI as OpenAIClient
+    from openai.types.create_embedding_response import CreateEmbeddingResponse
+except ImportError:
+    raise ImportError("`openai` not installed")
+
+
+@dataclass
+class OpenAIEmbedder(Embedder):
+    id: str = "text-embedding-3-small"
+    dimensions: Optional[int] = None
+    encoding_format: Literal["float", "base64"] = "float"
+    user: Optional[str] = None
+    api_key: Optional[str] = None
+    organization: Optional[str] = None
+    base_url: Optional[str] = None
+    request_params: Optional[Dict[str, Any]] = None
+    client_params: Optional[Dict[str, Any]] = None
+    openai_client: Optional[OpenAIClient] = None
+    async_client: Optional[AsyncOpenAI] = None
+
+    def __post_init__(self):
+        if self.dimensions is None:
+            self.dimensions = 3072 if self.id == "text-embedding-3-large" else 1536
+
+    @property
+    def client(self) -> OpenAIClient:
+        if self.openai_client:
+            return self.openai_client
+
+        _client_params: Dict[str, Any] = {
+            "api_key": self.api_key,
+            "organization": self.organization,
+            "base_url": self.base_url,
+        }
+        _client_params = {k: v for k, v in _client_params.items() if v is not None}
+        if self.client_params:
+            _client_params.update(self.client_params)
+        self.openai_client = OpenAIClient(**_client_params)
+        return self.openai_client
+
+    @property
+    def aclient(self) -> AsyncOpenAI:
+        if self.async_client:
+            return self.async_client
+        params = {
+            "api_key": self.api_key,
+            "organization": self.organization,
+            "base_url": self.base_url,
+        }
+        filtered_params: Dict[str, Any] = {k: v for k, v in params.items() if v is not None}
+        if self.client_params:
+            filtered_params.update(self.client_params)
+        self.async_client = AsyncOpenAI(**filtered_params)
+        return self.async_client
+
+    def response(self, text: str) -> CreateEmbeddingResponse:
+        _request_params: Dict[str, Any] = {
+            "input": text,
+            "model": self.id,
+            "encoding_format": self.encoding_format,
+        }
+        if self.user is not None:
+            _request_params["user"] = self.user
+        if self.id.startswith("text-embedding-3"):
+            _request_params["dimensions"] = self.dimensions
+        if self.request_params:
+            _request_params.update(self.request_params)
+        return self.client.embeddings.create(**_request_params)
+
+    def get_embedding(self, text: str) -> List[float]:
+        try:
+            response: CreateEmbeddingResponse = self.response(text=text)
+            return response.data[0].embedding
+        except Exception as e:
+            log_warning(e)
+            return []
+
+    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        try:
+            response: CreateEmbeddingResponse = self.response(text=text)
+
+            embedding = response.data[0].embedding
+            usage = response.usage
+            if usage:
+                return embedding, usage.model_dump()
+            return embedding, None
+        except Exception as e:
+            log_warning(e)
+            return [], None
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        req: Dict[str, Any] = {
+            "input": text,
+            "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)
+            return response.data[0].embedding
+        except Exception as e:
+            log_warning(e)
+            return []
+
+    async def async_get_embedding_and_usage(self, text: str):
+        req: Dict[str, Any] = {
+            "input": text,
+            "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 = await self.aclient.embeddings.create(**req)
+            embedding = response.data[0].embedding
+            usage = response.usage
+            return embedding, usage.model_dump() if usage else None
+        except Exception as e:
+            log_warning(f"Error getting embedding: {e}")
+            return [], 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:
+            Tuple of (List of embedding vectors, 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]
+
+            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:
+                log_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:
+                        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/sentence_transformer.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple, Union
+
+from agno.knowledge.embedder.base import Embedder
+from agno.utils.log import logger
+
+try:
+    from sentence_transformers import SentenceTransformer
+
+except ImportError:
+    raise ImportError("`sentence-transformers` not installed, please run `pip install sentence-transformers`")
+
+try:
+    import numpy as np
+
+except ImportError:
+    raise ImportError("numpy not installed, use `pip install numpy`")
+
+
+@dataclass
+class SentenceTransformerEmbedder(Embedder):
+    id: str = "sentence-transformers/all-MiniLM-L6-v2"
+    dimensions: int = 384
+    sentence_transformer_client: Optional[SentenceTransformer] = None
+    prompt: Optional[str] = None
+    normalize_embeddings: bool = False
+
+    def __post_init__(self):
+        # Initialize the SentenceTransformer model eagerly to avoid race conditions in async contexts
+        if self.sentence_transformer_client is None:
+            self.sentence_transformer_client = SentenceTransformer(model_name_or_path=self.id)
+
+    def get_embedding(self, text: Union[str, List[str]]) -> List[float]:
+        if self.sentence_transformer_client is None:
+            raise RuntimeError("SentenceTransformer model not initialized")
+        model = self.sentence_transformer_client
+        embedding = model.encode(text, prompt=self.prompt, normalize_embeddings=self.normalize_embeddings)
+        try:
+            if isinstance(embedding, np.ndarray):
+                return embedding.tolist()
+
+            return embedding  # type: ignore
+        except Exception as e:
+            logger.warning(e)
+            return []
+
+    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        return self.get_embedding(text=text), None
+
+    async def async_get_embedding(self, text: Union[str, List[str]]) -> List[float]:
+        """Async version using thread executor for CPU-bound operations."""
+        import asyncio
+
+        loop = asyncio.get_event_loop()
+        # Run the CPU-bound operation in a thread executor
+        return await loop.run_in_executor(None, self.get_embedding, text)
+
+    async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        """Async version using thread executor for CPU-bound operations."""
+        import asyncio
+
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self.get_embedding_and_usage, text)

agno/{embedder → knowledge/embedder}/together.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from os import getenv
 from typing import Optional
 
-from agno.embedder.openai import OpenAIEmbedder
+from agno.knowledge.embedder.openai import OpenAIEmbedder
 
 
 @dataclass

agno/knowledge/embedder/vllm.py

@@ -0,0 +1,262 @@
+import asyncio
+from dataclasses import dataclass
+from os import getenv
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+
+from agno.knowledge.embedder.base import Embedder
+from agno.utils.log import logger
+
+try:
+    from vllm import LLM  # type: ignore
+    from vllm.outputs import EmbeddingRequestOutput  # type: ignore
+except ImportError:
+    raise ImportError("`vllm` not installed. Please install using `pip install vllm`.")
+
+if TYPE_CHECKING:
+    from openai import AsyncOpenAI
+    from openai import OpenAI as OpenAIClient
+    from openai.types.create_embedding_response import CreateEmbeddingResponse
+
+
+@dataclass
+class VLLMEmbedder(Embedder):
+    """
+    VLLM Embedder supporting both local and remote deployment modes.
+
+    Local Mode (default):
+        - Loads model locally and runs inference on your GPU/CPU
+        - No API key required
+        - Example: VLLMEmbedder(id="intfloat/e5-mistral-7b-instruct")
+
+    Remote Mode:
+        - Connects to a remote vLLM server via OpenAI-compatible API
+        - Uses OpenAI SDK to communicate with vLLM's OpenAI-compatible endpoint
+        - Requires base_url and optionally api_key
+        - Example: VLLMEmbedder(base_url="http://localhost:8000/v1", api_key="your-key")
+        - Ref: https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html
+    """
+
+    id: str = "sentence-transformers/all-MiniLM-L6-v2"
+    dimensions: int = 4096
+    # Local mode parameters
+    enforce_eager: bool = True
+    vllm_kwargs: Optional[Dict[str, Any]] = None
+    vllm_client: Optional[LLM] = None
+    # Remote mode parameters
+    api_key: Optional[str] = getenv("VLLM_API_KEY")
+    base_url: Optional[str] = None
+    request_params: Optional[Dict[str, Any]] = None
+    client_params: Optional[Dict[str, Any]] = None
+    remote_client: Optional["OpenAIClient"] = None  # OpenAI-compatible client for vLLM server
+    async_remote_client: Optional["AsyncOpenAI"] = None  # Async OpenAI-compatible client for vLLM server
+
+    @property
+    def is_remote(self) -> bool:
+        """Determine if we should use remote mode."""
+        return self.base_url is not None
+
+    def _get_vllm_client(self) -> LLM:
+        """Get local VLLM client."""
+        if self.vllm_client:
+            return self.vllm_client
+
+        _vllm_params: Dict[str, Any] = {
+            "model": self.id,
+            "task": "embed",
+            "enforce_eager": self.enforce_eager,
+        }
+        if self.vllm_kwargs:
+            _vllm_params.update(self.vllm_kwargs)
+        self.vllm_client = LLM(**_vllm_params)
+        return self.vllm_client
+
+    def _get_remote_client(self) -> "OpenAIClient":
+        """Get OpenAI-compatible client for remote vLLM server."""
+        if self.remote_client:
+            return self.remote_client
+
+        try:
+            from openai import OpenAI as OpenAIClient
+        except ImportError:
+            raise ImportError("`openai` package required for remote vLLM mode. ")
+
+        _client_params: Dict[str, Any] = {
+            "api_key": self.api_key or "EMPTY",  # VLLM can run without API key
+            "base_url": self.base_url,
+        }
+        if self.client_params:
+            _client_params.update(self.client_params)
+        self.remote_client = OpenAIClient(**_client_params)
+        return self.remote_client
+
+    def _get_async_remote_client(self) -> "AsyncOpenAI":
+        """Get async OpenAI-compatible client for remote vLLM server."""
+        if self.async_remote_client:
+            return self.async_remote_client
+
+        try:
+            from openai import AsyncOpenAI
+        except ImportError:
+            raise ImportError("`openai` package required for remote vLLM mode. ")
+
+        _client_params: Dict[str, Any] = {
+            "api_key": self.api_key or "EMPTY",
+            "base_url": self.base_url,
+        }
+        if self.client_params:
+            _client_params.update(self.client_params)
+        self.async_remote_client = AsyncOpenAI(**_client_params)
+        return self.async_remote_client
+
+    def _create_embedding_local(self, text: str) -> Optional[EmbeddingRequestOutput]:
+        """Create embedding using local VLLM."""
+        try:
+            outputs = self._get_vllm_client().embed([text])
+            return outputs[0] if outputs else None
+        except Exception as e:
+            logger.warning(f"Error creating local embedding: {e}")
+            return None
+
+    def _create_embedding_remote(self, text: str) -> "CreateEmbeddingResponse":
+        """Create embedding using remote vLLM server."""
+        _request_params: Dict[str, Any] = {
+            "input": text,
+            "model": self.id,
+        }
+        if self.request_params:
+            _request_params.update(self.request_params)
+        return self._get_remote_client().embeddings.create(**_request_params)
+
+    def get_embedding(self, text: str) -> List[float]:
+        try:
+            if self.is_remote:
+                # Remote mode: OpenAI-compatible API
+                response: "CreateEmbeddingResponse" = self._create_embedding_remote(text=text)
+                return response.data[0].embedding
+            else:
+                # Local mode: Direct VLLM
+                output = self._create_embedding_local(text=text)
+                if output and hasattr(output, "outputs") and hasattr(output.outputs, "embedding"):
+                    embedding = output.outputs.embedding
+                    if len(embedding) != self.dimensions:
+                        logger.warning(f"Expected embedding dimension {self.dimensions}, but got {len(embedding)}")
+                    return embedding
+                return []
+        except Exception as e:
+            logger.warning(f"Error extracting embedding: {e}")
+            return []
+
+    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        if self.is_remote:
+            try:
+                response: "CreateEmbeddingResponse" = self._create_embedding_remote(text=text)
+                embedding = response.data[0].embedding
+                usage = response.usage
+                if usage:
+                    return embedding, usage.model_dump()
+                return embedding, None
+            except Exception as e:
+                logger.warning(f"Error in remote embedding: {e}")
+                return [], None
+        else:
+            embedding = self.get_embedding(text=text)
+            # Local VLLM doesn't provide usage information
+            return embedding, None
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        """Async version of get_embedding using thread executor for local mode."""
+        if self.is_remote:
+            # Remote mode: async client for vLLM server
+            try:
+                req: Dict[str, Any] = {
+                    "input": text,
+                    "model": self.id,
+                }
+                if self.request_params:
+                    req.update(self.request_params)
+                response: "CreateEmbeddingResponse" = await self._get_async_remote_client().embeddings.create(**req)
+                return response.data[0].embedding
+            except Exception as e:
+                logger.warning(f"Error in async remote embedding: {e}")
+                return []
+        else:
+            # Local mode: use thread executor for CPU-bound operations
+            loop = asyncio.get_event_loop()
+            return await loop.run_in_executor(None, self.get_embedding, text)
+
+    async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        """Async version of get_embedding_and_usage using thread executor for local mode."""
+        if self.is_remote:
+            try:
+                req: Dict[str, Any] = {
+                    "input": text,
+                    "model": self.id,
+                }
+                if self.request_params:
+                    req.update(self.request_params)
+                response: "CreateEmbeddingResponse" = await self._get_async_remote_client().embeddings.create(**req)
+                embedding = response.data[0].embedding
+                usage = response.usage
+                return embedding, usage.model_dump() if usage else None
+            except Exception as e:
+                logger.warning(f"Error in async remote embedding: {e}")
+                return [], None
+        else:
+            # Local mode: use thread executor for CPU-bound operations
+            try:
+                loop = asyncio.get_event_loop()
+                return await loop.run_in_executor(None, self.get_embedding_and_usage, text)
+            except Exception as e:
+                logger.warning(f"Error in async local embedding: {e}")
+                return [], 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:
+            Tuple of (List of embedding vectors, List of usage dictionaries)
+        """
+        all_embeddings = []
+        all_usage = []
+        logger.info(f"Getting embeddings 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:
+                if self.is_remote:
+                    # Remote mode: use batch API
+                    req: Dict[str, Any] = {
+                        "input": batch_texts,
+                        "model": self.id,
+                    }
+                    if self.request_params:
+                        req.update(self.request_params)
+                    response: "CreateEmbeddingResponse" = await self._get_async_remote_client().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))
+                else:
+                    # Local mode: process individually using thread executor
+                    for text in batch_texts:
+                        embedding, usage = await self.async_get_embedding_and_usage(text)
+                        all_embeddings.append(embedding)
+                        all_usage.append(usage)
+
+            except Exception as e:
+                logger.warning(f"Error in async batch embedding: {e}")
+                # Fallback: add empty results for failed batch
+                for _ in batch_texts:
+                    all_embeddings.append([])
+                    all_usage.append(None)
+
+        return all_embeddings, all_usage

agno/knowledge/embedder/voyageai.py

@@ -0,0 +1,165 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+from agno.knowledge.embedder.base import Embedder
+from agno.utils.log import logger
+
+try:
+    from voyageai import AsyncClient as AsyncVoyageClient
+    from voyageai import Client as VoyageClient
+    from voyageai.object import EmbeddingsObject
+except ImportError:
+    raise ImportError("`voyageai` not installed. Please install using `pip install voyageai`")
+
+
+@dataclass
+class VoyageAIEmbedder(Embedder):
+    id: str = "voyage-2"
+    dimensions: int = 1024
+    request_params: Optional[Dict[str, Any]] = None
+    api_key: Optional[str] = None
+    base_url: str = "https://api.voyageai.com/v1/embeddings"
+    max_retries: Optional[int] = None
+    timeout: Optional[float] = None
+    client_params: Optional[Dict[str, Any]] = None
+    voyage_client: Optional[VoyageClient] = None
+    async_client: Optional[AsyncVoyageClient] = None
+
+    @property
+    def client(self) -> VoyageClient:
+        if self.voyage_client:
+            return self.voyage_client
+
+        _client_params: Dict[str, Any] = {}
+        if self.api_key is not None:
+            _client_params["api_key"] = self.api_key
+        if self.max_retries is not None:
+            _client_params["max_retries"] = self.max_retries
+        if self.timeout is not None:
+            _client_params["timeout"] = self.timeout
+        if self.client_params:
+            _client_params.update(self.client_params)
+        self.voyage_client = VoyageClient(**_client_params)
+        return self.voyage_client
+
+    @property
+    def aclient(self) -> AsyncVoyageClient:
+        if self.async_client:
+            return self.async_client
+
+        _client_params: Dict[str, Any] = {}
+        if self.api_key is not None:
+            _client_params["api_key"] = self.api_key
+        if self.max_retries is not None:
+            _client_params["max_retries"] = self.max_retries
+        if self.timeout is not None:
+            _client_params["timeout"] = self.timeout
+        if self.client_params:
+            _client_params.update(self.client_params)
+        self.async_client = AsyncVoyageClient(**_client_params)
+        return self.async_client
+
+    def _response(self, text: str) -> EmbeddingsObject:
+        _request_params: Dict[str, Any] = {
+            "texts": [text],
+            "model": self.id,
+        }
+        if self.request_params:
+            _request_params.update(self.request_params)
+        return self.client.embed(**_request_params)
+
+    def get_embedding(self, text: str) -> List[float]:
+        response: EmbeddingsObject = self._response(text=text)
+        try:
+            embedding = response.embeddings[0]
+            return [float(x) for x in embedding]  # Ensure all values are float
+        except Exception as e:
+            logger.warning(e)
+            return []
+
+    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        response: EmbeddingsObject = self._response(text=text)
+
+        embedding = response.embeddings[0]
+        usage = {"total_tokens": response.total_tokens}
+        return [float(x) for x in embedding], usage
+
+    async def _async_response(self, text: str) -> EmbeddingsObject:
+        """Async version of _response using AsyncVoyageClient."""
+        _request_params: Dict[str, Any] = {
+            "texts": [text],
+            "model": self.id,
+        }
+        if self.request_params:
+            _request_params.update(self.request_params)
+        return await self.aclient.embed(**_request_params)
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        """Async version of get_embedding."""
+        try:
+            response: EmbeddingsObject = await self._async_response(text=text)
+            embedding = response.embeddings[0]
+            return [float(x) for x in embedding]  # Ensure all values are float
+        except Exception as e:
+            logger.warning(f"Error getting embedding: {e}")
+            return []
+
+    async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        """Async version of get_embedding_and_usage."""
+        try:
+            response: EmbeddingsObject = await self._async_response(text=text)
+            embedding = response.embeddings[0]
+            usage = {"total_tokens": response.total_tokens}
+            return [float(x) for x in embedding], usage
+        except Exception as e:
+            logger.warning(f"Error getting embedding and usage: {e}")
+            return [], 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.
+
+        Args:
+            texts: List of text strings to embed
+
+        Returns:
+            Tuple of (List of embedding vectors, List of usage dictionaries)
+        """
+        all_embeddings: List[List[float]] = []
+        all_usage: List[Optional[Dict]] = []
+        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] = {
+                "texts": batch_texts,
+                "model": self.id,
+            }
+            if self.request_params:
+                req.update(self.request_params)
+
+            try:
+                response: EmbeddingsObject = await self.aclient.embed(**req)
+                batch_embeddings = [[float(x) for x in emb] for emb in response.embeddings]
+                all_embeddings.extend(batch_embeddings)
+
+                # For each embedding in the batch, add the same usage information
+                usage_dict = {"total_tokens": response.total_tokens}
+                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