agno 2.2.13__py3-none-any.whl

agno/tools/crawl4ai.py

@@ -0,0 +1,158 @@
+import asyncio
+from typing import Any, Dict, List, Optional, Union
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_warning
+
+try:
+    from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig
+except ImportError:
+    raise ImportError("`crawl4ai` not installed. Please install using `pip install crawl4ai`")
+
+
+class Crawl4aiTools(Toolkit):
+    def __init__(
+        self,
+        max_length: Optional[int] = 5000,
+        timeout: int = 60,
+        use_pruning: bool = False,
+        pruning_threshold: float = 0.48,
+        bm25_threshold: float = 1.0,
+        headless: bool = True,
+        wait_until: str = "domcontentloaded",
+        enable_crawl: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        tools = []
+        if all or enable_crawl:
+            tools.append(self.crawl)
+
+        super().__init__(name="crawl4ai_tools", tools=tools, **kwargs)
+        self.max_length = max_length
+        self.timeout = timeout
+        self.use_pruning = use_pruning
+        self.pruning_threshold = pruning_threshold
+        self.bm25_threshold = bm25_threshold
+        self.wait_until = wait_until
+        self.headless = headless
+
+    def _build_config(self, search_query: Optional[str] = None) -> Dict[str, Any]:
+        """Build CrawlerRunConfig parameters from toolkit settings."""
+        config_params = {
+            "page_timeout": self.timeout * 1000,  # Convert to milliseconds
+            "wait_until": self.wait_until,
+            "cache_mode": "bypass",  # Don't use cache for fresh results
+            "verbose": False,
+        }
+
+        # Handle content filtering
+        if self.use_pruning or search_query:
+            try:
+                from crawl4ai.content_filter_strategy import BM25ContentFilter, PruningContentFilter
+                from crawl4ai.markdown_generation_strategy import DefaultMarkdownGenerator
+
+                if search_query:
+                    # Use BM25 for query-specific extraction
+                    content_filter = BM25ContentFilter(user_query=search_query, bm25_threshold=self.bm25_threshold)
+                    log_debug(f"Using BM25ContentFilter for query: {search_query}")
+                else:
+                    # Use pruning for general cleanup
+                    content_filter = PruningContentFilter(
+                        threshold=self.pruning_threshold, threshold_type="fixed", min_word_threshold=2
+                    )
+                    log_debug("Using PruningContentFilter for general cleanup")
+
+                config_params["markdown_generator"] = DefaultMarkdownGenerator(content_filter=content_filter)
+                log_debug("Using DefaultMarkdownGenerator with content_filter")
+            except ImportError:
+                # If advanced features not available, continue without them
+                log_warning("crawl4ai.content_filter_strategy or crawl4ai.markdown_generation_strategy not installed")
+                pass
+
+        return config_params
+
+    def crawl(self, url: Union[str, List[str]], search_query: Optional[str] = None) -> Union[str, Dict[str, str]]:
+        """
+        Crawl URLs and extract their text content.
+
+        Args:
+            url: Single URL string or list of URLs to crawl
+            search_query: Optional query string to filter content using BM25 algorithm
+
+        Returns:
+            The extracted text content from the URL(s)
+        """
+        if not url:
+            return "Error: No URL provided"
+
+        # Handle single URL
+        if isinstance(url, str):
+            return asyncio.run(self._async_crawl(url, search_query))
+
+        # Handle multiple URLs
+        results = {}
+        for single_url in url:
+            results[single_url] = asyncio.run(self._async_crawl(single_url, search_query))
+        return results
+
+    async def _async_crawl(self, url: str, search_query: Optional[str] = None) -> str:
+        """Crawl a single URL and extract content."""
+        try:
+            # Use BrowserConfig to suppress crawl4ai logs
+            browser_config = BrowserConfig(
+                headless=self.headless,
+                verbose=False,
+            )
+
+            async with AsyncWebCrawler(config=browser_config) as crawler:
+                # Build configuration from parameters
+                config_params = self._build_config(search_query)
+
+                config = CrawlerRunConfig(**config_params)
+                log_debug(f"Crawling {url} with config: {config}")
+                result = await crawler.arun(url=url, config=config)
+
+                # Process the result
+                if not result:
+                    return "Error: No content found"
+
+                log_debug(f"Result attributes: {dir(result)}")
+                log_debug(f"Result success: {getattr(result, 'success', 'N/A')}")
+
+                # Try to get markdown content
+                content = ""
+                if hasattr(result, "fit_markdown") and result.fit_markdown:
+                    content = result.fit_markdown
+                    log_debug("Using fit_markdown")
+                elif hasattr(result, "markdown") and result.markdown:
+                    if hasattr(result.markdown, "raw_markdown"):
+                        content = result.markdown.raw_markdown
+                        log_debug("Using markdown.raw_markdown")
+                    else:
+                        content = str(result.markdown)
+                        log_debug("Using str(markdown)")
+                else:
+                    # Try to get any text content
+                    if hasattr(result, "text"):
+                        content = result.text
+                        log_debug("Using text attribute")
+                    elif hasattr(result, "html"):
+                        log_warning("Only HTML available, no markdown extracted")
+                        return "Error: Could not extract markdown from page"
+
+                if not content:
+                    log_warning(f"No content extracted. Result type: {type(result)}")
+                    return "Error: No readable content extracted"
+
+                log_debug(f"Extracted content length: {len(content)}")
+
+                # Truncate if needed
+                if self.max_length and len(content) > self.max_length:
+                    content = content[: self.max_length] + "..."
+
+                return content
+
+        except Exception as e:
+            log_warning(f"Exception during crawl: {str(e)}")
+            return f"Error crawling {url}: {str(e)}"

agno/tools/csv_toolkit.py

@@ -0,0 +1,185 @@
+import csv
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_info, logger
+
+
+class CsvTools(Toolkit):
+    def __init__(
+        self,
+        csvs: Optional[List[Union[str, Path]]] = None,
+        row_limit: Optional[int] = None,
+        duckdb_connection: Optional[Any] = None,
+        duckdb_kwargs: Optional[Dict[str, Any]] = None,
+        enable_read_csv_file: bool = True,
+        enable_list_csv_files: bool = True,
+        enable_get_columns: bool = True,
+        enable_query_csv_file: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.csvs: List[Path] = []
+        if csvs:
+            for _csv in csvs:
+                if isinstance(_csv, str):
+                    self.csvs.append(Path(_csv))
+                elif isinstance(_csv, Path):
+                    self.csvs.append(_csv)
+                else:
+                    raise ValueError(f"Invalid csv file: {_csv}")
+        self.row_limit = row_limit
+        self.duckdb_connection: Optional[Any] = duckdb_connection
+        self.duckdb_kwargs: Optional[Dict[str, Any]] = duckdb_kwargs
+
+        tools: List[Any] = []
+        if all or enable_read_csv_file:
+            tools.append(self.read_csv_file)
+        if all or enable_list_csv_files:
+            tools.append(self.list_csv_files)
+        if all or enable_get_columns:
+            tools.append(self.get_columns)
+        if all or enable_query_csv_file:
+            try:
+                import duckdb  # noqa: F401
+
+                tools.append(self.query_csv_file)
+            except ImportError:
+                logger.warning("`duckdb` not installed. Query functionality disabled.")
+
+        super().__init__(name="csv_tools", tools=tools, **kwargs)
+
+    def list_csv_files(self) -> str:
+        """Returns a list of available csv files
+
+        Returns:
+            str: List of available csv files
+        """
+        return json.dumps([_csv.stem for _csv in self.csvs])
+
+    def read_csv_file(self, csv_name: str, row_limit: Optional[int] = None) -> str:
+        """Use this function to read the contents of a csv file `name` without the extension.
+
+        Args:
+            csv_name (str): The name of the csv file to read without the extension.
+            row_limit (Optional[int]): The number of rows to return. None returns all rows. Defaults to None.
+
+        Returns:
+            str: The contents of the csv file if successful, otherwise returns an error message.
+        """
+        try:
+            if csv_name not in [_csv.stem for _csv in self.csvs]:
+                return f"File: {csv_name} not found, please use one of {self.list_csv_files()}"
+
+            log_info(f"Reading file: {csv_name}")
+            file_path = [_csv for _csv in self.csvs if _csv.stem == csv_name][0]
+
+            # Read the csv file
+            csv_data = []
+            _row_limit = row_limit or self.row_limit
+            with open(str(file_path), newline="") as csvfile:
+                reader = csv.DictReader(csvfile)
+                if _row_limit is not None:
+                    csv_data = [row for row in reader][:_row_limit]
+                else:
+                    csv_data = [row for row in reader]
+            return json.dumps(csv_data)
+        except Exception as e:
+            logger.error(f"Error reading csv: {e}")
+            return f"Error reading csv: {e}"
+
+    def get_columns(self, csv_name: str) -> str:
+        """Use this function to get the columns of the csv file `csv_name` without the extension.
+
+        Args:
+            csv_name (str): The name of the csv file to get the columns from without the extension.
+
+        Returns:
+            str: The columns of the csv file if successful, otherwise returns an error message.
+        """
+        try:
+            if csv_name not in [_csv.stem for _csv in self.csvs]:
+                return f"File: {csv_name} not found, please use one of {self.list_csv_files()}"
+
+            log_info(f"Reading columns from file: {csv_name}")
+            file_path = [_csv for _csv in self.csvs if _csv.stem == csv_name][0]
+
+            # Get the columns of the csv file
+            with open(str(file_path), newline="") as csvfile:
+                reader = csv.DictReader(csvfile)
+                columns = reader.fieldnames
+
+            return json.dumps(columns)
+        except Exception as e:
+            logger.error(f"Error getting columns: {e}")
+            return f"Error getting columns: {e}"
+
+    def query_csv_file(self, csv_name: str, sql_query: str) -> str:
+        """Use this function to run a SQL query on csv file `csv_name` without the extension.
+        The Table name is the name of the csv file without the extension.
+        The SQL Query should be a valid DuckDB SQL query.
+        Always wrap column names with double quotes if they contain spaces or special characters
+        Remember to escape the quotes in th e JSON string (use \")
+        Use single quotes for string values
+
+        Args:
+            csv_name (str): The name of the csv file to query
+            sql_query (str): The SQL Query to run on the csv file.
+
+        Returns:
+            str: The query results if successful, otherwise returns an error message.
+        """
+        try:
+            import duckdb
+
+            if csv_name not in [_csv.stem for _csv in self.csvs]:
+                return f"File: {csv_name} not found, please use one of {self.list_csv_files()}"
+
+            # Load the csv file into duckdb
+            log_info(f"Loading csv file: {csv_name}")
+            file_path = [_csv for _csv in self.csvs if _csv.stem == csv_name][0]
+
+            # Create duckdb connection
+            con = self.duckdb_connection
+            if not self.duckdb_connection:
+                con = duckdb.connect(**(self.duckdb_kwargs or {}))
+            if con is None:
+                logger.error("Error connecting to DuckDB")
+                return "Error connecting to DuckDB, please check the connection."
+
+            # Create a table from the csv file
+            con.execute(
+                f"CREATE TABLE {csv_name} AS SELECT * FROM read_csv('{file_path}', ignore_errors=false, auto_detect=true)"
+            )
+
+            # -*- Format the SQL Query
+            # Remove backticks
+            formatted_sql = sql_query.replace("`", "")
+            # If there are multiple statements, only run the first one
+            formatted_sql = formatted_sql.split(";")[0]
+            # -*- Run the SQL Query
+            log_info(f"Running query: {formatted_sql}")
+            query_result = con.sql(formatted_sql)
+            result_output = "No output"
+            if query_result is not None:
+                try:
+                    results_as_python_objects = query_result.fetchall()
+                    result_rows = []
+                    for row in results_as_python_objects:
+                        if len(row) == 1:
+                            result_rows.append(str(row[0]))
+                        else:
+                            result_rows.append(",".join(str(x) for x in row))
+
+                    result_data = "\n".join(result_rows)
+                    result_output = ",".join(query_result.columns) + "\n" + result_data
+                except AttributeError:
+                    result_output = str(query_result)
+
+            log_debug(f"Query result: {result_output}")
+            return result_output
+        except Exception as e:
+            logger.error(f"Error querying csv: {e}")
+            return f"Error querying csv: {e}"

agno/tools/dalle.py

@@ -0,0 +1,110 @@
+from os import getenv
+from typing import Any, List, Literal, 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 openai import OpenAI
+    from openai.types.images_response import ImagesResponse
+except ImportError:
+    raise ImportError("`openai` not installed. Please install using `pip install openai`")
+
+
+class DalleTools(Toolkit):
+    def __init__(
+        self,
+        model: str = "dall-e-3",
+        n: int = 1,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]] = "1024x1024",
+        quality: Literal["standard", "hd"] = "standard",
+        style: Literal["vivid", "natural"] = "vivid",
+        api_key: Optional[str] = None,
+        enable_create_image: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.model = model
+        self.n = n
+        self.size = size
+        self.quality = quality
+        self.style = style
+        self.api_key = api_key or getenv("OPENAI_API_KEY")
+
+        # Validations
+        if model not in ["dall-e-3", "dall-e-2"]:
+            raise ValueError("Invalid model. Please choose from 'dall-e-3' or 'dall-e-2'.")
+        if size not in ["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"]:
+            raise ValueError(
+                "Invalid size. Please choose from '256x256', '512x512', '1024x1024', '1792x1024', '1024x1792'."
+            )
+        if quality not in ["standard", "hd"]:
+            raise ValueError("Invalid quality. Please choose from 'standard' or 'hd'.")
+        if not isinstance(n, int) or n <= 0:
+            raise ValueError("Invalid number of images. Please provide a positive integer.")
+        if model == "dall-e-3" and n > 1:
+            raise ValueError("Dall-e-3 only supports a single image generation.")
+
+        if not self.api_key:
+            logger.error("OPENAI_API_KEY not set. Please set the OPENAI_API_KEY environment variable.")
+
+        tools: List[Any] = []
+        if all or enable_create_image:
+            tools.append(self.create_image)
+
+        super().__init__(name="dalle", tools=tools, **kwargs)
+
+        # TODO:
+        # - Add support for response_format
+        # - Add support for saving images
+        # - Add support for editing images
+
+    def create_image(self, prompt: str) -> ToolResult:
+        """Use this function to generate an image for a prompt.
+
+        Args:
+            prompt (str): A text description of the desired image.
+
+        Returns:
+            ToolResult: Result containing the message and generated images.
+        """
+        if not self.api_key:
+            return ToolResult(content="Please set the OPENAI_API_KEY")
+
+        try:
+            client = OpenAI(api_key=self.api_key)
+            log_debug(f"Generating image using prompt: {prompt}")
+            response: ImagesResponse = client.images.generate(
+                prompt=prompt,
+                model=self.model,
+                n=self.n,
+                quality=self.quality,
+                size=self.size,
+                style=self.style,
+            )
+            log_debug("Image generated successfully")
+
+            generated_images = []
+            response_str = ""
+            if response.data:
+                for img in response.data:
+                    if img.url:
+                        image = Image(
+                            id=str(uuid4()),
+                            url=img.url,
+                            original_prompt=prompt,
+                            revised_prompt=img.revised_prompt,
+                        )
+                        generated_images.append(image)
+                        response_str += f"Image has been generated at the URL {img.url}\n"
+
+            return ToolResult(
+                content=response_str or "No images were generated",
+                images=generated_images if generated_images else None,
+            )
+        except Exception as e:
+            logger.error(f"Failed to generate image: {e}")
+            return ToolResult(content=f"Error: {e}")