agno 1.8.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/knowledge/website.py

@@ -1,179 +0,0 @@
-import asyncio
-from typing import Any, AsyncIterator, Dict, Iterator, List, Optional
-
-from pydantic import model_validator
-
-from agno.document import Document
-from agno.document.chunking.fixed import FixedSizeChunking
-from agno.document.reader.website_reader import WebsiteReader
-from agno.knowledge.agent import AgentKnowledge
-from agno.utils.log import log_debug, log_info, logger
-
-
-class WebsiteKnowledgeBase(AgentKnowledge):
-    urls: List[str] = []
-    reader: Optional[WebsiteReader] = None
-
-    # WebsiteReader parameters
-    max_depth: int = 3
-    max_links: int = 10
-
-    @model_validator(mode="after")
-    def set_reader(self) -> "WebsiteKnowledgeBase":
-        if self.reader is None:
-            self.reader = WebsiteReader(
-                max_depth=self.max_depth,
-                max_links=self.max_links,
-                chunking_strategy=self.chunking_strategy or FixedSizeChunking(),
-            )
-        return self
-
-    @property
-    def document_lists(self) -> Iterator[List[Document]]:
-        """Iterate over urls and yield lists of documents.
-        Each object yielded by the iterator is a list of documents.
-
-        Returns:
-            Iterator[List[Document]]: Iterator yielding list of documents
-        """
-        if self.reader is not None:
-            for _url in self.urls:
-                yield self.reader.read(url=_url)
-
-    @property
-    async def async_document_lists(self) -> AsyncIterator[List[Document]]:
-        """Asynchronously iterate over urls and yield lists of documents.
-        Each object yielded by the iterator is a list of documents.
-
-        Returns:
-            AsyncIterator[List[Document]]: AsyncIterator yielding list of documents
-        """
-        if self.reader is not None:
-            for _url in self.urls:
-                yield await self.reader.async_read(url=_url)
-
-    def load(
-        self,
-        recreate: bool = False,
-        upsert: bool = True,
-        skip_existing: bool = True,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> None:
-        """Load the website contents to the vector db"""
-
-        if self.vector_db is None:
-            logger.warning("No vector db provided")
-            return
-
-        if self.reader is None:
-            logger.warning("No reader provided")
-            return
-
-        if recreate:
-            log_debug("Dropping collection")
-            self.vector_db.drop()
-
-        log_debug("Creating collection")
-        self.vector_db.create()
-
-        log_info("Loading knowledge base")
-
-        # Given that the crawler needs to parse the URL before existence can be checked
-        # We check if the website url exists in the vector db if recreate is False
-        urls_to_read = self.urls.copy()
-        if not recreate:
-            for url in urls_to_read:
-                log_debug(f"Checking if {url} exists in the vector db")
-                if self.vector_db.name_exists(name=url):
-                    log_debug(f"Skipping {url} as it exists in the vector db")
-                    urls_to_read.remove(url)
-
-        num_documents = 0
-        for url in urls_to_read:
-            if document_list := self.reader.read(url=url):
-                # Filter out documents which already exist in the vector db
-                if not recreate:
-                    document_list = [document for document in document_list if not self.vector_db.doc_exists(document)]
-                    if not document_list:
-                        continue
-                if upsert and self.vector_db.upsert_available():
-                    self.vector_db.upsert(documents=document_list, filters=filters)
-                else:
-                    self.vector_db.insert(documents=document_list, filters=filters)
-                num_documents += len(document_list)
-                log_info(f"Loaded {num_documents} documents to knowledge base")
-
-        if self.optimize_on is not None and num_documents > self.optimize_on:
-            log_debug("Optimizing Vector DB")
-            self.vector_db.optimize()
-
-    async def async_load(
-        self,
-        recreate: bool = False,
-        upsert: bool = True,
-        skip_existing: bool = True,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> None:
-        """Asynchronously load the website contents to the vector db"""
-
-        if self.vector_db is None:
-            logger.warning("No vector db provided")
-            return
-
-        if self.reader is None:
-            logger.warning("No reader provided")
-            return
-
-        vector_db = self.vector_db
-        reader = self.reader
-
-        if recreate:
-            log_debug("Dropping collection asynchronously")
-            await vector_db.async_drop()
-
-        log_debug("Creating collection asynchronously")
-        await vector_db.async_create()
-
-        log_info("Loading knowledge base asynchronously")
-        num_documents = 0
-
-        urls_to_read = self.urls.copy()
-        if not recreate:
-            for url in urls_to_read[:]:
-                log_debug(f"Checking if {url} exists in the vector db")
-                name_exists = vector_db.async_name_exists(name=url)
-                if name_exists:
-                    log_debug(f"Skipping {url} as it exists in the vector db")
-                    urls_to_read.remove(url)
-
-        async def process_url(url: str) -> List[Document]:
-            try:
-                document_list = await reader.async_read(url=url)
-
-                if not recreate:
-                    filtered_documents = []
-                    for document in document_list:
-                        if not await vector_db.async_doc_exists(document):
-                            filtered_documents.append(document)
-                    document_list = filtered_documents
-
-                return document_list
-            except Exception as e:
-                logger.error(f"Error processing URL {url}: {e}")
-                return []
-
-        url_tasks = [process_url(url) for url in urls_to_read]
-        all_document_lists = await asyncio.gather(*url_tasks)
-
-        for document_list in all_document_lists:
-            if document_list:
-                if upsert and vector_db.upsert_available():
-                    await vector_db.async_upsert(documents=document_list, filters=filters)
-                else:
-                    await vector_db.async_insert(documents=document_list, filters=filters)
-                num_documents += len(document_list)
-                log_info(f"Loaded {num_documents} documents to knowledge base asynchronously")
-
-        if self.optimize_on is not None and num_documents > self.optimize_on:
-            log_debug("Optimizing Vector DB")
-            vector_db.optimize()

agno/knowledge/wikipedia.py

@@ -1,32 +0,0 @@
-from typing import Iterator, List
-
-from agno.document import Document
-from agno.knowledge.agent import AgentKnowledge
-
-try:
-    import wikipedia  # noqa: F401
-except ImportError:
-    raise ImportError("The `wikipedia` package is not installed. Please install it via `pip install wikipedia`.")
-
-
-class WikipediaKnowledgeBase(AgentKnowledge):
-    topics: List[str] = []
-    auto_suggest: bool = True
-
-    @property
-    def document_lists(self) -> Iterator[List[Document]]:
-        """Iterate over urls and yield lists of documents.
-        Each object yielded by the iterator is a list of documents.
-
-        Returns:
-            Iterator[List[Document]]: Iterator yielding list of documents
-        """
-
-        for topic in self.topics:
-            yield [
-                Document(
-                    name=topic,
-                    meta_data={"topic": topic},
-                    content=wikipedia.summary(topic, auto_suggest=self.auto_suggest),
-                )
-            ]

agno/knowledge/youtube.py

@@ -1,35 +0,0 @@
-import asyncio
-from typing import AsyncIterator, Iterator, List
-
-from agno.document import Document
-from agno.document.reader.youtube_reader import YouTubeReader
-from agno.knowledge.agent import AgentKnowledge
-
-
-class YouTubeKnowledgeBase(AgentKnowledge):
-    urls: List[str] = []
-    reader: YouTubeReader = YouTubeReader()
-
-    @property
-    def document_lists(self) -> Iterator[List[Document]]:
-        """Iterate over YouTube URLs and yield lists of documents.
-        Each object yielded by the iterator is a list of documents.
-
-        Returns:
-                Iterator[List[Document]]: Iterator yielding list of documents
-        """
-        for url in self.urls:
-            yield self.reader.read(video_url=url)
-
-    @property
-    async def async_document_lists(self) -> AsyncIterator[List[Document]]:
-        """Asynchronously iterate over YouTube URLs and yield lists of documents.
-        Each object yielded by the iterator is a list of documents.
-
-        Returns:
-            AsyncIterator[List[Document]]: Async iterator yielding list of documents
-        """
-        tasks = [self.reader.async_read(video_url=url) for url in self.urls]
-        results = await asyncio.gather(*tasks)
-        for documents in results:
-            yield documents

agno/memory/agent.py

@@ -1,423 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional, Tuple
-
-from pydantic import BaseModel, ConfigDict
-
-from agno.memory.classifier import MemoryClassifier
-from agno.memory.db import MemoryDb
-from agno.memory.manager import MemoryManager
-from agno.memory.memory import Memory, MemoryRetrieval
-from agno.memory.summarizer import MemorySummarizer
-from agno.memory.summary import SessionSummary
-from agno.models.message import Message
-from agno.run.response import RunResponse
-from agno.utils.log import log_debug, log_info, logger
-
-
-class AgentRun(BaseModel):
-    message: Optional[Message] = None
-    messages: Optional[List[Message]] = None
-    response: Optional[RunResponse] = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def to_dict(self) -> Dict[str, Any]:
-        response = {
-            "message": self.message.to_dict() if self.message else None,
-            "messages": [message.to_dict() for message in self.messages] if self.messages else None,
-            "response": self.response.to_dict() if self.response else None,
-        }
-        return {k: v for k, v in response.items() if v is not None}
-
-
-class AgentMemory(BaseModel):
-    # Runs between the user and agent
-    runs: List[AgentRun] = []
-    # List of messages sent to the model
-    messages: List[Message] = []
-    update_system_message_on_change: bool = False
-
-    # Summary of the session
-    summary: Optional[SessionSummary] = None
-    # Create and store session summaries
-    create_session_summary: bool = False
-    # Update session summaries after each run
-    update_session_summary_after_run: bool = True
-    # Summarizer to generate session summaries
-    summarizer: Optional[MemorySummarizer] = None
-
-    # Create and store personalized memories for this user
-    create_user_memories: bool = False
-    # Update memories for the user after each run
-    update_user_memories_after_run: bool = True
-
-    # MemoryDb to store personalized memories
-    db: Optional[MemoryDb] = None
-    # User ID for the personalized memories
-    user_id: Optional[str] = None
-    retrieval: MemoryRetrieval = MemoryRetrieval.last_n
-    memories: Optional[List[Memory]] = None
-    num_memories: Optional[int] = None
-    classifier: Optional[MemoryClassifier] = None
-    manager: Optional[MemoryManager] = None
-
-    # True when memory is being updated
-    updating_memory: bool = False
-
-    version: int = 1
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def to_dict(self) -> Dict[str, Any]:
-        _memory_dict = self.model_dump(
-            exclude_none=True,
-            include={
-                "update_system_message_on_change",
-                "create_session_summary",
-                "update_session_summary_after_run",
-                "create_user_memories",
-                "update_user_memories_after_run",
-                "user_id",
-                "num_memories",
-            },
-        )
-        # Add summary if it exists
-        if self.summary is not None:
-            _memory_dict["summary"] = self.summary.to_dict()
-        # Add memories if they exist
-        if self.memories is not None:
-            _memory_dict["memories"] = [memory.to_dict() for memory in self.memories]
-        # Add messages if they exist
-        if self.messages is not None:
-            _memory_dict["messages"] = [message.to_dict() for message in self.messages]
-        # Add runs if they exist
-        if self.runs is not None:
-            _memory_dict["runs"] = [run.to_dict() for run in self.runs]
-        return _memory_dict
-
-    def add_run(self, agent_run: AgentRun) -> None:
-        """Adds an AgentRun to the runs list."""
-        # Initialize runs list if it doesn't exist
-        if self.runs is None:
-            self.runs = []
-
-        # Process run if it has a valid response with run_id
-        if agent_run.response and agent_run.response.run_id:
-            run_id = agent_run.response.run_id
-
-            # Check for existing run with same ID
-            for i, run in enumerate(self.runs):
-                if run.response and run.response.run_id == run_id:
-                    # Replace existing run
-                    self.runs[i] = agent_run
-                    log_debug(f"Replaced existing AgentRun with run_id {run_id} in memory")
-                    return
-
-            # Add new run if not found
-            self.runs.append(agent_run)
-            log_debug("Added AgentRun to AgentMemory")
-
-    def add_system_message(self, message: Message, system_message_role: str = "system") -> None:
-        """Add the system messages to the messages list"""
-        # If this is the first run in the session, add the system message to the messages list
-        if len(self.messages) == 0:
-            if message is not None:
-                self.messages.append(message)
-        # If there are messages in the memory, check if the system message is already in the memory
-        # If it is not, add the system message to the messages list
-        # If it is, update the system message if content has changed and update_system_message_on_change is True
-        else:
-            system_message_index = next((i for i, m in enumerate(self.messages) if m.role == system_message_role), None)
-            # Update the system message in memory if content has changed
-            if system_message_index is not None:
-                if (
-                    self.messages[system_message_index].content != message.content
-                    and self.update_system_message_on_change
-                ):
-                    log_info("Updating system message in memory with new content")
-                    self.messages[system_message_index] = message
-            else:
-                # Add the system message to the messages list
-                self.messages.insert(0, message)
-
-    def add_messages(self, messages: List[Message]) -> None:
-        """Add a list of messages to the messages list."""
-        self.messages.extend(messages)
-        log_debug(f"Added {len(messages)} Messages to AgentMemory")
-
-    def get_messages(self) -> List[Dict[str, Any]]:
-        """Returns the messages list as a list of dictionaries."""
-        return [message.model_dump() for message in self.messages]
-
-    def get_messages_from_last_n_runs(
-        self, last_n: Optional[int] = None, skip_role: Optional[str] = None
-    ) -> List[Message]:
-        """Returns the messages from the last_n runs, excluding previously tagged history messages.
-
-        Args:
-            last_n: The number of runs to return from the end of the conversation.
-            skip_role: Skip messages with this role.
-
-        Returns:
-            A list of Messages from the specified runs, excluding history messages.
-        """
-        if not self.runs:
-            return []
-
-        runs_to_process = self.runs if last_n is None else self.runs[-last_n:]
-        messages_from_history = []
-
-        for run in runs_to_process:
-            if not (run.response and run.response.messages):
-                continue
-
-            for message in run.response.messages:
-                # Skip messages with specified role
-                if skip_role and message.role == skip_role:
-                    continue
-                # Skip messages that were tagged as history in previous runs
-                if hasattr(message, "from_history") and message.from_history:
-                    continue
-
-                messages_from_history.append(message)
-
-        log_debug(f"Getting messages from previous runs: {len(messages_from_history)}")
-        return messages_from_history
-
-    def get_message_pairs(
-        self, user_role: str = "user", assistant_role: Optional[List[str]] = None
-    ) -> List[Tuple[Message, Message]]:
-        """Returns a list of tuples of (user message, assistant response)."""
-
-        if assistant_role is None:
-            assistant_role = ["assistant", "model", "CHATBOT"]
-
-        runs_as_message_pairs: List[Tuple[Message, Message]] = []
-        for run in self.runs:
-            if run.response and run.response.messages:
-                user_messages_from_run = None
-                assistant_messages_from_run = None
-
-                # Start from the beginning to look for the user message
-                for message in run.response.messages:
-                    if hasattr(message, "from_history") and message.from_history:
-                        continue
-                    if message.role == user_role:
-                        user_messages_from_run = message
-                        break
-
-                # Start from the end to look for the assistant response
-                for message in run.response.messages[::-1]:
-                    if hasattr(message, "from_history") and message.from_history:
-                        continue
-                    if message.role in assistant_role:
-                        assistant_messages_from_run = message
-                        break
-
-                if user_messages_from_run and assistant_messages_from_run:
-                    runs_as_message_pairs.append((user_messages_from_run, assistant_messages_from_run))
-        return runs_as_message_pairs
-
-    def get_tool_calls(self, num_calls: Optional[int] = None) -> List[Dict[str, Any]]:
-        """Returns a list of tool calls from the messages"""
-
-        tool_calls = []
-        for message in self.messages[::-1]:
-            if message.tool_calls:
-                for tool_call in message.tool_calls:
-                    tool_calls.append(tool_call)
-                    if num_calls and len(tool_calls) >= num_calls:
-                        return tool_calls
-        return tool_calls
-
-    def load_user_memories(self) -> None:
-        """Load memories from memory db for this user."""
-
-        if self.db is None:
-            return
-
-        try:
-            if self.retrieval in (MemoryRetrieval.last_n, MemoryRetrieval.first_n):
-                memory_rows = self.db.read_memories(
-                    user_id=self.user_id,
-                    limit=self.num_memories,
-                    sort="asc" if self.retrieval == MemoryRetrieval.first_n else "desc",
-                )
-            else:
-                raise NotImplementedError("Semantic retrieval not yet supported.")
-        except Exception as e:
-            log_debug(f"Error reading memory: {e}")
-            return
-
-        # Clear the existing memories
-        self.memories = []
-
-        # No memories to load
-        if memory_rows is None or len(memory_rows) == 0:
-            return
-
-        for row in memory_rows:
-            try:
-                self.memories.append(Memory.model_validate(row.memory))
-            except Exception as e:
-                logger.warning(f"Error loading memory: {e}")
-                continue
-
-    def should_update_memory(self, input: str) -> bool:
-        """Determines if a message should be added to the memory db."""
-        from agno.memory.classifier import MemoryClassifier
-
-        if self.classifier is None:
-            self.classifier = MemoryClassifier()
-
-        self.classifier.existing_memories = self.memories
-        classifier_response = self.classifier.run(input)
-        if classifier_response and classifier_response.lower() == "yes":
-            return True
-        return False
-
-    async def ashould_update_memory(self, input: str) -> bool:
-        """Determines if a message should be added to the memory db."""
-        from agno.memory.classifier import MemoryClassifier
-
-        if self.classifier is None:
-            self.classifier = MemoryClassifier()
-
-        self.classifier.existing_memories = self.memories
-        classifier_response = await self.classifier.arun(input)
-        if classifier_response and classifier_response.lower() == "yes":
-            return True
-        return False
-
-    def update_memory(self, input: str, force: bool = False) -> Optional[str]:
-        """Creates a memory from a message and adds it to the memory db.
-
-        Args:
-            input: The input message to create a memory from.
-            force: If True, the memory will be created even if the classifier returns False.
-
-        Returns:
-            The response from the memory manager.
-        """
-        from agno.memory.manager import MemoryManager
-
-        if input is None or not isinstance(input, str):
-            return "Invalid message content"
-
-        if self.db is None:
-            logger.warning("MemoryDb not provided.")
-            return "Please provide a db to store memories"
-
-        self.updating_memory = True
-
-        # Check if this user message should be added to long term memory
-        should_update_memory = force or self.should_update_memory(input=input)
-        log_debug(f"Update memory: {should_update_memory}")
-
-        if not should_update_memory:
-            log_debug("Memory update not required")
-            return "Memory update not required"
-
-        if self.manager is None:
-            self.manager = MemoryManager(user_id=self.user_id, db=self.db)
-
-        else:
-            self.manager.db = self.db
-            self.manager.user_id = self.user_id
-
-        response = self.manager.run(input)
-        self.load_user_memories()
-        self.updating_memory = False
-        return response
-
-    async def aupdate_memory(self, input: str, force: bool = False) -> Optional[str]:
-        """Creates a memory from a message and adds it to the memory db.
-
-        Args:
-            input: The input message to create a memory from.
-            force: If True, the memory will be created even if the classifier returns False.
-
-        Returns:
-            The response from the memory manager.
-        """
-        if input is None or not isinstance(input, str):
-            return "Invalid message content"
-
-        if self.db is None:
-            logger.warning("MemoryDb not provided.")
-            return "Please provide a db to store memories"
-
-        self.updating_memory = True
-
-        # Check if this user message should be added to long term memory
-        should_update_memory = force or await self.ashould_update_memory(input=input)
-        log_debug(f"Async update memory: {should_update_memory}")
-
-        if not should_update_memory:
-            log_debug("Memory update not required")
-            return "Memory update not required"
-
-        if self.manager is None:
-            self.manager = MemoryManager(user_id=self.user_id, db=self.db)
-
-        else:
-            self.manager.db = self.db
-            self.manager.user_id = self.user_id
-
-        response = await self.manager.arun(input)
-        self.load_user_memories()
-        self.updating_memory = False
-        return response
-
-    def update_summary(self) -> Optional[SessionSummary]:
-        """Creates a summary of the session"""
-        from agno.memory.summarizer import MemorySummarizer
-
-        self.updating_memory = True
-
-        if self.summarizer is None:
-            self.summarizer = MemorySummarizer()
-
-        self.summary = self.summarizer.run(self.get_message_pairs())
-        self.updating_memory = False
-        return self.summary
-
-    async def aupdate_summary(self) -> Optional[SessionSummary]:
-        """Creates a summary of the session"""
-        from agno.memory.summarizer import MemorySummarizer
-
-        self.updating_memory = True
-
-        if self.summarizer is None:
-            self.summarizer = MemorySummarizer()
-
-        self.summary = await self.summarizer.arun(self.get_message_pairs())
-        self.updating_memory = False
-        return self.summary
-
-    def clear(self) -> None:
-        """Clear the AgentMemory"""
-
-        self.runs = []
-        self.messages = []
-        self.summary = None
-        self.memories = None
-
-    def __deepcopy__(self, memo):
-        from copy import deepcopy
-
-        # Create a new instance without calling __init__
-        cls = self.__class__
-        copied_obj = cls.__new__(cls)
-        memo[id(self)] = copied_obj
-
-        # Deep copy attributes
-        for k, v in self.__dict__.items():
-            # Reuse db
-            if k in {"db", "classifier", "manager", "summarizer"}:
-                setattr(copied_obj, k, v)
-            else:
-                setattr(copied_obj, k, deepcopy(v, memo))
-
-        return copied_obj