agno 1.8.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

agno/knowledge/content.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from agno.knowledge.reader import Reader
+from agno.knowledge.remote_content.remote_content import RemoteContent
+
+
+class ContentStatus(str, Enum):
+    """Enumeration of possible content processing statuses."""
+
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+@dataclass
+class FileData:
+    content: Optional[Union[str, bytes]] = None
+    type: Optional[str] = None
+    filename: Optional[str] = None
+    size: Optional[int] = None
+
+
+@dataclass
+class ContentAuth:
+    password: Optional[str] = None
+
+
+@dataclass
+class Content:
+    id: Optional[str] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+    path: Optional[str] = None
+    url: Optional[str] = None
+    auth: Optional[ContentAuth] = None
+    file_data: Optional[FileData] = None
+    metadata: Optional[Dict[str, Any]] = None
+    topics: Optional[List[str]] = None
+    remote_content: Optional[RemoteContent] = None
+    reader: Optional[Reader] = None
+    size: Optional[int] = None
+    file_type: Optional[str] = None
+    content_hash: Optional[str] = None
+    status: Optional[ContentStatus] = None
+    status_message: Optional[str] = None
+    created_at: Optional[int] = None
+    updated_at: Optional[int] = None
+    external_id: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Content":
+        return cls(
+            id=data.get("id"),
+            name=data.get("name"),
+            description=data.get("description"),
+            path=data.get("path"),
+            url=data.get("url"),
+            auth=data.get("auth"),
+            file_data=data.get("file_data"),
+            metadata=data.get("metadata"),
+            topics=data.get("topics"),
+            remote_content=data.get("remote_content"),
+            reader=data.get("reader"),
+            size=data.get("size"),
+            file_type=data.get("file_type"),
+            content_hash=data.get("content_hash"),
+            status=data.get("status"),
+            status_message=data.get("status_message"),
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at"),
+            external_id=data.get("external_id"),
+        )

agno/knowledge/document/__init__.py

@@ -0,0 +1,5 @@
+from agno.knowledge.document.base import Document
+
+__all__ = [
+    "Document",
+]

agno/{document → knowledge/document}/base.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 
-from agno.embedder import Embedder
+from agno.knowledge.embedder import Embedder
 
 
 @dataclass
@@ -12,10 +12,13 @@ class Document:
     id: Optional[str] = None
     name: Optional[str] = None
     meta_data: Dict[str, Any] = field(default_factory=dict)
-    embedder: Optional[Embedder] = None
+    embedder: Optional["Embedder"] = None
     embedding: Optional[List[float]] = None
     usage: Optional[Dict[str, Any]] = None
     reranking_score: Optional[float] = None
+    content_id: Optional[str] = None
+    content_origin: Optional[str] = None
+    size: Optional[int] = None
 
     def embed(self, embedder: Optional[Embedder] = None) -> None:
         """Embed the document using the provided embedder"""
@@ -26,6 +29,13 @@ class Document:
 
         self.embedding, self.usage = _embedder.get_embedding_and_usage(self.content)
 
+    async def async_embed(self, embedder: Optional[Embedder] = None) -> None:
+        """Embed the document using the provided embedder"""
+        _embedder = embedder or self.embedder
+        if _embedder is None:
+            raise ValueError("No embedder provided")
+        self.embedding, self.usage = await _embedder.async_get_embedding_and_usage(self.content)
+
     def to_dict(self) -> Dict[str, Any]:
         """Returns a dictionary representation of the document"""
         fields = {"name", "meta_data", "content"}

agno/knowledge/embedder/__init__.py

@@ -0,0 +1,5 @@
+from agno.knowledge.embedder.base import Embedder
+
+__all__ = [
+    "Embedder",
+]

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

@@ -3,8 +3,8 @@ from dataclasses import dataclass
 from os import getenv
 from typing import Any, Dict, List, Optional, Tuple
 
-from agno.embedder.base import Embedder
 from agno.exceptions import AgnoError, ModelProviderError
+from agno.knowledge.embedder.base import Embedder
 from agno.utils.log import log_error, logger
 
 try:
@@ -15,6 +15,14 @@ except ImportError:
     log_error("`boto3` not installed. Please install it via `pip install boto3`.")
     raise
 
+try:
+    import aioboto3
+    from aioboto3.session import Session as AioSession
+except ImportError:
+    log_error("`aioboto3` not installed. Please install it via `pip install aioboto3`.")
+    aioboto3 = None
+    AioSession = None
+
 
 @dataclass
 class AwsBedrockEmbedder(Embedder):
