agno 1.8.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/knowledge/embedder/openai.py

@@ -0,0 +1,223 @@
+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 logger
+
+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]:
+        response: CreateEmbeddingResponse = self.response(text=text)
+        try:
+            return response.data[0].embedding
+        except Exception as e:
+            logger.warning(e)
+            return []
+
+    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        response: CreateEmbeddingResponse = self.response(text=text)
+
+        embedding = response.data[0].embedding
+        usage = response.usage
+        if usage:
+            return embedding, usage.model_dump()
+        return embedding, 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:
+            logger.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)
+
+        response = await self.aclient.embeddings.create(**req)
+        embedding = response.data[0].embedding
+        usage = response.usage
+        return embedding, usage.model_dump() if usage else None
+
+    def get_embeddings_batch(self, texts: List[str], batch_size: int = 100) -> List[List[float]]:
+        """
+        Get embeddings for multiple texts in batches.
+
+        Args:
+            texts: List of text strings to embed
+            batch_size: Number of texts to process in each API call (max ~2048)
+
+        Returns:
+            List of embedding vectors
+        """
+        all_embeddings = []
+
+        for i in range(0, len(texts), batch_size):
+            batch_texts = texts[i : i + 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 = self.client.embeddings.create(**req)
+                batch_embeddings = [data.embedding for data in response.data]
+                all_embeddings.extend(batch_embeddings)
+            except Exception as e:
+                logger.warning(f"Error in batch embedding: {e}")
+                # Fallback to individual calls for this batch
+                for text in batch_texts:
+                    try:
+                        embedding = self.get_embedding(text)
+                        all_embeddings.append(embedding)
+                    except Exception as e2:
+                        logger.warning(f"Error in individual embedding fallback: {e2}")
+                        all_embeddings.append([])
+
+        return all_embeddings
+
+    async def async_get_embeddings_batch(self, texts: List[str], batch_size: int = 100) -> List[List[float]]:
+        """
+        Get embeddings for multiple texts in batches (async version).
+
+        Args:
+            texts: List of text strings to embed
+            batch_size: Number of texts to process in each API call (max ~2048)
+
+        Returns:
+            List of embedding vectors
+        """
+        all_embeddings = []
+
+        for i in range(0, len(texts), batch_size):
+            batch_texts = texts[i : i + 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)
+            except Exception as e:
+                logger.warning(f"Error in async batch embedding: {e}")
+                # Fallback to individual async calls for this batch
+                for text in batch_texts:
+                    try:
+                        embedding = await self.async_get_embedding(text)
+                        all_embeddings.append(embedding)
+                    except Exception as e2:
+                        logger.warning(f"Error in individual async embedding fallback: {e2}")
+                        all_embeddings.append([])
+
+        return all_embeddings

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

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import 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:
@@ -42,3 +42,18 @@ class SentenceTransformerEmbedder(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: 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/{embedder → knowledge/embedder}/voyageai.py

@@ -1,10 +1,11 @@
 from dataclasses import dataclass
 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 voyageai import AsyncClient as AsyncVoyageClient
     from voyageai import Client as VoyageClient
     from voyageai.object import EmbeddingsObject
 except ImportError:
@@ -22,6 +23,7 @@ class VoyageAIEmbedder(Embedder):
     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:
@@ -39,6 +41,22 @@ class VoyageAIEmbedder(Embedder):
         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 = {
+            "api_key": self.api_key,
+            "max_retries": self.max_retries,
+            "timeout": self.timeout,
+        }
+        _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.async_client = AsyncVoyageClient(**_client_params)
+        return self.async_client
+
     def _response(self, text: str) -> EmbeddingsObject:
         _request_params: Dict[str, Any] = {
             "texts": [text],
@@ -62,3 +80,33 @@ class VoyageAIEmbedder(Embedder):
         embedding = response.embeddings[0]
         usage = {"total_tokens": response.total_tokens}
         return 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)
+            return response.embeddings[0]
+        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 embedding, usage
+        except Exception as e:
+            logger.warning(f"Error getting embedding and usage: {e}")
+            return [], None