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

agno/memory/classifier.py

@@ -1,104 +0,0 @@
-from typing import Any, List, Optional, cast
-
-from pydantic import BaseModel
-
-from agno.memory.memory import Memory
-from agno.models.base import Model
-from agno.models.message import Message
-from agno.utils.log import logger
-
-
-class MemoryClassifier(BaseModel):
-    model: Optional[Model] = None
-
-    # Provide the system prompt for the classifier as a string
-    system_prompt: Optional[str] = None
-    # Existing Memories
-    existing_memories: Optional[List[Memory]] = None
-
-    def update_model(self) -> None:
-        if self.model is None:
-            try:
-                from agno.models.openai import OpenAIChat
-            except ModuleNotFoundError as e:
-                logger.exception(e)
-                logger.error(
-                    "Agno uses `openai` as the default model provider. Please provide a `model` or install `openai`."
-                )
-                exit(1)
-            self.model = OpenAIChat(id="gpt-4o")
-
-    def get_system_message(self) -> Message:
-        # -*- Return a system message for classification
-        system_prompt_lines = [
-            "Your task is to identify if the user's message contains information that is worth remembering for future conversations.",
-            "This includes details that could personalize ongoing interactions with the user, such as:\n"
-            "  - Personal facts: name, age, occupation, location, interests, preferences, etc.\n"
-            "  - Significant life events or experiences shared by the user\n"
-            "  - Important context about the user's current situation, challenges or goals\n"
-            "  - What the user likes or dislikes, their opinions, beliefs, values, etc.\n"
-            "  - Any other details that provide valuable insights into the user's personality, perspective or needs",
-            "Your task is to decide whether the user input contains any of the above information worth remembering.",
-            "If the user input contains any information worth remembering for future conversations, respond with 'yes'.",
-            "If the input does not contain any important details worth saving, respond with 'no' to disregard it.",
-            "You will also be provided with a list of existing memories to help you decide if the input is new or already known.",
-            "If the memory already exists that matches the input, respond with 'no' to keep it as is.",
-            "If a memory exists that needs to be updated or deleted, respond with 'yes' to update/delete it.",
-            "You must only respond with 'yes' or 'no'. Nothing else will be considered as a valid response.",
-        ]
-        if self.existing_memories and len(self.existing_memories) > 0:
-            system_prompt_lines.extend(
-                [
-                    "\nExisting memories:",
-                    "<existing_memories>\n"
-                    + "\n".join([f"  - {m.memory}" for m in self.existing_memories])
-                    + "\n</existing_memories>",
-                ]
-            )
-        return Message(role="system", content="\n".join(system_prompt_lines))
-
-    def run(
-        self,
-        message: Optional[str] = None,
-        **kwargs: Any,
-    ) -> Optional[str]:
-        logger.debug("*********** MemoryClassifier Start ***********")
-
-        # Update the Model (set defaults, add logit etc.)
-        self.update_model()
-
-        # Prepare the List of messages to send to the Model
-        messages_for_model: List[Message] = [self.get_system_message()]
-        # Add the user prompt message
-        user_prompt_message = Message(role="user", content=message, **kwargs) if message else None
-        if user_prompt_message is not None:
-            messages_for_model += [user_prompt_message]
-
-        # Generate a response from the Model (includes running function calls)
-        self.model = cast(Model, self.model)
-        response = self.model.response(messages=messages_for_model)
-        logger.debug("*********** MemoryClassifier End ***********")
-        return response.content
-
-    async def arun(
-        self,
-        message: Optional[str] = None,
-        **kwargs: Any,
-    ) -> Optional[str]:
-        logger.debug("*********** Async MemoryClassifier Start ***********")
-
-        # Update the Model (set defaults, add logit etc.)
-        self.update_model()
-
-        # Prepare the List of messages to send to the Model
-        messages_for_model: List[Message] = [self.get_system_message()]
-        # Add the user prompt message
-        user_prompt_message = Message(role="user", content=message, **kwargs) if message else None
-        if user_prompt_message is not None:
-            messages_for_model += [user_prompt_message]
-
-        # Generate a response from the Model (includes running function calls)
-        self.model = cast(Model, self.model)
-        response = await self.model.aresponse(messages=messages_for_model)
-        logger.debug("*********** Async MemoryClassifier End ***********")
-        return response.content

agno/memory/db/__init__.py

@@ -1 +0,0 @@
-from agno.memory.db.base import MemoryDb

agno/memory/db/base.py

