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

agno/tools/nano_banana.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import os
+from io import BytesIO
+from typing import Any, List, Optional
+from uuid import uuid4
+
+from agno.media import Image
+from agno.tools import Toolkit
+from agno.tools.function import ToolResult
+from agno.utils.log import log_debug, logger
+
+try:
+    from google import genai
+    from google.genai import types
+    from PIL import Image as PILImage
+
+except ImportError as exc:
+    missing = []
+    try:
+        from google.genai import types
+    except ImportError:
+        missing.append("google-genai")
+
+    try:
+        from PIL import Image as PILImage
+    except ImportError:
+        missing.append("Pillow")
+
+    raise ImportError(
+        f"Missing required package(s): {', '.join(missing)}. Install using: pip install {' '.join(missing)}"
+    ) from exc
+
+
+# Note: Expand this list as new models become supported by the Google Content Generation API.
+ALLOWED_MODELS = ["gemini-2.5-flash-image"]
+ALLOWED_RATIOS = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"]
+
+
+class NanoBananaTools(Toolkit):
+    def __init__(
+        self,
+        model: str = "gemini-2.5-flash-image",
+        aspect_ratio: str = "1:1",
+        api_key: Optional[str] = None,
+        enable_create_image: bool = True,
+        **kwargs,
+    ):
+        self.model = model
+        self.aspect_ratio = aspect_ratio
+        self.api_key = api_key or os.getenv("GOOGLE_API_KEY")
+
+        # Validate model
+        if model not in ALLOWED_MODELS:
+            raise ValueError(f"Invalid model '{model}'. Supported: {', '.join(ALLOWED_MODELS)}")
+
+        if self.aspect_ratio not in ALLOWED_RATIOS:
+            raise ValueError(f"Invalid aspect_ratio '{self.aspect_ratio}'. Supported: {', '.join(ALLOWED_RATIOS)}")
+
+        if not self.api_key:
+            raise ValueError("GOOGLE_API_KEY not set. Export it: `export GOOGLE_API_KEY=<your-key>`")
+
+        tools: List[Any] = []
+        if enable_create_image:
+            tools.append(self.create_image)
+
+        super().__init__(name="nano_banana", tools=tools, **kwargs)
+
+    def create_image(self, prompt: str) -> ToolResult:
+        """Generate an image from a text prompt."""
+        try:
+            client = genai.Client(api_key=self.api_key)
+            log_debug(f"NanoBanana generating image with prompt: {prompt}")
+
+            cfg = types.GenerateContentConfig(
+                response_modalities=["IMAGE"],
+                image_config=types.ImageConfig(aspect_ratio=self.aspect_ratio),
+            )
+
+            response = client.models.generate_content(
+                model=self.model,
+                contents=[prompt],  # type: ignore
+                config=cfg,
+            )
+
+            generated_images: List[Image] = []
+            response_str = ""
+
+            if not hasattr(response, "candidates") or not response.candidates:
+                logger.warning("No candidates in response")
+                return ToolResult(content="No images were generated in the response")
+
+            # Process each candidate
+            for candidate in response.candidates:
+                if not hasattr(candidate, "content") or not candidate.content or not candidate.content.parts:
+                    continue
+
+                for part in candidate.content.parts:
+                    if hasattr(part, "text") and part.text:
+                        response_str += part.text + "\n"
+
+                    if hasattr(part, "inline_data") and part.inline_data:
+                        try:
+                            # Extract image data from the blob
+                            image_data = part.inline_data.data
+                            mime_type = getattr(part.inline_data, "mime_type", "image/png")
+
+                            if image_data:
+                                pil_img = PILImage.open(BytesIO(image_data))
+
+                                # Save to buffer with proper format
+                                buffer = BytesIO()
+                                image_format = "PNG" if "png" in mime_type.lower() else "JPEG"
+                                pil_img.save(buffer, format=image_format)
+                                buffer.seek(0)
+
+                                agno_img = Image(
+                                    id=str(uuid4()),
+                                    content=buffer.getvalue(),
+                                    original_prompt=prompt,
+                                )
+                                generated_images.append(agno_img)
+
+                                log_debug(f"Successfully processed image with ID: {agno_img.id}")
+                                response_str += f"Image generated successfully (ID: {agno_img.id}).\n"
+
+                        except Exception as img_exc:
+                            logger.error(f"Failed to process image data: {img_exc}")
+                            response_str += f"Failed to process image: {img_exc}\n"
+
+            if hasattr(response, "usage_metadata") and response.usage_metadata:
+                log_debug(
+                    f"Token usage - Prompt: {response.usage_metadata.prompt_token_count}, "
+                    f"Response: {response.usage_metadata.candidates_token_count}, "
+                    f"Total: {response.usage_metadata.total_token_count}"
+                )
+
+            if generated_images:
+                return ToolResult(
+                    content=response_str.strip() or "Image(s) generated successfully",
+                    images=generated_images,
+                )
+            else:
+                return ToolResult(
+                    content=response_str.strip() or "No images were generated",
+                    images=None,
+                )
+
+        except Exception as exc:
+            logger.error(f"NanoBanana image generation failed: {exc}")
+            return ToolResult(content=f"Error generating image: {str(exc)}")