@@ -94,6 +102,46 @@ class AwsBedrockEmbedder(Embedder):
         )
         return self.client
 
+    def get_async_client(self):
+        """
+        Returns an async AWS Bedrock client using aioboto3.
+
+        Returns:
+            An aioboto3 bedrock-runtime client context manager.
+        """
+        if aioboto3 is None:
+            raise AgnoError(
+                message="aioboto3 not installed. Please install it via `pip install aioboto3`.",
+                status_code=400,
+            )
+
+        if self.session:
+            # Convert boto3 session to aioboto3 session
+            aio_session = aioboto3.Session(
+                aws_access_key_id=self.session.get_credentials().access_key,
+                aws_secret_access_key=self.session.get_credentials().secret_key,
+                aws_session_token=self.session.get_credentials().token,
+                region_name=self.session.region_name,
+            )
+        else:
+            self.aws_access_key_id = self.aws_access_key_id or getenv("AWS_ACCESS_KEY_ID")
+            self.aws_secret_access_key = self.aws_secret_access_key or getenv("AWS_SECRET_ACCESS_KEY")
+            self.aws_region = self.aws_region or getenv("AWS_REGION")
+
+            if not self.aws_access_key_id or not self.aws_secret_access_key:
+                raise AgnoError(
+                    message="AWS credentials not found. Please set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables or provide a boto3 session.",
+                    status_code=400,
+                )
+
+            aio_session = aioboto3.Session(
+                aws_access_key_id=self.aws_access_key_id,
+                aws_secret_access_key=self.aws_secret_access_key,
+                region_name=self.aws_region,
+            )
+
+        return aio_session.client("bedrock-runtime", **(self.client_params or {}))
+
     def _format_request_body(self, text: str) -> str:
         """
         Format the request body for the embedder.
@@ -210,3 +258,81 @@ class AwsBedrockEmbedder(Embedder):
             usage = response["usage"]
 
         return embedding, usage
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        """
+        Async version of get_embedding() using native aioboto3 async client.
+        """
+        try:
+            body = self._format_request_body(text)
+            async with self.get_async_client() as client:
+                response = await client.invoke_model(
+                    modelId=self.id,
+                    body=body,
+                    contentType="application/json",
+                    accept="application/json",
+                )
+                response_body = json.loads((await response["body"].read()).decode("utf-8"))
+
+                # Extract embeddings using the same logic as get_embedding
+                if "embeddings" in response_body:
+                    if isinstance(response_body["embeddings"], list):
+                        # Default 'float' embeddings response format
+                        return response_body["embeddings"][0]
+                    elif isinstance(response_body["embeddings"], dict):
+                        # If embeddings_types parameter was used, select float embeddings
+                        if "float" in response_body["embeddings"]:
+                            return response_body["embeddings"]["float"][0]
+                        # 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")
+                return []
+        except ClientError as e:
+            log_error(f"Unexpected error calling Bedrock API: {str(e)}")
+            raise ModelProviderError(message=str(e.response), model_name="AwsBedrockEmbedder", model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error calling Bedrock API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name="AwsBedrockEmbedder", model_id=self.id) from e
+
+    async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict[str, Any]]]:
+        """
+        Async version of get_embedding_and_usage() using native aioboto3 async client.
+        """
+        try:
+            body = self._format_request_body(text)
+            async with self.get_async_client() as client:
+                response = await client.invoke_model(
+                    modelId=self.id,
+                    body=body,
+                    contentType="application/json",
+                    accept="application/json",
+                )
+                response_body = json.loads((await response["body"].read()).decode("utf-8"))
+
+                embedding: List[float] = []
+                # Extract embeddings using the same logic as get_embedding_and_usage
+                if "embeddings" in response_body:
+                    if isinstance(response_body["embeddings"], list):
+                        embedding = response_body["embeddings"][0]
+                    elif isinstance(response_body["embeddings"], dict):
+                        if "float" in response_body["embeddings"]:
+                            embedding = response_body["embeddings"]["float"][0]
+                        # Fallback to the first available embedding type
+                        else:
+                            for embedding_type in response_body["embeddings"]:
+                                embedding = response_body["embeddings"][embedding_type][0]
+                                break
+
+                # Extract usage metrics if available
+                usage = None
+                if "usage" in response_body:
+                    usage = response_body["usage"]
+
+                return embedding, usage
+        except ClientError as e:
+            log_error(f"Unexpected error calling Bedrock API: {str(e)}")
+            raise ModelProviderError(message=str(e.response), model_name="AwsBedrockEmbedder", model_id=self.id) from e
+        except Exception as e:
+            log_error(f"Unexpected error calling Bedrock API: {str(e)}")
+            raise ModelProviderError(message=str(e), model_name="AwsBedrockEmbedder", model_id=self.id) from e

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

@@ -4,10 +4,11 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from typing_extensions import Literal
 
-from agno.embedder.base import Embedder
+from agno.knowledge.embedder.base import Embedder
 from agno.utils.log import logger
 
 try:
+    from openai import AsyncAzureOpenAI as AsyncAzureOpenAIClient
     from openai import AzureOpenAI as AzureOpenAIClient
     from openai.types.create_embedding_response import CreateEmbeddingResponse
 except ImportError:
@@ -32,6 +33,7 @@ class AzureOpenAIEmbedder(Embedder):
     request_params: Optional[Dict[str, Any]] = None
     client_params: Optional[Dict[str, Any]] = None
     openai_client: Optional[AzureOpenAIClient] = None
+    async_client: Optional[AsyncAzureOpenAIClient] = None
 
     @property
     def client(self) -> AzureOpenAIClient:
@@ -61,6 +63,35 @@ class AzureOpenAIEmbedder(Embedder):
 
         return AzureOpenAIClient(**_client_params)
 
+    @property
+    def aclient(self) -> AsyncAzureOpenAIClient:
+        if self.async_client:
+            return self.async_client
+
+        _client_params: Dict[str, Any] = {}
+        if self.api_key:
+            _client_params["api_key"] = self.api_key
+        if self.api_version:
+            _client_params["api_version"] = self.api_version
+        if self.organization:
+            _client_params["organization"] = self.organization
+        if self.azure_endpoint:
+            _client_params["azure_endpoint"] = self.azure_endpoint
+        if self.azure_deployment:
+            _client_params["azure_deployment"] = self.azure_deployment
+        if self.base_url:
+            _client_params["base_url"] = self.base_url
+        if self.azure_ad_token:
+            _client_params["azure_ad_token"] = self.azure_ad_token
+        if self.azure_ad_token_provider:
+            _client_params["azure_ad_token_provider"] = self.azure_ad_token_provider
+
+        if self.client_params:
+            _client_params.update(self.client_params)
+
+        self.async_client = AsyncAzureOpenAIClient(**_client_params)
+        return self.async_client
+
     def _response(self, text: str) -> CreateEmbeddingResponse:
         _request_params: Dict[str, Any] = {
             "input": text,
@@ -90,3 +121,36 @@ class AzureOpenAIEmbedder(Embedder):
         embedding = response.data[0].embedding
         usage = response.usage
         return embedding, usage.model_dump()
+
+    async def _aresponse(self, text: str) -> CreateEmbeddingResponse:
+        """Async version of _response method."""
+        _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 await self.aclient.embeddings.create(**_request_params)
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        """Async version of get_embedding using the native Azure OpenAI async client."""
+        response: CreateEmbeddingResponse = await self._aresponse(text=text)
+        try:
+            return response.data[0].embedding
+        except Exception as e:
+            logger.warning(e)
+            return []
+
+    async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        """Async version of get_embedding_and_usage using the native Azure OpenAI async client."""
+        response: CreateEmbeddingResponse = await self._aresponse(text=text)
+
+        embedding = response.data[0].embedding
+        usage = response.usage
+        return embedding, usage.model_dump()

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

@@ -13,3 +13,9 @@ class Embedder:
 
     def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
         raise NotImplementedError
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        raise NotImplementedError
+
+    async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        raise NotImplementedError

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

@@ -1,10 +1,11 @@
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-from agno.embedder.base import Embedder
+from agno.knowledge.embedder.base import Embedder
 from agno.utils.log import logger
 
 try:
+    from cohere import AsyncClient as AsyncCohereClient
     from cohere import Client as CohereClient
     from cohere.types.embed_response import EmbeddingsByTypeEmbedResponse, EmbeddingsFloatsEmbedResponse
 except ImportError:
@@ -20,6 +21,7 @@ class CohereEmbedder(Embedder):
     request_params: Optional[Dict[str, Any]] = None
     client_params: Optional[Dict[str, Any]] = None
     cohere_client: Optional[CohereClient] = None
+    async_client: Optional[AsyncCohereClient] = None
 
     @property
     def client(self) -> CohereClient:
@@ -28,9 +30,24 @@ class CohereEmbedder(Embedder):
         client_params: Dict[str, Any] = {}
         if self.api_key:
             client_params["api_key"] = self.api_key
+        if self.client_params:
+            client_params.update(self.client_params)
         self.cohere_client = CohereClient(**client_params)
         return self.cohere_client
 
+    @property
+    def aclient(self) -> AsyncCohereClient:
+        """Lazy init for Cohere async client."""
+        if self.async_client:
+            return self.async_client
+        params: Dict[str, Any] = {}
+        if self.api_key:
+            params["api_key"] = self.api_key
+        if self.client_params:
+            params.update(self.client_params)
+        self.async_client = AsyncCohereClient(**params)
+        return self.async_client
+
     def response(self, text: str) -> Union[EmbeddingsFloatsEmbedResponse, EmbeddingsByTypeEmbedResponse]:
         request_params: Dict[str, Any] = {}
 
@@ -71,3 +88,57 @@ class CohereEmbedder(Embedder):
         if usage:
             return embedding, usage.model_dump()
         return embedding, None
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        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)
+
+        try:
+            response: Union[EmbeddingsFloatsEmbedResponse, EmbeddingsByTypeEmbedResponse] = await self.aclient.embed(
+                texts=[text], **request_params
+            )
+            if isinstance(response, EmbeddingsFloatsEmbedResponse):
+                return response.embeddings[0]
+            elif isinstance(response, EmbeddingsByTypeEmbedResponse):
+                return response.embeddings.float_[0] if response.embeddings.float_ else []
+            else:
+                logger.warning("No embeddings found")
+                return []
+        except Exception as e:
+            logger.warning(e)
+            return []
+
+    async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict[str, Any]]]:
+        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)
+
+        response: Union[EmbeddingsFloatsEmbedResponse, EmbeddingsByTypeEmbedResponse] = await self.aclient.embed(
+            texts=[text], **request_params
+        )
+
+        embedding: List[float] = []
+        if isinstance(response, EmbeddingsFloatsEmbedResponse):
+            embedding = response.embeddings[0]
+        elif isinstance(response, EmbeddingsByTypeEmbedResponse):
+            embedding = response.embeddings.float_[0] if response.embeddings.float_ else []
+
+        usage = response.meta.billed_units if response.meta else None
+        if usage:
+            return embedding, usage.model_dump()
+        return embedding, None

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

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import Dict, List, Optional, Tuple
 
-from agno.embedder.base import Embedder
+from agno.knowledge.embedder.base import Embedder
 from agno.utils.log import logger
 
 try:
@@ -44,3 +44,19 @@ class FastEmbedEmbedder(Embedder):
         usage = None
 
         return embedding, usage
+
+    async def async_get_embedding(self, text: 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()
+        # Run the CPU-bound operation in a thread executor
+        return await loop.run_in_executor(None, self.get_embedding_and_usage, text)

agno/{embedder → knowledge/embedder}/fireworks.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/{embedder → knowledge/embedder}/google.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from os import getenv
 from typing import Any, Dict, List, Optional, Tuple
 
-from agno.embedder.base import Embedder
+from agno.knowledge.embedder.base import Embedder
 from agno.utils.log import log_error, log_info
 
 try:
@@ -56,6 +56,11 @@ class GeminiEmbedder(Embedder):
 
         return self.gemini_client
 
+    @property
+    def aclient(self) -> GeminiClient:
+        """Returns the same client instance since Google GenAI Client supports both sync and async operations."""
+        return self.client
+
     def _response(self, text: str) -> EmbedContentResponse:
         # If a user provides a model id with the `models/` prefix, we need to remove it
         _id = self.id
@@ -105,3 +110,71 @@ class GeminiEmbedder(Embedder):
         except Exception as e:
             log_error(f"Error extracting embeddings: {e}")
             return [], usage
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        """Async version of get_embedding using client.aio."""
+        # If a user provides a model id with the `models/` prefix, we need to remove it
+        _id = self.id
+        if _id.startswith("models/"):
+            _id = _id.split("/")[-1]
+
+        _request_params: Dict[str, Any] = {"contents": text, "model": _id, "config": {}}
+        if self.dimensions:
+            _request_params["config"]["output_dimensionality"] = self.dimensions
+        if self.task_type:
+            _request_params["config"]["task_type"] = self.task_type
+        if self.title:
+            _request_params["config"]["title"] = self.title
+        if not _request_params["config"]:
+            del _request_params["config"]
+
+        if self.request_params:
+            _request_params.update(self.request_params)
+
+        try:
+            response = await self.aclient.aio.models.embed_content(**_request_params)
+            if response.embeddings and len(response.embeddings) > 0:
+                values = response.embeddings[0].values
+                if values is not None:
+                    return values
+            log_info("No embeddings found in response")
+            return []
+        except Exception as e:
+            log_error(f"Error extracting embeddings: {e}")
+            return []
+
+    async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict[str, Any]]]:
+        """Async version of get_embedding_and_usage using client.aio."""
+        # If a user provides a model id with the `models/` prefix, we need to remove it
+        _id = self.id
+        if _id.startswith("models/"):
+            _id = _id.split("/")[-1]
+
+        _request_params: Dict[str, Any] = {"contents": text, "model": _id, "config": {}}
+        if self.dimensions:
+            _request_params["config"]["output_dimensionality"] = self.dimensions
+        if self.task_type:
+            _request_params["config"]["task_type"] = self.task_type
+        if self.title:
+            _request_params["config"]["title"] = self.title
+        if not _request_params["config"]:
+            del _request_params["config"]
+
+        if self.request_params:
+            _request_params.update(self.request_params)
+
+        try:
+            response = await self.aclient.aio.models.embed_content(**_request_params)
+            usage = None
+            if response.metadata and hasattr(response.metadata, "billable_character_count"):
+                usage = {"billable_character_count": response.metadata.billable_character_count}
+
+            if response.embeddings and len(response.embeddings) > 0:
+                values = response.embeddings[0].values
+                if values is not None:
+                    return values, usage
+            log_info("No embeddings found in response")
+            return [], usage
+        except Exception as e:
+            log_error(f"Error extracting embeddings: {e}")
+            return [], usage

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

@@ -2,11 +2,11 @@ from dataclasses import dataclass
 from os import getenv
 from typing import Any, Dict, List, Optional, Tuple
 
-from agno.embedder.base import Embedder
+from agno.knowledge.embedder.base import Embedder
 from agno.utils.log import logger
 
 try:
-    from huggingface_hub import InferenceClient
+    from huggingface_hub import AsyncInferenceClient, InferenceClient
 except ImportError:
     logger.error("`huggingface-hub` not installed, please run `pip install huggingface-hub`")
     raise
@@ -20,6 +20,7 @@ class HuggingfaceCustomEmbedder(Embedder):
     api_key: Optional[str] = getenv("HUGGINGFACE_API_KEY")
     client_params: Optional[Dict[str, Any]] = None
     huggingface_client: Optional[InferenceClient] = None
+    async_client: Optional[AsyncInferenceClient] = None
 
     @property
     def client(self) -> InferenceClient:
@@ -33,6 +34,18 @@ class HuggingfaceCustomEmbedder(Embedder):
         self.huggingface_client = InferenceClient(**_client_params)
         return self.huggingface_client
 
+    @property
+    def aclient(self) -> AsyncInferenceClient:
+        if self.async_client:
+            return self.async_client
+        _client_params: Dict[str, Any] = {}
+        if self.api_key:
+            _client_params["api_key"] = self.api_key
+        if self.client_params:
+            _client_params.update(self.client_params)
+        self.async_client = AsyncInferenceClient(**_client_params)
+        return self.async_client
+
     def _response(self, text: str):
         return self.client.feature_extraction(text=text, model=self.id)
 
@@ -53,3 +66,24 @@ class HuggingfaceCustomEmbedder(Embedder):
 
     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: str) -> List[float]:
+        """Async version of get_embedding using AsyncInferenceClient."""
+        response = await self.aclient.feature_extraction(text=text, model=self.id)
+        try:
+            # If already a list, return directly
+            if isinstance(response, list):
+                return response
+            # If numpy array, convert to list
+            elif hasattr(response, "tolist"):
+                return response.tolist()
+            else:
+                return list(response)
+        except Exception as e:
+            logger.warning(f"Failed to process embeddings: {e}")
+            return []
+
+    async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        """Async version of get_embedding_and_usage."""
+        embedding = await self.async_get_embedding(text=text)
+        return embedding, None