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

agno/knowledge/s3/base.py

@@ -1,60 +0,0 @@
-from typing import Iterator, List, Optional
-
-from agno.aws.resource.s3.bucket import S3Bucket  # type: ignore
-from agno.aws.resource.s3.object import S3Object  # type: ignore
-from agno.document import Document
-from agno.knowledge.agent import AgentKnowledge
-
-
-class S3KnowledgeBase(AgentKnowledge):
-    # Provide either bucket or bucket_name
-    bucket: Optional[S3Bucket] = None
-    bucket_name: Optional[str] = None
-
-    # Provide either object or key
-    key: Optional[str] = None
-    object: Optional[S3Object] = None
-
-    # Filter objects by prefix
-    # Ignored if object or key is provided
-    prefix: Optional[str] = None
-
-    @property
-    def document_lists(self) -> Iterator[List[Document]]:
-        raise NotImplementedError
-
-    @property
-    def s3_objects(self) -> List[S3Object]:
-        """Iterate over PDFs in a s3 bucket 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
-        """
-
-        s3_objects_to_read: List[S3Object] = []
-
-        if self.bucket is None and self.bucket_name is None:
-            raise ValueError("No bucket or bucket_name provided")
-
-        if self.bucket is not None and self.bucket_name is not None:
-            raise ValueError("Provide either bucket or bucket_name")
-
-        if self.object is not None and self.key is not None:
-            raise ValueError("Provide either object or key")
-
-        if self.bucket_name is not None:
-            self.bucket = S3Bucket(name=self.bucket_name)
-
-        if self.bucket is not None:
-            if self.key is not None:
-                _object = S3Object(bucket_name=self.bucket.name, name=self.key)
-                s3_objects_to_read.append(_object)
-            elif self.object is not None:
-                s3_objects_to_read.append(self.object)
-            elif self.prefix is not None:
-                s3_objects_to_read.extend(self.bucket.get_objects(prefix=self.prefix))
-            else:
-                s3_objects_to_read.extend(self.bucket.get_objects())
-
-        return s3_objects_to_read

agno/knowledge/s3/pdf.py

@@ -1,21 +0,0 @@
-from typing import Iterator, List
-
-from agno.document import Document
-from agno.document.reader.s3.pdf_reader import S3PDFReader
-from agno.knowledge.s3.base import S3KnowledgeBase
-
-
-class S3PDFKnowledgeBase(S3KnowledgeBase):
-    reader: S3PDFReader = S3PDFReader()
-
-    @property
-    def document_lists(self) -> Iterator[List[Document]]:
-        """Iterate over PDFs in a s3 bucket 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 s3_object in self.s3_objects:
-            if s3_object.name.endswith(".pdf"):
-                yield self.reader.read(s3_object=s3_object)

agno/knowledge/s3/text.py

@@ -1,23 +0,0 @@
-from typing import Iterator, List
-
-from agno.document import Document
-from agno.document.reader.s3.text_reader import S3TextReader
-from agno.knowledge.s3.base import S3KnowledgeBase
-
-
-class S3TextKnowledgeBase(S3KnowledgeBase):
-    formats: List[str] = [".doc", ".docx"]
-    reader: S3TextReader = S3TextReader()
-
-    @property
-    def document_lists(self) -> Iterator[List[Document]]:
-        """Iterate over text files in a s3 bucket 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 s3_object in self.s3_objects:
-            if s3_object.name.endswith(tuple(self.formats)):
-                yield self.reader.read(s3_object=s3_object)

agno/knowledge/text.py

@@ -1,30 +0,0 @@
-from pathlib import Path
-from typing import Iterator, List, Union
-
-from agno.document import Document
-from agno.document.reader.text_reader import TextReader
-from agno.knowledge.agent import AgentKnowledge
-
-
-class TextKnowledgeBase(AgentKnowledge):
-    path: Union[str, Path]
-    formats: List[str] = [".txt"]
-    reader: TextReader = TextReader()
-
-    @property
-    def document_lists(self) -> Iterator[List[Document]]:
-        """Iterate over text files 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
-        """
-
-        _file_path: Path = Path(self.path) if isinstance(self.path, str) else self.path
-
-        if _file_path.exists() and _file_path.is_dir():
-            for _file in _file_path.glob("**/*"):
-                if _file.suffix in self.formats:
-                    yield self.reader.read(file=_file)
-        elif _file_path.exists() and _file_path.is_file() and _file_path.suffix in self.formats:
-            yield self.reader.read(file=_file_path)

agno/knowledge/website.py

