agno 1.7.11__py3-none-any.whl → 1.8.0__py3-none-any.whl

agno/tools/github.py

@@ -1698,20 +1698,32 @@ class GithubTools(Toolkit):
             log_debug(f"Final search query: {search_query}")
             code_results = self.g.search_code(search_query)
 
-            # Process results
-            results = []
-            # Limit to 50 results to prevent timeouts
-            for code in code_results[:50]:
-                code_info = {
-                    "repository": code.repository.full_name,
-                    "path": code.path,
-                    "name": code.name,
-                    "sha": code.sha,
-                    "html_url": code.html_url,
-                    "git_url": code.git_url,
-                    "score": code.score,
-                }
-                results.append(code_info)
+            results: list[dict] = []
+            limit = 60
+            max_pages = 2  # GitHub returns 30 items per page, so 2 pages covers our limit
+            page_index = 0
+
+            while len(results) < limit and page_index < max_pages:
+                # Fetch one page of results from GitHub API
+                page_items = code_results.get_page(page_index)
+
+                # Stop if no more results available
+                if not page_items:
+                    break
+
+                # Process each code result in the current page
+                for code in page_items:
+                    code_info = {
+                        "repository": code.repository.full_name,
+                        "path": code.path,
+                        "name": code.name,
+                        "sha": code.sha,
+                        "html_url": code.html_url,
+                        "git_url": code.git_url,
+                        "score": code.score,
+                    }
+                    results.append(code_info)
+                page_index += 1
 
             # Return search results
             return json.dumps(

agno/tools/memori.py

@@ -0,0 +1,387 @@
+import json
+from typing import Any, Dict, Optional
+
+from agno.agent import Agent
+from agno.tools.toolkit import Toolkit
+from agno.utils.log import log_debug, log_error, log_info, log_warning
+
+try:
+    from memori import Memori, create_memory_tool
+except ImportError:
+    raise ImportError("`memorisdk` package not found. Please install it with `pip install memorisdk`")
+
+
+class MemoriTools(Toolkit):
+    """
+    Memori ToolKit for Agno Agents and Teams, providing persistent memory capabilities.
+
+    This toolkit integrates Memori's memory system with Agno, allowing Agents and Teams to:
+    - Store and retrieve conversation history
+    - Search through past interactions
+    - Maintain user preferences and context
+    - Build long-term memory across sessions
+
+    Requirements:
+        - pip install memorisdk
+        - Database connection string (SQLite, PostgreSQL, etc.)
+
+    Example:
+        ```python
+        from agno.tools.memori import MemoriTools
+
+        # Initialize with SQLite (default)
+        memori_tools = MemoriTools(
+            database_connect="sqlite:///agent_memory.db",
+            namespace="my_agent",
+            auto_ingest=True  # Automatically ingest conversations
+        )
+
+        # Add to agent
+        agent = Agent(
+            model=OpenAIChat(),
+            tools=[memori_tools],
+            description="An AI assistant with persistent memory"
+        )
+        ```
+    """
+
+    def __init__(
+        self,
+        database_connect: Optional[str] = None,
+        namespace: Optional[str] = None,
+        conscious_ingest: bool = True,
+        auto_ingest: bool = True,
+        verbose: bool = False,
+        config: Optional[Dict[str, Any]] = None,
+        auto_enable: bool = True,
+        **kwargs,
+    ):
+        """
+        Initialize Memori toolkit.
+
+        Args:
+            database_connect: Database connection string (e.g., "sqlite:///memory.db")
+            namespace: Namespace for organizing memories (e.g., "agent_v1", "user_session")
+            conscious_ingest: Whether to use conscious memory ingestion
+            auto_ingest: Whether to automatically ingest conversations into memory
+            verbose: Enable verbose logging from Memori
+            config: Additional Memori configuration
+            auto_enable: Automatically enable the memory system on initialization
+            **kwargs: Additional arguments passed to Toolkit base class
+        """
+        super().__init__(
+            name="memori_tools",
+            tools=[
+                self.search_memory,
+                self.record_conversation,
+                self.get_memory_stats,
+            ],
+            **kwargs,
+        )
+
+        # Set default database connection if not provided
+        if not database_connect:
+            sqlite_db = "sqlite:///agno_memori_memory.db"
+            log_info(f"No database connection provided, using default SQLite database at {sqlite_db}")
+            database_connect = sqlite_db
+
+        self.database_connect = database_connect
+        self.namespace = namespace or "agno_default"
+        self.conscious_ingest = conscious_ingest
+        self.auto_ingest = auto_ingest
+        self.verbose = verbose
+        self.config = config or {}
+
+        try:
+            # Initialize Memori memory system
+            log_debug(f"Initializing Memori with database: {self.database_connect}")
+            self.memory_system = Memori(
+                database_connect=self.database_connect,
+                conscious_ingest=self.conscious_ingest,
+                auto_ingest=self.auto_ingest,
+                verbose=self.verbose,
+                namespace=self.namespace,
+                **self.config,
+            )
+
+            # Enable the memory system if auto_enable is True
+            if auto_enable:
+                self.memory_system.enable()
+                log_debug("Memori memory system enabled")
+
+            # Create the memory tool for internal use
+            self._memory_tool = create_memory_tool(self.memory_system)
+
+        except Exception as e:
+            log_error(f"Failed to initialize Memori: {e}")
+            raise ConnectionError("Failed to initialize Memori memory system") from e
+
+    def search_memory(
+        self,
+        agent: Agent,
+        query: str,
+        limit: Optional[int] = None,
+    ) -> str:
+        """
+        Search the Agent's memory for past conversations and information.
+
+        This performs semantic search across all stored memories to find
+        relevant information based on the provided query.
+
+        Args:
+            query: What to search for in memory (e.g., "past conversations about AI", "user preferences")
+            limit: Maximum number of results to return (optional)
+
+        Returns:
+            str: JSON-encoded search results or error message
+
+        Example:
+            search_memory("user's favorite programming languages")
+            search_memory("previous discussions about machine learning")
+        """
+        try:
+            if not query.strip():
+                return json.dumps({"error": "Please provide a search query"})
+
+            log_debug(f"Searching memory for: {query}")
+
+            # Execute search using Memori's memory tool
+            result = self._memory_tool.execute(query=query.strip())
+
+            if result:
+                # If limit is specified, truncate results
+                if limit and isinstance(result, list):
+                    result = result[:limit]
+
+                return json.dumps(
+                    {
+                        "success": True,
+                        "query": query,
+                        "results": result,
+                        "count": len(result) if isinstance(result, list) else 1,
+                    }
+                )
+            else:
+                return json.dumps(
+                    {
+                        "success": True,
+                        "query": query,
+                        "results": [],
+                        "count": 0,
+                        "message": "No relevant memories found",
+                    }
+                )
+
+        except Exception as e:
+            log_error(f"Error searching memory: {e}")
+            return json.dumps({"success": False, "error": f"Memory search error: {str(e)}"})
+
+    def record_conversation(self, agent: Agent, content: str) -> str:
+        """
+        Add important information or facts to memory.
+
+        Use this tool to store important information, user preferences, facts, or context that should be remembered
+        for future conversations.
+
+        Args:
+            content: The information/facts to store in memory
+
+        Returns:
+            str: Success message or error details
+
+        Example:
+            record_conversation("User prefers Python over JavaScript")
+            record_conversation("User is working on an e-commerce project using Django")
+            record_conversation("User's name is John and they live in NYC")
+        """
+        try:
+            if not content.strip():
+                return json.dumps({"success": False, "error": "Content cannot be empty"})
+
+            log_debug(f"Adding conversation: {content}")
+
+            # Extract the actual AI response from the agent's conversation history
+            ai_output = "I've noted this information and will remember it."
+
+            self.memory_system.record_conversation(user_input=content, ai_output=str(ai_output))
+            return json.dumps(
+                {
+                    "success": True,
+                    "message": "Memory added successfully via conversation recording",
+                    "content_length": len(content),
+                }
+            )
+
+        except Exception as e:
+            log_error(f"Error adding memory: {e}")
+            return json.dumps({"success": False, "error": f"Failed to add memory: {str(e)}"})
+
+    def get_memory_stats(
+        self,
+        agent: Agent,
+    ) -> str:
+        """
+        Get statistics about the memory system.
+
+        Returns information about the current state of the memory system,
+        including total memories, memory distribution by retention type
+        (short-term vs long-term), and system configuration.
+
+        Returns:
+            str: JSON-encoded memory statistics
+
+        Example:
+            Returns statistics like:
+            {
+                "success": true,
+                "total_memories": 42,
+                "memories_by_retention": {
+                    "short_term": 5,
+                    "long_term": 37
+                },
+                "namespace": "my_agent",
+                "conscious_ingest": true,
+                "auto_ingest": true,
+                "memory_system_enabled": true
+            }
+        """
+        try:
+            log_debug("Retrieving memory statistics")
+
+            # Base stats about the system configuration
+            stats = {
+                "success": True,
+                "namespace": self.namespace,
+                "database_connect": self.database_connect,
+                "conscious_ingest": self.conscious_ingest,
+                "auto_ingest": self.auto_ingest,
+                "verbose": self.verbose,
+                "memory_system_enabled": hasattr(self.memory_system, "_enabled") and self.memory_system._enabled,
+            }
+
+            # Get Memori's built-in memory statistics
+            try:
+                if hasattr(self.memory_system, "get_memory_stats"):
+                    # Use the get_memory_stats method as shown in the example
+                    memori_stats = self.memory_system.get_memory_stats()
+
+                    # Add the Memori-specific stats to our response
+                    if isinstance(memori_stats, dict):
+                        # Include total memories
+                        if "total_memories" in memori_stats:
+                            stats["total_memories"] = memori_stats["total_memories"]
+
+                        # Include memory distribution by retention type
+                        if "memories_by_retention" in memori_stats:
+                            stats["memories_by_retention"] = memori_stats["memories_by_retention"]
+
+                            # Also add individual counts for convenience
+                            retention_info = memori_stats["memories_by_retention"]
+                            stats["short_term_memories"] = retention_info.get("short_term", 0)
+                            stats["long_term_memories"] = retention_info.get("long_term", 0)
+
+                        # Include any other available stats
+                        for key, value in memori_stats.items():
+                            if key not in stats:
+                                stats[key] = value
+
+                    log_debug(
+                        f"Retrieved memory stats: total={stats.get('total_memories', 0)}, "
+                        f"short_term={stats.get('short_term_memories', 0)}, "
+                        f"long_term={stats.get('long_term_memories', 0)}"
+                    )
+
+                else:
+                    log_debug("get_memory_stats method not available, providing basic stats only")
+                    stats["total_memories"] = 0
+                    stats["memories_by_retention"] = {"short_term": 0, "long_term": 0}
+                    stats["short_term_memories"] = 0
+                    stats["long_term_memories"] = 0
+
+            except Exception as e:
+                log_debug(f"Could not retrieve detailed memory stats: {e}")
+                # Provide basic stats if detailed stats fail
+                stats["total_memories"] = 0
+                stats["memories_by_retention"] = {"short_term": 0, "long_term": 0}
+                stats["short_term_memories"] = 0
+                stats["long_term_memories"] = 0
+                stats["stats_warning"] = "Detailed memory statistics not available"
+
+            return json.dumps(stats)
+
+        except Exception as e:
+            log_error(f"Error getting memory stats: {e}")
+            return json.dumps({"success": False, "error": f"Failed to get memory statistics: {str(e)}"})
+
+    def enable_memory_system(self) -> bool:
+        """Enable the Memori memory system."""
+        try:
+            self.memory_system.enable()
+            log_debug("Memori memory system enabled")
+            return True
+        except Exception as e:
+            log_error(f"Failed to enable memory system: {e}")
+            return False
+
+    def disable_memory_system(self) -> bool:
+        """Disable the Memori memory system."""
+        try:
+            if hasattr(self.memory_system, "disable"):
+                self.memory_system.disable()
+                log_debug("Memori memory system disabled")
+                return True
+            else:
+                log_warning("Memory system disable method not available")
+                return False
+        except Exception as e:
+            log_error(f"Failed to disable memory system: {e}")
+            return False
+
+
+def create_memori_search_tool(memori_toolkit: MemoriTools):
+    """
+    Create a standalone memory search function for use with Agno agents.
+
+    This is a convenience function that creates a memory search tool similar
+    to the pattern shown in the Memori example code.
+
+    Args:
+        memori_toolkit: An initialized MemoriTools instance
+
+    Returns:
+        Callable: A memory search function that can be used as an agent tool
+
+    Example:
+        ```python
+        memori_tools = MemoriTools(database_connect="sqlite:///memory.db")
+        search_tool = create_memori_search_tool(memori_tools)
+
+        agent = Agent(
+            model=OpenAIChat(),
+            tools=[search_tool],
+            description="Agent with memory search capability"
+        )
+        ```
+    """
+
+    def search_memory(query: str) -> str:
+        """
+        Search the agent's memory for past conversations and information.
+
+        Args:
+            query: What to search for in memory
+
+        Returns:
+            str: Search results or error message
+        """
+        try:
+            if not query.strip():
+                return "Please provide a search query"
+
+            result = memori_toolkit._memory_tool.execute(query=query.strip())
+            return str(result) if result else "No relevant memories found"
+
+        except Exception as e:
+            return f"Memory search error: {str(e)}"
+
+    return search_memory

agno/tools/scrapegraph.py

@@ -22,6 +22,7 @@ class ScrapeGraphTools(Toolkit):
         markdownify: bool = False,
         crawl: bool = False,
         searchscraper: bool = False,
+        agentic_crawler: bool = False,
         **kwargs,
     ):
         self.api_key: Optional[str] = api_key or os.getenv("SGAI_API_KEY")
