agno 2.4.6__py3-none-any.whl → 2.4.8__py3-none-any.whl

agno/knowledge/reranker/aws_bedrock.py

@@ -0,0 +1,299 @@
+from os import getenv
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import ConfigDict, Field
+
+from agno.knowledge.document import Document
+from agno.knowledge.reranker.base import Reranker
+from agno.utils.log import logger
+
+try:
+    from boto3 import client as AwsClient
+    from boto3.session import Session
+    from botocore.exceptions import ClientError
+except ImportError:
+    raise ImportError("`boto3` not installed. Please install it via `pip install boto3`.")
+
+
+# Model ID constants
+AMAZON_RERANK_V1 = "amazon.rerank-v1:0"
+COHERE_RERANK_V3_5 = "cohere.rerank-v3-5:0"
+
+# Type alias for supported models
+RerankerModel = Literal["amazon.rerank-v1:0", "cohere.rerank-v3-5:0"]
+
+
+class AwsBedrockReranker(Reranker):
+    """
+    AWS Bedrock reranker supporting Amazon Rerank 1.0 and Cohere Rerank 3.5 models.
+
+    This reranker uses the unified Bedrock Rerank API (bedrock-agent-runtime)
+    which provides a consistent interface for both model providers.
+
+    To use this reranker, you need to either:
+    1. Set the following environment variables:
+       - AWS_ACCESS_KEY_ID
+       - AWS_SECRET_ACCESS_KEY
+       - AWS_REGION
+    2. Or provide a boto3 Session object
+
+    Args:
+        model (str): The model ID to use. Options:
+            - 'amazon.rerank-v1:0' (Amazon Rerank 1.0)
+            - 'cohere.rerank-v3-5:0' (Cohere Rerank 3.5)
+            Default is 'cohere.rerank-v3-5:0'.
+        top_n (Optional[int]): Number of top results to return after reranking.
+            If None, returns all documents reranked.
+        aws_region (Optional[str]): The AWS region to use.
+        aws_access_key_id (Optional[str]): The AWS access key ID to use.
+        aws_secret_access_key (Optional[str]): The AWS secret access key to use.
+        session (Optional[Session]): A boto3 Session object for authentication.
+        additional_model_request_fields (Optional[Dict]): Additional model-specific
+            parameters to pass in the request (e.g., Cohere-specific options).
+
+    Example:
+        ```python
+        from agno.knowledge.reranker.aws_bedrock import AwsBedrockReranker
+
+        # Using Cohere Rerank 3.5 (default)
+        reranker = AwsBedrockReranker(
+            model="cohere.rerank-v3-5:0",
+            top_n=5,
+            aws_region="us-west-2",
+        )
+
+        # Using Amazon Rerank 1.0
+        reranker = AwsBedrockReranker(
+            model="amazon.rerank-v1:0",
+            top_n=10,
+            aws_region="us-west-2",
+        )
+
+        # Rerank documents
+        reranked_docs = reranker.rerank(query="What is machine learning?", documents=docs)
+        ```
+
+    Note:
+        - Amazon Rerank 1.0 is NOT available in us-east-1 (N. Virginia).
+          Use Cohere Rerank 3.5 in that region.
+        - Maximum 1000 documents per request.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
+
+    model: str = Field(default=COHERE_RERANK_V3_5, description="Reranker model ID")
+    top_n: Optional[int] = Field(default=None, description="Number of top results to return")
+
+    aws_region: Optional[str] = Field(default=None, description="AWS region")
+    aws_access_key_id: Optional[str] = Field(default=None, description="AWS access key ID")
+    aws_secret_access_key: Optional[str] = Field(default=None, description="AWS secret access key")
+    session: Optional[Session] = Field(default=None, description="Boto3 session", exclude=True)
+
+    additional_model_request_fields: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Additional model-specific request parameters",
+    )
+
+    _client: Optional[AwsClient] = None
+
+    @property
+    def client(self) -> AwsClient:
+        """
+        Returns a bedrock-agent-runtime client for the Rerank API.
+
+        Returns:
+            AwsClient: An instance of the bedrock-agent-runtime client.
+        """
+        if self._client is not None:
+            return self._client
+
+        if self.session:
+            self._client = self.session.client("bedrock-agent-runtime")
+            return self._client
+
+        aws_access_key_id = self.aws_access_key_id or getenv("AWS_ACCESS_KEY_ID")
+        aws_secret_access_key = self.aws_secret_access_key or getenv("AWS_SECRET_ACCESS_KEY")
+        aws_region = self.aws_region or getenv("AWS_REGION")
+
+        if not aws_access_key_id or not aws_secret_access_key:
+            # Fall back to default credential chain
+            self._client = AwsClient(
+                service_name="bedrock-agent-runtime",
+                region_name=aws_region,
+            )
+        else:
+            self._client = AwsClient(
+                service_name="bedrock-agent-runtime",
+                region_name=aws_region,
+                aws_access_key_id=aws_access_key_id,
+                aws_secret_access_key=aws_secret_access_key,
+            )
+
+        return self._client
+
+    def _get_model_arn(self) -> str:
+        """
+        Constructs the full model ARN for the reranker model.
+
+        Returns:
+            str: The model ARN.
+        """
+        region = self.aws_region or getenv("AWS_REGION", "us-west-2")
+        return f"arn:aws:bedrock:{region}::foundation-model/{self.model}"
+
+    def _build_sources(self, documents: List[Document]) -> List[Dict[str, Any]]:
+        """
+        Convert Document objects to Bedrock Rerank API source format.
+
+        Args:
+            documents: List of Document objects to convert.
+
+        Returns:
+            List of RerankSource objects for the API.
+        """
+        sources = []
+        for doc in documents:
+            # Use text format for document content
+            source = {
+                "type": "INLINE",
+                "inlineDocumentSource": {
+                    "type": "TEXT",
+                    "textDocument": {
+                        "text": doc.content,
+                    },
+                },
+            }
+            sources.append(source)
+        return sources
+
+    def _rerank(self, query: str, documents: List[Document]) -> List[Document]:
+        """
+        Internal method to perform reranking via Bedrock Rerank API.
+
+        Args:
+            query: The query string to rank documents against.
+            documents: List of Document objects to rerank.
+
+        Returns:
+            List of Document objects sorted by relevance score.
+        """
+        if not documents:
+            return []
+
+        # Validate top_n
+        top_n = self.top_n
+        if top_n is not None and top_n <= 0:
+            logger.warning(f"top_n should be a positive integer, got {self.top_n}, setting top_n to None")
+            top_n = None
+
+        # Build the request
+        rerank_request: Dict[str, Any] = {
+            "queries": [
+                {
+                    "type": "TEXT",
+                    "textQuery": {
+                        "text": query,
+                    },
+                }
+            ],
+            "sources": self._build_sources(documents),
+            "rerankingConfiguration": {
+                "type": "BEDROCK_RERANKING_MODEL",
+                "bedrockRerankingConfiguration": {
+                    "modelConfiguration": {
+                        "modelArn": self._get_model_arn(),
+                    },
+                },
+            },
+        }
+
+        # Add numberOfResults if top_n is specified
+        if top_n is not None:
+            rerank_request["rerankingConfiguration"]["bedrockRerankingConfiguration"]["numberOfResults"] = top_n
+
+        # Add additional model request fields if provided
+        if self.additional_model_request_fields:
+            rerank_request["rerankingConfiguration"]["bedrockRerankingConfiguration"]["modelConfiguration"][
+                "additionalModelRequestFields"
+            ] = self.additional_model_request_fields
+
+        # Call the Rerank API
+        response = self.client.rerank(**rerank_request)
+
+        # Process results
+        reranked_docs: List[Document] = []
+        results = response.get("results", [])
+
+        for result in results:
+            index = result.get("index")
+            relevance_score = result.get("relevanceScore")
+
+            if index is not None and index < len(documents):
+                doc = documents[index]
+                doc.reranking_score = relevance_score
+                reranked_docs.append(doc)
+
+        # Results from API are already sorted by relevance, but ensure sorting
+        reranked_docs.sort(
+            key=lambda x: x.reranking_score if x.reranking_score is not None else float("-inf"),
+            reverse=True,
+        )
+
+        return reranked_docs
+
+    def rerank(self, query: str, documents: List[Document]) -> List[Document]:
+        """
+        Rerank documents based on their relevance to a query.
+
+        Args:
+            query: The query string to rank documents against.
+            documents: List of Document objects to rerank.
+
+        Returns:
+            List of Document objects sorted by relevance score (highest first).
+            Each document will have its `reranking_score` attribute set.
+        """
+        try:
+            return self._rerank(query=query, documents=documents)
+        except ClientError as e:
+            error_code = e.response.get("Error", {}).get("Code", "Unknown")
+            error_message = e.response.get("Error", {}).get("Message", str(e))
+            logger.error(f"AWS Bedrock Rerank API error ({error_code}): {error_message}. Returning original documents.")
+            return documents
+        except Exception as e:
+            logger.error(f"Error reranking documents: {e}. Returning original documents.")
+            return documents
+
+
+class CohereBedrockReranker(AwsBedrockReranker):
+    """
+    Convenience class for Cohere Rerank 3.5 on AWS Bedrock.
+
+    This is a pre-configured AwsBedrockReranker using the Cohere Rerank 3.5 model.
+
+    Example:
+        ```python
+        reranker = CohereBedrockReranker(top_n=5, aws_region="us-west-2")
+        reranked_docs = reranker.rerank(query="What is AI?", documents=docs)
+        ```
+    """
+
+    model: str = Field(default=COHERE_RERANK_V3_5)
+
+
+class AmazonReranker(AwsBedrockReranker):
+    """
+    Convenience class for Amazon Rerank 1.0 on AWS Bedrock.
+
+    This is a pre-configured AwsBedrockReranker using the Amazon Rerank 1.0 model.
+
+    Note: Amazon Rerank 1.0 is NOT available in us-east-1 (N. Virginia).
+
+    Example:
+        ```python
+        reranker = AmazonReranker(top_n=5, aws_region="us-west-2")
+        reranked_docs = reranker.rerank(query="What is AI?", documents=docs)
+        ```
+    """
+
+    model: str = Field(default=AMAZON_RERANK_V1)

agno/learn/machine.py

@@ -645,12 +645,11 @@ class LearningMachine:
         for name, store in self.stores.items():
             try:
                 result = await store.arecall(**context)
-                if result is not None:
-                    results[name] = result
-                    try:
-                        log_debug(f"Recalled from {name}: {result}")
-                    except Exception:
-                        pass
+                results[name] = result
+                try:
+                    log_debug(f"Recalled from {name}: {result}")
+                except Exception:
+                    pass
             except Exception as e:
                 log_warning(f"Error recalling from {name}: {e}")
 

agno/learn/stores/session_context.py

@@ -540,7 +540,11 @@ class SessionContextStore(LearningStore):
             existing_context=existing_context,
         )
 
-        messages_for_model = [system_message]
+        messages_for_model = [
+            system_message,
+            # For models that require a non-system message
+            Message(role="user", content="Please analyze the conversation and update the session context using the available tools."),
+        ]
 
         model_copy = deepcopy(self.model)
         response = model_copy.response(
@@ -596,7 +600,11 @@ class SessionContextStore(LearningStore):
             existing_context=existing_context,
         )
 
-        messages_for_model = [system_message]
+        messages_for_model = [
+            system_message,
+            # For models that require a non-system message
+            Message(role="user", content="Please analyze the conversation and update the session context using the available tools."),
+        ]
 
         model_copy = deepcopy(self.model)
         response = await model_copy.aresponse(

agno/models/azure/openai_chat.py

@@ -65,17 +65,12 @@ class AzureOpenAI(OpenAILike):
         self.azure_endpoint = self.azure_endpoint or getenv("AZURE_OPENAI_ENDPOINT")
         self.azure_deployment = self.azure_deployment or getenv("AZURE_OPENAI_DEPLOYMENT")
 
-        if not (self.api_key or self.azure_ad_token):
-            if not self.api_key:
-                raise ModelAuthenticationError(
-                    message="AZURE_OPENAI_API_KEY not set. Please set the AZURE_OPENAI_API_KEY environment variable.",
-                    model_name=self.name,
-                )
-            if not self.azure_ad_token:
-                raise ModelAuthenticationError(
-                    message="AZURE_AD_TOKEN not set. Please set the AZURE_AD_TOKEN environment variable.",
-                    model_name=self.name,
-                )
+        if not (self.api_key or self.azure_ad_token or self.azure_ad_token_provider):
+            raise ModelAuthenticationError(
+                message="Azure OpenAI authentication not configured. Please provide one of:"
+                "AZURE_OPENAI_API_KEY environment variable, azure_ad_token, or azure_ad_token_provider",
+                model_name=self.name,
+            )
 
         params_mapping = {
             "api_key": self.api_key,

agno/models/neosantara/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.neosantara.neosantara import Neosantara
+
+__all__ = [
+    "Neosantara",
+]

agno/models/neosantara/neosantara.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.exceptions import ModelAuthenticationError
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class Neosantara(OpenAILike):
+    """
+    A class for interacting with Neosantara API.
+
+    Attributes:
+        id (str): The id of the Neosantara model to use. Default is "grok-4.1-fast-non-reasoning".
+        name (str): The name of this chat model instance. Default is "Neosantara"
+        provider (str): The provider of the model. Default is "Neosantara".
+        api_key (str): The api key to authorize request to Neosantara.
+        base_url (str): The base url to which the requests are sent. Defaults to "https://api.neosantara.xyz/v1".
+    """
+
+    id: str = "grok-4.1-fast-non-reasoning"
+    name: str = "Neosantara"
+    provider: str = "Neosantara"
+    api_key: Optional[str] = None
+    base_url: str = "https://api.neosantara.xyz/v1"
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for NEOSANTARA_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("NEOSANTARA_API_KEY")
+            if not self.api_key:
+                raise ModelAuthenticationError(
+                    message="NEOSANTARA_API_KEY not set. Please set the NEOSANTARA_API_KEY environment variable.",
+                    model_name=self.name,
+                )
+        return super()._get_client_params()

agno/models/utils.py

@@ -149,6 +149,11 @@ def _get_model_class(model_id: str, model_provider: str) -> Model:
 
         return Nebius(id=model_id)
 
+    elif model_provider == "neosantara":
+        from agno.models.neosantara import Neosantara
+
+        return Neosantara(id=model_id)
+
     elif model_provider == "nexus":
         from agno.models.nexus import Nexus
 

agno/os/app.py

@@ -1056,12 +1056,15 @@ class AgentOS:
         dbs_with_specific_config = [db.db_id for db in knowledge_config.dbs]
 
         # Only add databases that are actually used for knowledge contents
-        for db_id in self.knowledge_dbs.keys():
+        for db_id, dbs in self.knowledge_dbs.items():
             if db_id not in dbs_with_specific_config:
+                # Collect unique table names from all databases with the same id
+                unique_tables = list(set(db.knowledge_table_name for db in dbs))
                 knowledge_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=KnowledgeDomainConfig(display_name=db_id),
+                        tables=unique_tables,
                     )
                 )
 

agno/os/interfaces/agui/router.py

@@ -14,7 +14,7 @@ try:
     )
     from ag_ui.encoder import EventEncoder
 except ImportError as e:
-    raise ImportError("`ag_ui` not installed. Please install it with `pip install -U ag-ui`") from e
+    raise ImportError("`ag_ui` not installed. Please install it with `pip install -U ag-ui-protocol`") from e
 
 from fastapi import APIRouter
 from fastapi.responses import StreamingResponse

agno/os/routers/components/components.py

@@ -243,6 +243,8 @@ def attach_routes(
                 update_kwargs["description"] = body.description
             if body.metadata is not None:
                 update_kwargs["metadata"] = body.metadata
+            if body.current_version is not None:
+                update_kwargs["current_version"] = body.current_version
             if body.component_type is not None:
                 update_kwargs["component_type"] = DbComponentType(body.component_type)
 

agno/os/routers/knowledge/knowledge.py

@@ -215,7 +215,6 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
         description=(
             "Upload content from a remote source (S3, GCS, SharePoint, GitHub) to the knowledge base. "
             "Content is processed asynchronously in the background. "
-            "Use the /knowledge/config endpoint to see available remote content sources."
         ),
         responses={
             202: {