@@ -1,42 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Optional
-
-from agno.memory.row import MemoryRow
-
-
-class MemoryDb(ABC):
-    """Base class for the Memory Database."""
-
-    @abstractmethod
-    def create(self) -> None:
-        raise NotImplementedError
-
-    @abstractmethod
-    def memory_exists(self, memory: MemoryRow) -> bool:
-        raise NotImplementedError
-
-    @abstractmethod
-    def read_memories(
-        self, user_id: Optional[str] = None, limit: Optional[int] = None, sort: Optional[str] = None
-    ) -> List[MemoryRow]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def upsert_memory(self, memory: MemoryRow) -> Optional[MemoryRow]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def delete_memory(self, id: str) -> None:
-        raise NotImplementedError
-
-    @abstractmethod
-    def drop_table(self) -> None:
-        raise NotImplementedError
-
-    @abstractmethod
-    def table_exists(self) -> bool:
-        raise NotImplementedError
-
-    @abstractmethod
-    def clear(self) -> bool:
-        raise NotImplementedError

agno/memory/db/mongodb.py

@@ -1,189 +0,0 @@
-from datetime import datetime, timezone
-from typing import List, Optional
-
-try:
-    from pymongo import MongoClient
-    from pymongo.collection import Collection
-    from pymongo.database import Database
-    from pymongo.errors import PyMongoError
-except ImportError:
-    raise ImportError("`pymongo` not installed. Please install it with `pip install pymongo`")
-
-from agno.memory.db import MemoryDb
-from agno.memory.row import MemoryRow
-from agno.utils.log import logger
-
-
-class MongoMemoryDb(MemoryDb):
-    def __init__(
-        self,
-        collection_name: str = "memory",
-        db_url: Optional[str] = None,
-        db_name: str = "agno",
-        client: Optional[MongoClient] = None,
-    ):
-        """
-        This class provides a memory store backed by a MongoDB collection.
-
-        Args:
-            collection_name: The name of the collection to store memories
-            db_url: MongoDB connection URL
-            db_name: Name of the database
-            client: Optional existing MongoDB client
-        """
-        self._client: Optional[MongoClient] = client
-        if self._client is None and db_url is not None:
-            self._client = MongoClient(db_url)
-
-        if self._client is None:
-            raise ValueError("Must provide either db_url or client")
-
-        self.collection_name: str = collection_name
-        self.db_name: str = db_name
-        self.db: Database = self._client[self.db_name]
-        self.collection: Collection = self.db[self.collection_name]
-
-    def create(self) -> None:
-        """Create indexes for the collection"""
-        try:
-            # Create indexes
-            self.collection.create_index("id", unique=True)
-            self.collection.create_index("user_id")
-            self.collection.create_index("created_at")
-        except PyMongoError as e:
-            logger.error(f"Error creating indexes for collection '{self.collection_name}': {e}")
-            raise
-
-    def memory_exists(self, memory: MemoryRow) -> bool:
-        """Check if a memory exists
-        Args:
-            memory: MemoryRow to check
-        Returns:
-            bool: True if the memory exists, False otherwise
-        """
-        try:
-            result = self.collection.find_one({"id": memory.id})
-            return result is not None
-        except PyMongoError as e:
-            logger.error(f"Error checking memory existence: {e}")
-            return False
-
-    def read_memories(
-        self, user_id: Optional[str] = None, limit: Optional[int] = None, sort: Optional[str] = None
-    ) -> List[MemoryRow]:
-        """Read memories from the collection
-        Args:
-            user_id: ID of the user to read
-            limit: Maximum number of memories to read
-            sort: Sort order ("asc" or "desc")
-        Returns:
-            List[MemoryRow]: List of memories
-        """
-        memories: List[MemoryRow] = []
-        try:
-            # Build query
-            query = {}
-            if user_id is not None:
-                query["user_id"] = user_id
-
-            # Build sort order
-            sort_order = -1 if sort != "asc" else 1
-            cursor = self.collection.find(query).sort("created_at", sort_order)
-
-            if limit is not None:
-                cursor = cursor.limit(limit)
-
-            for doc in cursor:
-                # Remove MongoDB _id before converting to MemoryRow
-                doc.pop("_id", None)
-                memories.append(MemoryRow(id=doc["id"], user_id=doc["user_id"], memory=doc["memory"]))
-        except PyMongoError as e:
-            logger.error(f"Error reading memories: {e}")
-        return memories
-
-    def upsert_memory(self, memory: MemoryRow, create_and_retry: bool = True) -> None:
-        """Upsert a memory into the collection
-        Args:
-            memory: MemoryRow to upsert
-            create_and_retry: Whether to create a new memory if the id already exists
-        Returns:
-            None
-        """
-        try:
-            now = datetime.now(timezone.utc)
-            timestamp = int(now.timestamp())
-
-            # Add version field for optimistic locking
-            memory_dict = memory.model_dump()
-            if "_version" not in memory_dict:
-                memory_dict["_version"] = 1
-            else:
-                memory_dict["_version"] += 1
-
-            update_data = {
-                "user_id": memory.user_id,
-                "memory": memory.memory,
-                "updated_at": timestamp,
-                "_version": memory_dict["_version"],
-            }
-
-            # For new documents, set created_at
-            query = {"id": memory.id}
-            doc = self.collection.find_one(query)
-            if not doc:
-                update_data["created_at"] = timestamp
-
-            result = self.collection.update_one(query, {"$set": update_data}, upsert=True)
-
-            if not result.acknowledged:
-                logger.error("Memory upsert not acknowledged")
-
-        except PyMongoError as e:
-            logger.error(f"Error upserting memory: {e}")
-            raise
-
-    def delete_memory(self, id: str) -> None:
-        """Delete a memory from the collection
-        Args:
-            id: ID of the memory to delete
-        Returns:
-            None
-        """
-        try:
-            result = self.collection.delete_one({"id": id})
-            if result.deleted_count == 0:
-                logger.debug(f"No memory found with id: {id}")
-            else:
-                logger.debug(f"Successfully deleted memory with id: {id}")
-        except PyMongoError as e:
-            logger.error(f"Error deleting memory: {e}")
-            raise
-
-    def drop_table(self) -> None:
-        """Drop the collection
-        Returns:
-            None
-        """
-        try:
-            self.collection.drop()
-        except PyMongoError as e:
-            logger.error(f"Error dropping collection: {e}")
-
-    def table_exists(self) -> bool:
-        """Check if the collection exists
-        Returns:
-            bool: True if the collection exists, False otherwise
-        """
-        return self.collection_name in self.db.list_collection_names()
-
-    def clear(self) -> bool:
-        """Clear the collection
-        Returns:
-            bool: True if the collection was cleared, False otherwise
-        """
-        try:
-            result = self.collection.delete_many({})
-            return result.acknowledged
-        except PyMongoError as e:
-            logger.error(f"Error clearing collection: {e}")
-            return False

