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

agno/knowledge/embedder/huggingface.py

@@ -0,0 +1,94 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, List, Optional, Tuple
+
+from agno.knowledge.embedder.base import Embedder
+from agno.utils.log import log_error, log_warning
+
+try:
+    from huggingface_hub import AsyncInferenceClient, InferenceClient
+except ImportError:
+    log_error("`huggingface-hub` not installed, please run `pip install huggingface-hub`")
+    raise
+
+
+@dataclass
+class HuggingfaceCustomEmbedder(Embedder):
+    """Huggingface Custom Embedder"""
+
+    id: str = "intfloat/multilingual-e5-large"
+    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
+
+    def __post_init__(self):
+        if self.enable_batch:
+            log_warning("HuggingfaceEmbedder does not support batch embeddings, setting enable_batch to False")
+            self.enable_batch = False
+
+    @property
+    def client(self) -> InferenceClient:
+        if self.huggingface_client:
+            return self.huggingface_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.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)
+
+    def get_embedding(self, text: str) -> List[float]:
+        response = self._response(text=text)
+        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:
+            log_warning(f"Failed to process embeddings: {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: 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:
+            log_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

agno/knowledge/embedder/jina.py

@@ -0,0 +1,182 @@
+from dataclasses import dataclass
+from os import getenv
+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:
+    import requests
+except ImportError:
+    raise ImportError("`requests` not installed, use pip install requests")
+
+try:
+    import aiohttp
+except ImportError:
+    raise ImportError("`aiohttp` not installed, use pip install aiohttp")
+
+
+@dataclass
+class JinaEmbedder(Embedder):
+    id: str = "jina-embeddings-v3"
+    dimensions: int = 1024
+    embedding_type: Literal["float", "base64", "int8"] = "float"
+    late_chunking: bool = False
+    user: Optional[str] = None
+    api_key: Optional[str] = getenv("JINA_API_KEY")
+    base_url: str = "https://api.jina.ai/v1/embeddings"
+    headers: Optional[Dict[str, str]] = None
+    request_params: Optional[Dict[str, Any]] = None
+    timeout: Optional[float] = None
+
+    def _get_headers(self) -> Dict[str, str]:
+        if not self.api_key:
+            raise ValueError(
+                "API key is required for Jina embedder. Set JINA_API_KEY environment variable or pass api_key parameter."
+            )
+
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {self.api_key}"}
+        if self.headers:
+            headers.update(self.headers)
+        return headers
+
+    def _response(self, text: str) -> Dict[str, Any]:
+        data = {
+            "model": self.id,
+            "late_chunking": self.late_chunking,
+            "dimensions": self.dimensions,
+            "embedding_type": self.embedding_type,
+            "input": [text],  # Jina API expects a list
+        }
+        if self.user is not None:
+            data["user"] = self.user
+        if self.request_params:
+            data.update(self.request_params)
+
+        response = requests.post(self.base_url, headers=self._get_headers(), json=data, timeout=self.timeout)
+        response.raise_for_status()
+        return response.json()
+
+    def get_embedding(self, text: str) -> List[float]:
+        try:
+            result = self._response(text)
+            return result["data"][0]["embedding"]
+        except Exception as e:
+            logger.warning(f"Failed to get embedding: {e}")
+            return []
+
+    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        try:
+            result = self._response(text)
+            embedding = result["data"][0]["embedding"]
+            usage = result.get("usage")
+            return embedding, usage
+        except Exception as e:
+            logger.warning(f"Failed to get embedding and usage: {e}")
+            return [], None
+
+    async def _async_response(self, text: str) -> Dict[str, Any]:
+        """Async version of _response using aiohttp."""
+        data = {
+            "model": self.id,
+            "late_chunking": self.late_chunking,
+            "dimensions": self.dimensions,
+            "embedding_type": self.embedding_type,
+            "input": [text],  # Jina API expects a list
+        }
+        if self.user is not None:
+            data["user"] = self.user
+        if self.request_params:
+            data.update(self.request_params)
+
+        timeout = aiohttp.ClientTimeout(total=self.timeout) if self.timeout else None
+
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.post(self.base_url, headers=self._get_headers(), json=data) as response:
+                response.raise_for_status()
+                return await response.json()
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        """Async version of get_embedding."""
+        try:
+            result = await self._async_response(text)
+            return result["data"][0]["embedding"]
+        except Exception as e:
+            logger.warning(f"Failed to get 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:
+            result = await self._async_response(text)
+            embedding = result["data"][0]["embedding"]
+            usage = result.get("usage")
+            return embedding, usage
+        except Exception as e:
+            logger.warning(f"Failed to get embedding and usage: {e}")
+            return [], None
+
+    async def _async_batch_response(self, texts: List[str]) -> Dict[str, Any]:
+        """Async batch version of _response using aiohttp."""
+        data = {
+            "model": self.id,
+            "late_chunking": self.late_chunking,
+            "dimensions": self.dimensions,
+            "embedding_type": self.embedding_type,
+            "input": texts,  # Jina API expects a list of texts for batch processing
+        }
+        if self.user is not None:
+            data["user"] = self.user
+        if self.request_params:
+            data.update(self.request_params)
+
+        timeout = aiohttp.ClientTimeout(total=self.timeout) if self.timeout else None
+
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.post(self.base_url, headers=self._get_headers(), json=data) as response:
+                response.raise_for_status()
+                return await response.json()
+
+    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]
+
+            try:
+                result = await self._async_batch_response(batch_texts)
+                batch_embeddings = [data["embedding"] for data in result["data"]]
+                all_embeddings.extend(batch_embeddings)
+
+                # For each embedding in the batch, add the same usage information
+                usage_dict = result.get("usage")
+                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/langdb.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Optional
+
+from agno.knowledge.embedder.openai import OpenAIEmbedder
+
+
+@dataclass
+class LangDBEmbedder(OpenAIEmbedder):
+    id: str = "text-embedding-ada-002"
+    dimensions: int = 1536
+    api_key: Optional[str] = getenv("LANGDB_API_KEY")
+    project_id: Optional[str] = getenv("LANGDB_PROJECT_ID")
+    base_url: Optional[str] = None
+
+    def __post_init__(self):
+        """Set the base_url based on project_id if not provided."""
+        if not self.project_id:
+            raise ValueError("LANGDB_PROJECT_ID not set in the environment")
+
+        if not self.base_url:
+            self.base_url = f"https://api.us-east-1.langdb.ai/{self.project_id}/v1"

agno/knowledge/embedder/mistral.py

@@ -0,0 +1,206 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, List, Optional, Tuple
+
+from agno.knowledge.embedder.base import Embedder
+from agno.utils.log import log_error, log_info, log_warning
+
+try:
+    from mistralai import Mistral  # type: ignore
+    from mistralai.models.embeddingresponse import EmbeddingResponse  # type: ignore
+except ImportError:
+    log_error("`mistralai` not installed")
+    raise
+
+
+@dataclass
+class MistralEmbedder(Embedder):
+    id: str = "mistral-embed"
+    dimensions: int = 1024
+    # -*- Request parameters
+    request_params: Optional[Dict[str, Any]] = None
+    # -*- Client parameters
+    api_key: Optional[str] = getenv("MISTRAL_API_KEY")
+    endpoint: Optional[str] = None
+    max_retries: Optional[int] = None
+    timeout: Optional[int] = None
+    client_params: Optional[Dict[str, Any]] = None
+    # -*- Provide the Mistral Client manually
+    mistral_client: Optional[Mistral] = None
+
+    @property
+    def client(self) -> Mistral:
+        if self.mistral_client:
+            return self.mistral_client
+
+        _client_params: Dict[str, Any] = {
+            "api_key": self.api_key,
+            "endpoint": self.endpoint,
+            "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.mistral_client = Mistral(**_client_params)
+
+        return self.mistral_client
+
+    def _response(self, text: str) -> EmbeddingResponse:
+        _request_params: Dict[str, Any] = {
+            "inputs": [text],  # Mistral API expects a list
+            "model": self.id,
+        }
+        if self.request_params:
+            _request_params.update(self.request_params)
+        response = self.client.embeddings.create(**_request_params)
+        if response is None:
+            raise ValueError("Failed to get embedding response")
+        return response
+
+    def get_embedding(self, text: str) -> List[float]:
+        try:
+            response: EmbeddingResponse = self._response(text=text)
+            if response.data and response.data[0].embedding:
+                return response.data[0].embedding
+            return []
+        except Exception as e:
+            log_warning(f"Error getting embedding: {e}")
+            return []
+
+    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Dict[str, Any]]:
+        try:
+            response: EmbeddingResponse = self._response(text=text)
+            embedding: List[float] = (
+                response.data[0].embedding if (response.data and response.data[0].embedding) else []
+            )
+            usage: Dict[str, Any] = response.usage.model_dump() if response.usage else {}
+            return embedding, usage
+        except Exception as e:
+            log_warning(f"Error getting embedding and usage: {e}")
+            return [], {}
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        """Async version of get_embedding."""
+        try:
+            # Check if the client has an async version of embeddings.create
+            if hasattr(self.client.embeddings, "create_async"):
+                response: EmbeddingResponse = await self.client.embeddings.create_async(
+                    inputs=[text], model=self.id, **self.request_params if self.request_params else {}
+                )
+            else:
+                # Fallback to running sync method in thread executor
+                import asyncio
+
+                loop = asyncio.get_running_loop()
+                response: EmbeddingResponse = await loop.run_in_executor(  # type: ignore
+                    None,
+                    lambda: self.client.embeddings.create(
+                        inputs=[text], model=self.id, **self.request_params if self.request_params else {}
+                    ),
+                )
+
+            if response.data and response.data[0].embedding:
+                return response.data[0].embedding
+            return []
+        except Exception as e:
+            log_warning(f"Error getting embedding: {e}")
+            return []
+
+    async def async_get_embedding_and_usage(self, text: str) -> Tuple[List[float], Dict[str, Any]]:
+        """Async version of get_embedding_and_usage."""
+        try:
+            # Check if the client has an async version of embeddings.create
+            if hasattr(self.client.embeddings, "create_async"):
+                response: EmbeddingResponse = await self.client.embeddings.create_async(
+                    inputs=[text], model=self.id, **self.request_params if self.request_params else {}
+                )
+            else:
+                # Fallback to running sync method in thread executor
+                import asyncio
+
+                loop = asyncio.get_running_loop()
+                response: EmbeddingResponse = await loop.run_in_executor(  # type: ignore
+                    None,
+                    lambda: self.client.embeddings.create(
+                        inputs=[text], model=self.id, **self.request_params if self.request_params else {}
+                    ),
+                )
+
+            embedding: List[float] = (
+                response.data[0].embedding if (response.data and response.data[0].embedding) else []
+            )
+            usage: Dict[str, Any] = response.usage.model_dump() if response.usage else {}
+            return embedding, usage
+        except Exception as e:
+            log_warning(f"Error getting embedding and usage: {e}")
+            return [], {}
+
+    async def async_get_embeddings_batch_and_usage(
+        self, texts: List[str]
+    ) -> Tuple[List[List[float]], List[Optional[Dict[str, Any]]]]:
+        """
+        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 = []
+        log_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]
+
+            _request_params: Dict[str, Any] = {
+                "inputs": batch_texts,  # Mistral API expects a list for batch processing
+                "model": self.id,
+            }
+            if self.request_params:
+                _request_params.update(self.request_params)
+
+            try:
+                # Check if the client has an async version of embeddings.create
+                if hasattr(self.client.embeddings, "create_async"):
+                    response: EmbeddingResponse = await self.client.embeddings.create_async(**_request_params)
+                else:
+                    # Fallback to running sync method in thread executor
+                    import asyncio
+
+                    loop = asyncio.get_running_loop()
+                    response: EmbeddingResponse = await loop.run_in_executor(  # type: ignore
+                        None, lambda: self.client.embeddings.create(**_request_params)
+                    )
+
+                # Extract embeddings from batch response
+                if response.data:
+                    batch_embeddings = [data.embedding for data in response.data if data.embedding]
+                    all_embeddings.extend(batch_embeddings)
+                else:
+                    # If no embeddings, add empty lists for each text in batch
+                    all_embeddings.extend([[] for _ in batch_texts])
+
+                # Extract usage information
+                usage_dict = response.usage.model_dump() if response.usage else None
+                # Add same usage info for each embedding in the batch
+                all_usage.extend([usage_dict] * len(batch_texts))
+
+            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/nebius.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Optional
+
+from agno.knowledge.embedder.openai import OpenAIEmbedder
+
+
+@dataclass
+class NebiusEmbedder(OpenAIEmbedder):
+    id: str = "BAAI/bge-en-icl"
+    dimensions: int = 1024
+    api_key: Optional[str] = getenv("NEBIUS_API_KEY")
+    base_url: str = "https://api.tokenfactory.nebius.com/v1/"

agno/knowledge/embedder/ollama.py

@@ -0,0 +1,154 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+from agno.knowledge.embedder.base import Embedder
+from agno.utils.log import log_error, logger
+
+try:
+    import importlib.metadata as metadata
+
+    from ollama import AsyncClient as AsyncOllamaClient
+    from ollama import Client as OllamaClient
+    from packaging import version
+
+    # Get installed Ollama version
+    ollama_version = metadata.version("ollama")
+
+    # Check version compatibility (requires v0.3.x or higher)
+    parsed_version = version.parse(ollama_version)
+    if parsed_version.major == 0 and parsed_version.minor < 3:
+        import warnings
+
+        warnings.warn("Only Ollama v0.3.x and above are supported", UserWarning)
+        raise RuntimeError("Incompatible Ollama version detected")
+
+except ImportError as e:
+    # Handle different import error scenarios
+    if "ollama" in str(e):
+        raise ImportError("Ollama not installed. Install with `pip install ollama`") from e
+    else:
+        raise ImportError("Missing dependencies. Install with `pip install packaging importlib-metadata`") from e
+
+except Exception as e:
+    # Catch-all for unexpected errors
+    log_error(f"An unexpected error occurred: {e}")
+
+
+@dataclass
+class OllamaEmbedder(Embedder):
+    id: str = "openhermes"
+    dimensions: int = 4096
+    host: Optional[str] = None
+    timeout: Optional[Any] = None
+    options: Optional[Any] = None
+    client_kwargs: Optional[Dict[str, Any]] = None
+    ollama_client: Optional[OllamaClient] = None
+    async_client: Optional[AsyncOllamaClient] = None
+
+    def __post_init__(self):
+        if self.enable_batch:
+            logger.warning("OllamaEmbedder does not support batch embeddings, setting enable_batch to False")
+            self.enable_batch = False
+
+    @property
+    def client(self) -> OllamaClient:
+        if self.ollama_client:
+            return self.ollama_client
+
+        _ollama_params: Dict[str, Any] = {
+            "host": self.host,
+            "timeout": self.timeout,
+        }
+        _ollama_params = {k: v for k, v in _ollama_params.items() if v is not None}
+        if self.client_kwargs:
+            _ollama_params.update(self.client_kwargs)
+        self.ollama_client = OllamaClient(**_ollama_params)
+        return self.ollama_client
+
+    @property
+    def aclient(self) -> AsyncOllamaClient:
+        if self.async_client:
+            return self.async_client
+
+        _ollama_params: Dict[str, Any] = {
+            "host": self.host,
+            "timeout": self.timeout,
+        }
+        _ollama_params = {k: v for k, v in _ollama_params.items() if v is not None}
+        if self.client_kwargs:
+            _ollama_params.update(self.client_kwargs)
+        self.async_client = AsyncOllamaClient(**_ollama_params)
+        return self.async_client
+
+    def _response(self, text: str) -> Dict[str, Any]:
+        kwargs: Dict[str, Any] = {}
+        if self.options is not None:
+            kwargs["options"] = self.options
+
+        # Add dimensions parameter for models that support it
+        if self.dimensions is not None:
+            kwargs["dimensions"] = self.dimensions
+
+        response = self.client.embed(input=text, model=self.id, **kwargs)
+        if response and "embeddings" in response:
+            embeddings = response["embeddings"]
+            if isinstance(embeddings, list) and len(embeddings) > 0 and isinstance(embeddings[0], list):
+                return {"embeddings": embeddings[0]}  # Use the first element
+            elif isinstance(embeddings, list) and all(isinstance(x, (int, float)) for x in embeddings):
+                return {"embeddings": embeddings}  # Return as-is if already flat
+        return {"embeddings": []}  # Return an empty list if no valid embedding is found
+
+    def get_embedding(self, text: str) -> List[float]:
+        try:
+            response = self._response(text=text)
+            embedding = response.get("embeddings", [])
+            if len(embedding) != self.dimensions:
+                logger.warning(f"Expected embedding dimension {self.dimensions}, but got {len(embedding)}")
+                return []
+            return embedding
+        except Exception as e:
+            logger.warning(e)
+            return []
+
+    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        embedding = self.get_embedding(text=text)
+        usage = None
+        return embedding, usage
+
+    async def _async_response(self, text: str) -> Dict[str, Any]:
+        """Async version of _response using AsyncOllamaClient."""
+        kwargs: Dict[str, Any] = {}
+        if self.options is not None:
+            kwargs["options"] = self.options
+
+        # Add dimensions parameter for models that support it
+        if self.dimensions is not None:
+            kwargs["dimensions"] = self.dimensions
+
+        response = await self.aclient.embed(input=text, model=self.id, **kwargs)
+        if response and "embeddings" in response:
+            embeddings = response["embeddings"]
+            if isinstance(embeddings, list) and len(embeddings) > 0 and isinstance(embeddings[0], list):
+                return {"embeddings": embeddings[0]}  # Use the first element
+            elif isinstance(embeddings, list) and all(isinstance(x, (int, float)) for x in embeddings):
+                return {"embeddings": embeddings}  # Return as-is if already flat
+        return {"embeddings": []}  # Return an empty list if no valid embedding is found
+
+    async def async_get_embedding(self, text: str) -> List[float]:
+        """Async version of get_embedding."""
+        try:
+            response = await self._async_response(text=text)
+            embedding = response.get("embeddings", [])
+            if len(embedding) != self.dimensions:
+                logger.warning(f"Expected embedding dimension {self.dimensions}, but got {len(embedding)}")
+                return []
+            return embedding
+        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."""
+        embedding = await self.async_get_embedding(text=text)
+        usage = None
+        return embedding, usage