agno/tools/neo4j.py

@@ -0,0 +1,134 @@
+import os
+from typing import Any, List, Optional
+
+try:
+    from neo4j import GraphDatabase
+except ImportError:
+    raise ImportError("`neo4j` not installed. Please install using `pip install neo4j`")
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+
+class Neo4jTools(Toolkit):
+    def __init__(
+        self,
+        uri: Optional[str] = None,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        database: Optional[str] = None,
+        # Enable flags for <6 functions
+        enable_list_labels: bool = True,
+        enable_list_relationships: bool = True,
+        enable_get_schema: bool = True,
+        enable_run_cypher: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        """
+        Initialize the Neo4jTools toolkit.
+        Connection parameters (uri/user/password or host/port) can be provided.
+        If not provided, falls back to NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD env vars.
+
+        Args:
+            uri (Optional[str]): The Neo4j URI.
+            user (Optional[str]): The Neo4j username.
+            password (Optional[str]): The Neo4j password.
+            host (Optional[str]): The Neo4j host.
+            port (Optional[int]): The Neo4j port.
+            database (Optional[str]): The Neo4j database.
+            list_labels (bool): Whether to list node labels.
+            list_relationships (bool): Whether to list relationship types.
+            get_schema (bool): Whether to get the schema.
+            run_cypher (bool): Whether to run Cypher queries.
+            **kwargs: Additional keyword arguments.
+        """
+        # Determine the connection URI and credentials
+        uri = uri or os.getenv("NEO4J_URI", "bolt://localhost:7687")
+        user = user or os.getenv("NEO4J_USERNAME")
+        password = password or os.getenv("NEO4J_PASSWORD")
+
+        if user is None or password is None:
+            raise ValueError("Username or password for Neo4j not provided")
+
+        # Create the Neo4j driver
+        try:
+            self.driver = GraphDatabase.driver(uri, auth=(user, password))  # type: ignore
+            self.driver.verify_connectivity()
+            log_debug("Connected to Neo4j database")
+        except Exception as e:
+            logger.error(f"Failed to connect to Neo4j: {e}")
+            raise
+
+        self.database = database or "neo4j"
+
+        # Register toolkit methods as tools
+        tools: List[Any] = []
+        if all or enable_list_labels:
+            tools.append(self.list_labels)
+        if all or enable_list_relationships:
+            tools.append(self.list_relationship_types)
+        if all or enable_get_schema:
+            tools.append(self.get_schema)
+        if all or enable_run_cypher:
+            tools.append(self.run_cypher_query)
+        super().__init__(name="neo4j_tools", tools=tools, **kwargs)
+
+    def list_labels(self) -> list:
+        """
+        Retrieve all node labels present in the connected Neo4j database.
+        """
+        try:
+            log_debug("Listing node labels in Neo4j database")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.labels()")
+                labels = [record["label"] for record in result]
+            return labels
+        except Exception as e:
+            logger.error(f"Error listing labels: {e}")
+            return []
+
+    def list_relationship_types(self) -> list:
+        """
+        Retrieve all relationship types present in the connected Neo4j database.
+        """
+        try:
+            log_debug("Listing relationship types in Neo4j database")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.relationshipTypes()")
+                types = [record["relationshipType"] for record in result]
+            return types
+        except Exception as e:
+            logger.error(f"Error listing relationship types: {e}")
+            return []
+
+    def get_schema(self) -> list:
+        """
+        Retrieve a visualization of the database schema, including nodes and relationships.
+        """
+        try:
+            log_debug("Retrieving Neo4j schema visualization")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.schema.visualization()")
+                schema_data = result.data()
+            return schema_data
+        except Exception as e:
+            logger.error(f"Error getting Neo4j schema: {e}")
+            return []
+
+    def run_cypher_query(self, query: str) -> list:
+        """
+        Execute an arbitrary Cypher query against the connected Neo4j database.
+
+        Args:
+            query (str): The Cypher query string to execute.
+        """
+        try:
+            log_debug(f"Running Cypher query: {query}")
+            with self.driver.session(database=self.database) as session:
+                result = session.run(query)  # type: ignore[arg-type]
+                data = result.data()
+            return data
+        except Exception as e:
+            logger.error(f"Error running Cypher query: {e}")
+            return []

agno/tools/newspaper.py

@@ -1,4 +1,5 @@
 from agno.tools import Toolkit
+from agno.utils.log import log_debug
 
 try:
     from newspaper import Article
@@ -7,14 +8,23 @@ except ImportError:
 
 
 class NewspaperTools(Toolkit):
+    """
+    Newspaper is a tool for getting the text of an article from a URL.
+    Args:
+        get_article_text (bool): Whether to get the text of an article from a URL.
+    """
+
     def __init__(
         self,
-        get_article_text: bool = True,
+        enable_get_article_text: bool = True,
+        all: bool = False,
+        **kwargs,
     ):
-        super().__init__(name="newspaper_toolkit")
+        tools = []
+        if all or enable_get_article_text:
+            tools.append(self.get_article_text)
 
-        if get_article_text:
-            self.register(self.get_article_text)
+        super().__init__(name="newspaper_toolkit", tools=tools, **kwargs)
 
     def get_article_text(self, url: str) -> str:
         """Get the text of an article from a URL.
@@ -27,6 +37,7 @@ class NewspaperTools(Toolkit):
         """
 
         try:
+            log_debug(f"Reading news: {url}")
             article = Article(url)
             article.download()
             article.parse()

agno/tools/newspaper4k.py

@@ -2,7 +2,7 @@ import json
 from typing import Any, Dict, Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, logger
 
 try:
     import newspaper
@@ -11,18 +11,30 @@ except ImportError:
 
 
 class Newspaper4kTools(Toolkit):
+    """
+    Newspaper4kTools is a toolkit for getting the text of an article from a URL.
+    Args:
+        enable_read_article (bool): Whether to read an article from a URL.
+        include_summary (bool): Whether to include the summary of an article.
+        article_length (Optional[int]): The length of the article to read.
+    """
+
     def __init__(
         self,
-        read_article: bool = True,
         include_summary: bool = False,
         article_length: Optional[int] = None,
+        enable_read_article: bool = True,
+        all: bool = False,
+        **kwargs,
     ):
-        super().__init__(name="newspaper_tools")
-
         self.include_summary: bool = include_summary
         self.article_length: Optional[int] = article_length
-        if read_article:
-            self.register(self.read_article)
+
+        tools = []
+        if all or enable_read_article:
+            tools.append(self.read_article)
+
+        super().__init__(name="newspaper4k_tools", tools=tools, **kwargs)
 
     def get_article_data(self, url: str) -> Optional[Dict[str, Any]]:
         """Read and get article data from a URL.
@@ -68,6 +80,7 @@ class Newspaper4kTools(Toolkit):
         """
 
         try:
+            log_debug(f"Reading news: {url}")
             article_data = self.get_article_data(url)
             if not article_data:
                 return f"Error reading article from {url}: No data found."

agno/tools/notion.py

@@ -0,0 +1,204 @@
+import json
+import os
+from typing import Any, Dict, List, Optional, cast
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+try:
+    from notion_client import Client
+except ImportError:
+    raise ImportError("`notion-client` not installed. Please install using `pip install notion-client`")
+
+
+class NotionTools(Toolkit):
+    """
+    Notion toolkit for creating and managing Notion pages.
+
+    Args:
+        api_key (Optional[str]): Notion API key (integration token). If not provided, uses NOTION_API_KEY env var.
+        database_id (Optional[str]): The ID of the database to work with. If not provided, uses NOTION_DATABASE_ID env var.
+        enable_create_page (bool): Enable creating pages. Default is True.
+        enable_update_page (bool): Enable updating pages. Default is True.
+        enable_search_pages (bool): Enable searching pages. Default is True.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        database_id: Optional[str] = None,
+        enable_create_page: bool = True,
+        enable_update_page: bool = True,
+        enable_search_pages: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.api_key = api_key or os.getenv("NOTION_API_KEY")
+        self.database_id = database_id or os.getenv("NOTION_DATABASE_ID")
+
+        if not self.api_key:
+            raise ValueError(
+                "Notion API key is required. Either pass api_key parameter or set NOTION_API_KEY environment variable."
+            )
+        if not self.database_id:
+            raise ValueError(
+                "Notion database ID is required. Either pass database_id parameter or set NOTION_DATABASE_ID environment variable."
+            )
+
+        self.client = Client(auth=self.api_key)
+
+        tools: List[Any] = []
+        if all or enable_create_page:
+            tools.append(self.create_page)
+        if all or enable_update_page:
+            tools.append(self.update_page)
+        if all or enable_search_pages:
+            tools.append(self.search_pages)
+
+        super().__init__(name="notion_tools", tools=tools, **kwargs)
+
+    def create_page(self, title: str, tag: str, content: str) -> str:
+        """Create a new page in the Notion database with a title, tag, and content.
+
+        Args:
+            title (str): The title of the page
+            tag (str): The tag/category for the page (e.g., travel, tech, general-blogs, fashion, documents)
+            content (str): The content to add to the page
+
+        Returns:
+            str: JSON string with page creation details
+        """
+        try:
+            log_debug(f"Creating Notion page with title: {title}, tag: {tag}")
+
+            # Create the page in the database
+            new_page = cast(
+                Dict[str, Any],
+                self.client.pages.create(
+                    parent={"database_id": self.database_id},
+                    properties={"Name": {"title": [{"text": {"content": title}}]}, "Tag": {"select": {"name": tag}}},
+                    children=[
+                        {
+                            "object": "block",
+                            "type": "paragraph",
+                            "paragraph": {"rich_text": [{"type": "text", "text": {"content": content}}]},
+                        }
+                    ],
+                ),
+            )
+
+            result = {"success": True, "page_id": new_page["id"], "url": new_page["url"], "title": title, "tag": tag}
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            logger.exception(e)
+            return json.dumps({"success": False, "error": str(e)})
+
+    def update_page(self, page_id: str, content: str) -> str:
+        """Add content to an existing Notion page.
+
+        Args:
+            page_id (str): The ID of the page to update
+            content (str): The content to append to the page
+
+        Returns:
+            str: JSON string with update status
+        """
+        try:
+            log_debug(f"Updating Notion page: {page_id}")
+
+            # Append content to the page
+            self.client.blocks.children.append(
+                block_id=page_id,
+                children=[
+                    {
+                        "object": "block",
+                        "type": "paragraph",
+                        "paragraph": {"rich_text": [{"type": "text", "text": {"content": content}}]},
+                    }
+                ],
+            )
+
+            result = {"success": True, "page_id": page_id, "message": "Content added successfully"}
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            logger.exception(e)
+            return json.dumps({"success": False, "error": str(e)})
+
+    def search_pages(self, tag: str) -> str:
+        """Search for pages in the database by tag.
+
+        Args:
+            tag (str): The tag to search for
+
+        Returns:
+            str: JSON string with list of matching pages
+        """
+        try:
+            log_debug(f"Searching for pages with tag: {tag}")
+
+            import httpx
+
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Notion-Version": "2022-06-28",
+                "Content-Type": "application/json",
+            }
+
+            payload = {"filter": {"property": "Tag", "select": {"equals": tag}}}
+
+            # The SDK client does not support the query method
+            response = httpx.post(
+                f"https://api.notion.com/v1/databases/{self.database_id}/query",
+                headers=headers,
+                json=payload,
+                timeout=30.0,
+            )
+
+            if response.status_code != 200:
+                return json.dumps(
+                    {
+                        "success": False,
+                        "error": f"API request failed with status {response.status_code}",
+                        "message": response.text,
+                    }
+                )
+
+            data = response.json()
+            pages = []
+
+            for page in data.get("results", []):
+                try:
+                    page_title = "Untitled"
+                    if page.get("properties", {}).get("Name", {}).get("title"):
+                        page_title = page["properties"]["Name"]["title"][0]["text"]["content"]
+
+                    page_tag = None
+                    if page.get("properties", {}).get("Tag", {}).get("select"):
+                        page_tag = page["properties"]["Tag"]["select"]["name"]
+
+                    page_info = {
+                        "page_id": page["id"],
+                        "title": page_title,
+                        "tag": page_tag,
+                        "url": page.get("url", ""),
+                    }
+                    pages.append(page_info)
+                except Exception as page_error:
+                    log_debug(f"Error parsing page: {page_error}")
+                    continue
+
+            result = {"success": True, "count": len(pages), "pages": pages}
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            logger.exception(e)
+            return json.dumps(
+                {
+                    "success": False,
+                    "error": str(e),
+                    "message": "Failed to search pages. Make sure the database is shared with the integration and has a 'Tag' property.",
+                }
+            )