agno/memory/db/postgres.py

@@ -1,203 +0,0 @@
-from typing import List, Optional
-
-try:
-    from sqlalchemy.dialects import postgresql
-    from sqlalchemy.engine import Engine, create_engine
-    from sqlalchemy.inspection import inspect
-    from sqlalchemy.orm import scoped_session, sessionmaker
-    from sqlalchemy.schema import Column, MetaData, Table
-    from sqlalchemy.sql.expression import delete, select, text
-    from sqlalchemy.types import DateTime, String
-except ImportError:
-    raise ImportError("`sqlalchemy` not installed")
-
-from agno.memory.db import MemoryDb
-from agno.memory.row import MemoryRow
-from agno.utils.log import logger
-
-
-class PgMemoryDb(MemoryDb):
-    def __init__(
-        self,
-        table_name: str,
-        schema: Optional[str] = "ai",
-        db_url: Optional[str] = None,
-        db_engine: Optional[Engine] = None,
-    ):
-        """
-        This class provides a memory store backed by a postgres table.
-
-        The following order is used to determine the database connection:
-            1. Use the db_engine if provided
-            2. Use the db_url to create the engine
-
-        Args:
-            table_name (str): The name of the table to store memory rows.
-            schema (Optional[str]): The schema to store the table in. Defaults to "ai".
-            db_url (Optional[str]): The database URL to connect to. Defaults to None.
-            db_engine (Optional[Engine]): The database engine to use. Defaults to None.
-        """
-        _engine: Optional[Engine] = db_engine
-        if _engine is None and db_url is not None:
-            _engine = create_engine(db_url)
-
-        if _engine is None:
-            raise ValueError("Must provide either db_url or db_engine")
-
-        self.table_name: str = table_name
-        self.schema: Optional[str] = schema
-        self.db_url: Optional[str] = db_url
-        self.db_engine: Engine = _engine
-        self.inspector = inspect(self.db_engine)
-        self.metadata: MetaData = MetaData(schema=self.schema)
-        self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine))
-        self.table: Table = self.get_table()
-
-    def get_table(self) -> Table:
-        return Table(
-            self.table_name,
-            self.metadata,
-            Column("id", String, primary_key=True),
-            Column("user_id", String),
-            Column("memory", postgresql.JSONB, server_default=text("'{}'::jsonb")),
-            Column("created_at", DateTime(timezone=True), server_default=text("now()")),
-            Column("updated_at", DateTime(timezone=True), onupdate=text("now()")),
-            extend_existing=True,
-        )
-
-    def create(self) -> None:
-        if not self.table_exists():
-            try:
-                with self.Session() as sess, sess.begin():
-                    if self.schema is not None:
-                        logger.debug(f"Creating schema: {self.schema}")
-                        sess.execute(text(f"CREATE SCHEMA IF NOT EXISTS {self.schema};"))
-                logger.debug(f"Creating table: {self.table_name}")
-                self.table.create(self.db_engine, checkfirst=True)
-            except Exception as e:
-                logger.error(f"Error creating table '{self.table.fullname}': {e}")
-                raise
-
-    def memory_exists(self, memory: MemoryRow) -> bool:
-        columns = [self.table.c.id]
-        with self.Session() as sess, sess.begin():
-            stmt = select(*columns).where(self.table.c.id == memory.id)
-            result = sess.execute(stmt).first()
-            return result is not None
-
-    def read_memories(
-        self, user_id: Optional[str] = None, limit: Optional[int] = None, sort: Optional[str] = None
-    ) -> List[MemoryRow]:
-        memories: List[MemoryRow] = []
-        try:
-            with self.Session() as sess, sess.begin():
-                stmt = select(self.table)
-                if user_id is not None:
-                    stmt = stmt.where(self.table.c.user_id == user_id)
-                if limit is not None:
-                    stmt = stmt.limit(limit)
-
-                if sort == "asc":
-                    stmt = stmt.order_by(self.table.c.created_at.asc())
-                else:
-                    stmt = stmt.order_by(self.table.c.created_at.desc())
-
-                rows = sess.execute(stmt).fetchall()
-                for row in rows:
-                    if row is not None:
-                        memories.append(MemoryRow.model_validate(row))
-        except Exception as e:
-            logger.debug(f"Exception reading from table: {e}")
-            logger.debug(f"Table does not exist: {self.table.name}")
-            logger.debug("Creating table for future transactions")
-            self.create()
-        return memories
-
-    def upsert_memory(self, memory: MemoryRow, create_and_retry: bool = True) -> None:
-        """Create a new memory if it does not exist, otherwise update the existing memory"""
-
-        try:
-            with self.Session() as sess, sess.begin():
-                # Create an insert statement
-                stmt = postgresql.insert(self.table).values(
-                    id=memory.id,
-                    user_id=memory.user_id,
-                    memory=memory.memory,
-                )
-
-                # Define the upsert if the memory already exists
-                # See: https://docs.sqlalchemy.org/en/20/dialects/postgresql.html#postgresql-insert-on-conflict
-                stmt = stmt.on_conflict_do_update(
-                    index_elements=["id"],
-                    set_=dict(
-                        user_id=stmt.excluded.user_id,
-                        memory=stmt.excluded.memory,
-                    ),
-                )
-
-                sess.execute(stmt)
-        except Exception as e:
-            logger.debug(f"Exception upserting into table: {e}")
-            logger.debug(f"Table does not exist: {self.table.name}")
-            logger.debug("Creating table for future transactions")
-            self.create()
-            if create_and_retry:
-                return self.upsert_memory(memory, create_and_retry=False)
-            return None
-
-    def delete_memory(self, id: str) -> None:
-        with self.Session() as sess, sess.begin():
-            stmt = delete(self.table).where(self.table.c.id == id)
-            sess.execute(stmt)
-
-    def drop_table(self) -> None:
-        if self.table_exists():
-            logger.debug(f"Deleting table: {self.table_name}")
-            self.table.drop(self.db_engine)
-
-    def table_exists(self) -> bool:
-        logger.debug(f"Checking if table exists: {self.table.name}")
-        try:
-            return inspect(self.db_engine).has_table(self.table.name, schema=self.schema)
-        except Exception as e:
-            logger.error(e)
-            return False
-
-    def clear(self) -> bool:
-        with self.Session() as sess, sess.begin():
-            stmt = delete(self.table)
-            sess.execute(stmt)
-            return True
-
-    def __deepcopy__(self, memo):
-        """
-        Create a deep copy of the PgMemoryDb instance, handling unpickleable attributes.
-
-        Args:
-            memo (dict): A dictionary of objects already copied during the current copying pass.
-
-        Returns:
-            PgMemoryDb: A deep-copied instance of PgMemoryDb.
-        """
-        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():
-            if k in {"metadata", "table"}:
-                continue
-            # Reuse db_engine and Session without copying
-            elif k in {"db_engine", "Session"}:
-                setattr(copied_obj, k, v)
-            else:
-                setattr(copied_obj, k, deepcopy(v, memo))
-
-        # Recreate metadata and table for the copied instance
-        copied_obj.metadata = MetaData(schema=copied_obj.schema)
-        copied_obj.table = copied_obj.get_table()
-
-        return copied_obj