@@ -41,6 +42,8 @@ class ScrapeGraphTools(Toolkit):
             tools.append(self.crawl)
         if searchscraper:
             tools.append(self.searchscraper)
+        if agentic_crawler:
+            tools.append(self.agentic_crawler)
 
         super().__init__(name="scrapegraph_tools", tools=tools, **kwargs)
 
@@ -110,6 +113,68 @@ class ScrapeGraphTools(Toolkit):
         except Exception as e:
             return json.dumps({"error": str(e)})
 
+    def agentic_crawler(
+        self,
+        url: str,
+        steps: List[str],
+        use_session: bool = True,
+        user_prompt: Optional[str] = None,
+        output_schema: Optional[dict] = None,
+        ai_extraction: bool = False,
+    ) -> str:
+        """Perform agentic crawling with automated browser actions and optional AI extraction.
+
+        This tool can:
+        1. Navigate to a website
+        2. Perform a series of automated actions (like filling forms, clicking buttons)
+        3. Extract the resulting HTML content as markdown
+        4. Optionally use AI to extract structured data
+
+        Args:
+            url (str): The URL to scrape
+            steps (List[str]): List of steps to perform on the webpage (e.g., ["Type email in input box", "click login"])
+            use_session (bool): Whether to use session for the scraping (default: True)
+            user_prompt (Optional[str]): Prompt for AI extraction (only used when ai_extraction=True)
+            output_schema (Optional[dict]): Schema for structured data extraction (only used when ai_extraction=True)
+            ai_extraction (bool): Whether to use AI for data extraction from the scraped content (default: False)
+
+        Returns:
+            JSON string containing the scraping results, including request_id, status, and extracted data
+        """
+        try:
+            # Validate required parameters for AI extraction
+            if ai_extraction and not user_prompt:
+                return json.dumps({"error": "user_prompt is required when ai_extraction=True"})
+
+            # Validate URL format
+            if not url.strip():
+                return json.dumps({"error": "URL cannot be empty"})
+            if not (url.startswith("http://") or url.startswith("https://")):
+                return json.dumps({"error": "Invalid URL - must start with http:// or https://"})
+
+            # Validate steps
+            if not steps:
+                return json.dumps({"error": "Steps cannot be empty"})
+            if any(not step.strip() for step in steps):
+                return json.dumps({"error": "All steps must contain valid instructions"})
+
+            # Prepare parameters for the API call
+            params = {"url": url, "steps": steps, "use_session": use_session, "ai_extraction": ai_extraction}
+
+            # Add optional parameters only if they are provided
+            if user_prompt:
+                params["user_prompt"] = user_prompt
+            if output_schema:
+                params["output_schema"] = output_schema
+
+            # Call the agentic scraper API
+            response = self.client.agenticscraper(**params)
+
+            return json.dumps(response, indent=2)
+
+        except Exception as e:
+            return json.dumps({"error": str(e)})
+
     def searchscraper(self, prompt: str) -> str:
         """Search the web and extract information from the web.
         Args:

agno/tools/youtube.py

@@ -126,18 +126,19 @@ class YouTubeTools(Toolkit):
             return "Error getting video ID from URL, please provide a valid YouTube url"
 
         try:
-            captions = None
-            kwargs: Dict = {}
-            if self.languages:
-                kwargs["languages"] = self.languages or ["en"]
-            if self.proxies:
-                kwargs["proxies"] = self.proxies
-            captions = YouTubeTranscriptApi.get_transcript(video_id, **kwargs)
-            # log_debug(f"Captions for video {video_id}: {captions}")
-            if captions:
-                return " ".join(line["text"] for line in captions)
-            return "No captions found for video"
+            ytt_api = YouTubeTranscriptApi()
+            captions_data = ytt_api.fetch(video_id)
+
+            # log_info(f"Captions for video {video_id}: {captions_data}")
+
+            transcript_text = ""
+
+            for segment in captions_data:
+                transcript_text += f"{segment.text} "
+
+            return transcript_text.strip() if transcript_text else "No captions found for video"
         except Exception as e:
+            # log_info(f"Error getting captions for video {video_id}: {e}")
             return f"Error getting captions for video: {e}"
 
     def get_video_timestamps(self, url: str) -> str:

agno/vectordb/pgvector/pgvector.py

@@ -310,26 +310,7 @@ class PgVector(VectorDb):
                         batch_records = []
                         for doc in batch_docs:
                             try:
-                                doc.embed(embedder=self.embedder)
-                                cleaned_content = self._clean_content(doc.content)
-                                content_hash = safe_content_hash(doc.content)
-                                _id = doc.id or content_hash
-
-                                meta_data = doc.meta_data or {}
-                                if filters:
-                                    meta_data.update(filters)
-
-                                record = {
-                                    "id": _id,
-                                    "name": doc.name,
-                                    "meta_data": doc.meta_data,
-                                    "filters": filters,
-                                    "content": cleaned_content,
-                                    "embedding": doc.embedding,
-                                    "usage": doc.usage,
-                                    "content_hash": content_hash,
-                                }
-                                batch_records.append(record)
+                                batch_records.append(self._get_document_record(doc, filters))
                             except Exception as e:
                                 logger.error(f"Error processing document '{doc.name}': {e}")
 
@@ -383,25 +364,7 @@ class PgVector(VectorDb):
                         batch_records = []
                         for doc in batch_docs:
                             try:
-                                doc.embed(embedder=self.embedder)
-                                cleaned_content = self._clean_content(doc.content)
-                                content_hash = safe_content_hash(doc.content)
-
-                                meta_data = doc.meta_data or {}
-                                if filters:
-                                    meta_data.update(filters)
-
-                                record = {
-                                    "id": content_hash,  # use content_hash as a reproducible id to avoid duplicates while upsert
-                                    "name": doc.name,
-                                    "meta_data": doc.meta_data,
-                                    "filters": filters,
-                                    "content": cleaned_content,
-                                    "embedding": doc.embedding,
-                                    "usage": doc.usage,
-                                    "content_hash": content_hash,
-                                }
-                                batch_records.append(record)
+                                batch_records.append(self._get_document_record(doc, filters))
                             except Exception as e:
                                 logger.error(f"Error processing document '{doc.name}': {e}")
 
@@ -430,6 +393,27 @@ class PgVector(VectorDb):
             logger.error(f"Error upserting documents: {e}")
             raise
 
+    def _get_document_record(self, doc: Document, filters: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        doc.embed(embedder=self.embedder)
+        cleaned_content = self._clean_content(doc.content)
+        content_hash = safe_content_hash(doc.content)
+        _id = doc.id or content_hash
+
+        meta_data = doc.meta_data or {}
+        if filters:
+            meta_data.update(filters)
+
+        return {
+            "id": _id,
+            "name": doc.name,
+            "meta_data": meta_data,
+            "filters": filters,
+            "content": cleaned_content,
+            "embedding": doc.embedding,
+            "usage": doc.usage,
+            "content_hash": content_hash,
+        }
+
     async def async_upsert(self, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
         """Upsert documents asynchronously by running in a thread."""
         await asyncio.to_thread(self.upsert, documents, filters)

agno/workflow/v2/step.py

@@ -239,6 +239,7 @@ class Step:
                             images=images,
                             videos=videos,
                             audio=audios,
+                            files=step_input.files,
                             session_id=session_id,
                             user_id=user_id,
                         )
@@ -363,6 +364,7 @@ class Step:
                             images=images,
                             videos=videos,
                             audio=audios,
+                            files=step_input.files,
                             session_id=session_id,
                             user_id=user_id,
                             stream=True,
@@ -514,6 +516,7 @@ class Step:
                             images=images,
                             videos=videos,
                             audio=audios,
+                            files=step_input.files,
                             session_id=session_id,
                             user_id=user_id,
                         )
@@ -656,6 +659,7 @@ class Step:
                             images=images,
                             videos=videos,
                             audio=audios,
+                            files=step_input.files,
                             session_id=session_id,
                             user_id=user_id,
                             stream=True,