@@ -1,88 +0,0 @@
-from typing import Any, Dict, Iterator, List, Optional
-
-from pydantic import model_validator
-
-from agno.document import Document
-from agno.document.reader.website_reader import WebsiteReader
-from agno.knowledge.agent import AgentKnowledge
-from agno.utils.log import 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)
-        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)
-
-    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:
-            logger.debug("Dropping collection")
-            self.vector_db.drop()
-
-        logger.debug("Creating collection")
-        self.vector_db.create()
-
-        logger.info("Loading knowledge base")
-        num_documents = 0
-
-        # 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:
-                logger.debug(f"Checking if {url} exists in the vector db")
-                if self.vector_db.name_exists(name=url):
-                    logger.debug(f"Skipping {url} as it exists in the vector db")
-                    urls_to_read.remove(url)
-
-        for url in urls_to_read:
-            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 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)
-            logger.info(f"Loaded {num_documents} documents to knowledge base")
-
-        if self.optimize_on is not None and num_documents > self.optimize_on:
-            logger.debug("Optimizing Vector DB")
-            self.vector_db.optimize()

agno/knowledge/wikipedia.py

@@ -1,31 +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] = []
-
-    @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),
-                )
-            ]

agno/knowledge/youtube.py

@@ -1,22 +0,0 @@
-from typing import 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)

agno/memory/agent.py

@@ -1,392 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-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
-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 logger
-
-
-class AgentRun(BaseModel):
-    message: Optional[Message] = None
-    messages: Optional[List[Message]] = None
-    response: Optional[RunResponse] = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class MemoryRetrieval(str, Enum):
-    last_n = "last_n"
-    first_n = "first_n"
-    semantic = "semantic"
-
-
-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
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def to_dict(self) -> Dict[str, Any]:
-        _memory_dict = self.model_dump(
-            exclude_none=True,
-            include={
-                "runs",
-                "messages",
-                "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]
-        return _memory_dict
-
-    def add_run(self, agent_run: AgentRun) -> None:
-        """Adds an AgentRun to the runs list."""
-        self.runs.append(agent_run)
-        logger.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
-                ):
-                    logger.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_message(self, message: Message) -> None:
-        """Add a Message to the messages list."""
-        self.messages.append(message)
-        logger.debug("Added Message to AgentMemory")
-
-    def add_messages(self, messages: List[Message]) -> None:
-        """Add a list of messages to the messages list."""
-        self.messages.extend(messages)
-        logger.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
-
-        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 in the last_n runs.
-        """
-        if last_n is None:
-            logger.debug("Getting messages from all previous runs")
-            messages_from_all_history = []
-            for prev_run in self.runs:
-                if prev_run.response and prev_run.response.messages:
-                    if skip_role:
-                        prev_run_messages = [m for m in prev_run.response.messages if m.role != skip_role]
-                    else:
-                        prev_run_messages = prev_run.response.messages
-                    messages_from_all_history.extend(prev_run_messages)
-            logger.debug(f"Messages from previous runs: {len(messages_from_all_history)}")
-            return messages_from_all_history
-
-        logger.debug(f"Getting messages from last {last_n} runs")
-        messages_from_last_n_history = []
-        for prev_run in self.runs[-last_n:]:
-            if prev_run.response and prev_run.response.messages:
-                if skip_role:
-                    prev_run_messages = [m for m in prev_run.response.messages if m.role != skip_role]
-                else:
-                    prev_run_messages = prev_run.response.messages
-                messages_from_last_n_history.extend(prev_run_messages)
-        logger.debug(f"Messages from last {last_n} runs: {len(messages_from_last_n_history)}")
-        return messages_from_last_n_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 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 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:
-            logger.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 == "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 == "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."""
-        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)
-        logger.debug(f"Update memory: {should_update_memory}")
-
-        if not should_update_memory:
-            logger.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."""
-        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 await self.ashould_update_memory(input=input)
-        logger.debug(f"Async update memory: {should_update_memory}")
-
-        if not should_update_memory:
-            logger.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 deep_copy(self) -> "AgentMemory":
-        from copy import deepcopy
-
-        # Create a shallow copy of the object
-        copied_obj = self.__class__(**self.to_dict())
-
-        # Manually deepcopy fields that are known to be safe
-        for field_name, field_value in self.__dict__.items():
-            if field_name not in ["db", "classifier", "manager", "summarizer"]:
-                try:
-                    setattr(copied_obj, field_name, deepcopy(field_value))
-                except Exception as e:
-                    logger.warning(f"Failed to deepcopy field: {field_name} - {e}")
-                    setattr(copied_obj, field_name, field_value)
-
-        copied_obj.db = self.db
-        copied_obj.classifier = self.classifier
-        copied_obj.manager = self.manager
-        copied_obj.summarizer = self.summarizer
-
-        return copied_obj