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

agno/memory/db/sqlite.py

@@ -1,193 +0,0 @@
-from pathlib import Path
-from typing import List, Optional
-
-try:
-    from sqlalchemy import (
-        Column,
-        DateTime,
-        Engine,
-        MetaData,
-        String,
-        Table,
-        create_engine,
-        delete,
-        inspect,
-        select,
-        text,
-    )
-    from sqlalchemy.exc import SQLAlchemyError
-    from sqlalchemy.orm import scoped_session, sessionmaker
-except ImportError:
-    raise ImportError("`sqlalchemy` not installed. Please install it with `pip install sqlalchemy`")
-
-from agno.memory.db import MemoryDb
-from agno.memory.row import MemoryRow
-from agno.utils.log import logger
-
-
-class SqliteMemoryDb(MemoryDb):
-    def __init__(
-        self,
-        table_name: str = "memory",
-        db_url: Optional[str] = None,
-        db_file: Optional[str] = None,
-        db_engine: Optional[Engine] = None,
-    ):
-        """
-        This class provides a memory store backed by a SQLite table.
-
-        The following order is used to determine the database connection:
-            1. Use the db_engine if provided
-            2. Use the db_url
-            3. Use the db_file
-            4. Create a new in-memory database
-
-        Args:
-            table_name: The name of the table to store Agent sessions.
-            db_url: The database URL to connect to.
-            db_file: The database file to connect to.
-            db_engine: The database engine to use.
-        """
-        _engine: Optional[Engine] = db_engine
-        if _engine is None and db_url is not None:
-            _engine = create_engine(db_url)
-        elif _engine is None and db_file is not None:
-            # Use the db_file to create the engine
-            db_path = Path(db_file).resolve()
-            # Ensure the directory exists
-            db_path.parent.mkdir(parents=True, exist_ok=True)
-            _engine = create_engine(f"sqlite:///{db_path}")
-        else:
-            _engine = create_engine("sqlite://")
-
-        if _engine is None:
-            raise ValueError("Must provide either db_url, db_file or db_engine")
-
-        # Database attributes
-        self.table_name: str = table_name
-        self.db_url: Optional[str] = db_url
-        self.db_engine: Engine = _engine
-        self.metadata: MetaData = MetaData()
-        self.inspector = inspect(self.db_engine)
-
-        # Database session
-        self.Session = scoped_session(sessionmaker(bind=self.db_engine))
-        # Database table for memories
-        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", String),
-            Column("created_at", DateTime, server_default=text("CURRENT_TIMESTAMP")),
-            Column(
-                "updated_at", DateTime, server_default=text("CURRENT_TIMESTAMP"), onupdate=text("CURRENT_TIMESTAMP")
-            ),
-            extend_existing=True,
-        )
-
-    def create(self) -> None:
-        if not self.table_exists():
-            try:
-                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_name}': {e}")
-                raise
-
-    def memory_exists(self, memory: MemoryRow) -> bool:
-        with self.Session() as session:
-            stmt = select(self.table.c.id).where(self.table.c.id == memory.id)
-            result = session.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 session:
-                stmt = select(self.table)
-                if user_id is not None:
-                    stmt = stmt.where(self.table.c.user_id == user_id)
-
-                if sort == "asc":
-                    stmt = stmt.order_by(self.table.c.created_at.asc())
-                else:
-                    stmt = stmt.order_by(self.table.c.created_at.desc())
-
-                if limit is not None:
-                    stmt = stmt.limit(limit)
-
-                result = session.execute(stmt)
-                for row in result:
-                    memories.append(MemoryRow(id=row.id, user_id=row.user_id, memory=eval(row.memory)))
-        except SQLAlchemyError 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:
-        try:
-            with self.Session() as session:
-                # Check if the memory already exists
-                existing = session.execute(select(self.table).where(self.table.c.id == memory.id)).first()
-
-                if existing:
-                    # Update existing memory
-                    stmt = (
-                        self.table.update()
-                        .where(self.table.c.id == memory.id)
-                        .values(user_id=memory.user_id, memory=str(memory.memory), updated_at=text("CURRENT_TIMESTAMP"))
-                    )
-                else:
-                    # Insert new memory
-                    stmt = self.table.insert().values(id=memory.id, user_id=memory.user_id, memory=str(memory.memory))  # type: ignore
-
-                session.execute(stmt)
-                session.commit()
-        except SQLAlchemyError as e:
-            logger.error(f"Exception upserting into table: {e}")
-            if not self.table_exists():
-                logger.info(f"Table does not exist: {self.table_name}")
-                logger.info("Creating table for future transactions")
-                self.create()
-                if create_and_retry:
-                    return self.upsert_memory(memory, create_and_retry=False)
-            else:
-                raise
-
-    def delete_memory(self, id: str) -> None:
-        with self.Session() as session:
-            stmt = delete(self.table).where(self.table.c.id == id)
-            session.execute(stmt)
-            session.commit()
-
-    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 self.inspector.has_table(self.table.name)
-        except Exception as e:
-            logger.error(e)
-            return False
-
-    def clear(self) -> bool:
-        with self.Session() as session:
-            stmt = delete(self.table)
-            session.execute(stmt)
-            session.commit()
-        return True
-
-    def __del__(self):
-        # self.Session.remove()
-        pass

agno/memory/memory.py

@@ -1,15 +0,0 @@
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel
-
-
-class Memory(BaseModel):
-    """Model for Agent Memories"""
-
-    memory: str
-    id: Optional[str] = None
-    topic: Optional[str] = None
-    input: Optional[str] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        return self.model_dump(exclude_none=True)

agno/memory/row.py

@@ -1,36 +0,0 @@
-import json
-from datetime import datetime
-from hashlib import md5
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel, ConfigDict, model_validator
-
-
-class MemoryRow(BaseModel):
-    """Memory Row that is stored in the database"""
-
-    memory: Dict[str, Any]
-    user_id: Optional[str] = None
-    created_at: Optional[datetime] = None
-    updated_at: Optional[datetime] = None
-    # id for this memory, auto-generated from the memory
-    id: Optional[str] = None
-
-    model_config = ConfigDict(from_attributes=True, arbitrary_types_allowed=True)
-
-    def serializable_dict(self) -> Dict[str, Any]:
-        _dict = self.model_dump(exclude={"created_at", "updated_at"})
-        _dict["created_at"] = self.created_at.isoformat() if self.created_at else None
-        _dict["updated_at"] = self.updated_at.isoformat() if self.updated_at else None
-        return _dict
-
-    def to_dict(self) -> Dict[str, Any]:
-        return self.serializable_dict()
-
-    @model_validator(mode="after")
-    def generate_id(self) -> "MemoryRow":
-        if self.id is None:
-            memory_str = json.dumps(self.memory, sort_keys=True)
-            cleaned_memory = memory_str.replace(" ", "").replace("\n", "").replace("\t", "")
-            self.id = md5(cleaned_memory.encode()).hexdigest()
-        return self

agno/memory/summarizer.py

@@ -1,192 +0,0 @@
-import json
-from textwrap import dedent
-from typing import Any, Dict, List, Optional, Tuple, cast
-
-from pydantic import BaseModel, ValidationError
-
-from agno.memory.summary import SessionSummary
-from agno.models.base import Model
-from agno.models.message import Message
-from agno.utils.log import logger
-
-
-class MemorySummarizer(BaseModel):
-    model: Optional[Model] = None
-    use_structured_outputs: bool = False
-
-    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")
-
-        # Set response_format if it is not set on the Model
-        if self.use_structured_outputs:
-            self.model.response_format = SessionSummary
-            self.model.structured_outputs = True
-        else:
-            self.model.response_format = {"type": "json_object"}
-
-    def get_system_message(self, messages_for_summarization: List[Dict[str, str]]) -> Message:
-        # -*- Return a system message for summarization
-        system_prompt = dedent("""\
-        Analyze the following conversation between a user and an assistant, and extract the following details:
-          - Summary (str): Provide a concise summary of the session, focusing on important information that would be helpful for future interactions.
-          - Topics (Optional[List[str]]): List the topics discussed in the session.
-        Please ignore any frivolous information.
-
-        Conversation:
-        """)
-        conversation = []
-        for message_pair in messages_for_summarization:
-            conversation.append(f"User: {message_pair['user']}")
-            if "assistant" in message_pair:
-                conversation.append(f"Assistant: {message_pair['assistant']}")
-            elif "model" in message_pair:
-                conversation.append(f"Assistant: {message_pair['model']}")
-
-        system_prompt += "\n".join(conversation)
-
-        if not self.use_structured_outputs:
-            system_prompt += "\n\nProvide your output as a JSON containing the following fields:"
-            json_schema = SessionSummary.model_json_schema()
-            response_model_properties = {}
-            json_schema_properties = json_schema.get("properties")
-            if json_schema_properties is not None:
-                for field_name, field_properties in json_schema_properties.items():
-                    formatted_field_properties = {
-                        prop_name: prop_value
-                        for prop_name, prop_value in field_properties.items()
-                        if prop_name != "title"
-                    }
-                    response_model_properties[field_name] = formatted_field_properties
-
-            if len(response_model_properties) > 0:
-                system_prompt += "\n<json_fields>"
-                system_prompt += f"\n{json.dumps([key for key in response_model_properties.keys() if key != '$defs'])}"
-                system_prompt += "\n</json_fields>"
-                system_prompt += "\nHere are the properties for each field:"
-                system_prompt += "\n<json_field_properties>"
-                system_prompt += f"\n{json.dumps(response_model_properties, indent=2)}"
-                system_prompt += "\n</json_field_properties>"
-
-            system_prompt += "\nStart your response with `{` and end it with `}`."
-            system_prompt += "\nYour output will be passed to json.loads() to convert it to a Python object."
-            system_prompt += "\nMake sure it only contains valid JSON."
-        return Message(role="system", content=system_prompt)
-
-    def run(
-        self,
-        message_pairs: List[Tuple[Message, Message]],
-        **kwargs: Any,
-    ) -> Optional[SessionSummary]:
-        logger.debug("*********** MemorySummarizer Start ***********")
-
-        if message_pairs is None or len(message_pairs) == 0:
-            logger.info("No message pairs provided for summarization.")
-            return None
-
-        # Update the Model (set defaults, add logit etc.)
-        self.update_model()
-
-        # Convert the message pairs to a list of dictionaries
-        messages_for_summarization: List[Dict[str, str]] = []
-        for message_pair in message_pairs:
-            user_message, assistant_message = message_pair
-            messages_for_summarization.append(
-                {
-                    user_message.role: user_message.get_content_string(),
-                    assistant_message.role: assistant_message.get_content_string(),
-                }
-            )
-
-        # Prepare the List of messages to send to the Model
-        messages_for_model: List[Message] = [self.get_system_message(messages_for_summarization)]
-        # 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("*********** MemorySummarizer End ***********")
-
-        # If the model natively supports structured outputs, the parsed value is already in the structured format
-        if self.use_structured_outputs and response.parsed is not None and isinstance(response.parsed, SessionSummary):
-            return response.parsed
-
-        # Otherwise convert the response to the structured format
-        if isinstance(response.content, str):
-            try:
-                session_summary = None
-                try:
-                    session_summary = SessionSummary.model_validate_json(response.content)
-                except ValidationError:
-                    # Check if response starts with ```json
-                    if response.content.startswith("```json"):
-                        response.content = response.content.replace("```json\n", "").replace("\n```", "")
-                        try:
-                            session_summary = SessionSummary.model_validate_json(response.content)
-                        except ValidationError as exc:
-                            logger.warning(f"Failed to validate session_summary response: {exc}")
-                return session_summary
-            except Exception as e:
-                logger.warning(f"Failed to convert response to session_summary: {e}")
-        return None
-
-    async def arun(
-        self,
-        message_pairs: List[Tuple[Message, Message]],
-        **kwargs: Any,
-    ) -> Optional[SessionSummary]:
-        logger.debug("*********** Async MemorySummarizer Start ***********")
-
-        if message_pairs is None or len(message_pairs) == 0:
-            logger.info("No message pairs provided for summarization.")
-            return None
-
-        # Update the Model (set defaults, add logit etc.)
-        self.update_model()
-
-        # Convert the message pairs to a list of dictionaries
-        messages_for_summarization: List[Dict[str, str]] = []
-        for message_pair in message_pairs:
-            user_message, assistant_message = message_pair
-            messages_for_summarization.append(
-                {
-                    user_message.role: user_message.get_content_string(),
-                    assistant_message.role: assistant_message.get_content_string(),
-                }
-            )
-
-        # Prepare the List of messages to send to the Model
-        messages_for_model: List[Message] = [self.get_system_message(messages_for_summarization)]
-        # 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 MemorySummarizer End ***********")
-
-        # If the model natively supports structured outputs, the parsed value is already in the structured format
-        if self.use_structured_outputs and response.parsed is not None and isinstance(response.parsed, SessionSummary):
-            return response.parsed
-
-        # Otherwise convert the response to the structured format
-        if isinstance(response.content, str):
-            try:
-                session_summary = None
-                try:
-                    session_summary = SessionSummary.model_validate_json(response.content)
-                except ValidationError:
-                    # Check if response starts with ```json
-                    if response.content.startswith("```json"):
-                        response.content = response.content.replace("```json\n", "").replace("\n```", "")
-                        try:
-                            session_summary = SessionSummary.model_validate_json(response.content)
-                        except ValidationError as exc:
-                            logger.warning(f"Failed to validate session_summary response: {exc}")
-                return session_summary
-            except Exception as e:
-                logger.warning(f"Failed to convert response to session_summary: {e}")
-        return None

agno/memory/summary.py

@@ -1,19 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel, Field
-
-
-class SessionSummary(BaseModel):
-    """Model for Session Summary."""
-
-    summary: str = Field(
-        ...,
-        description="Summary of the session. Be concise and focus on only important information. Do not make anything up.",
-    )
-    topics: Optional[List[str]] = Field(None, description="Topics discussed in the session.")
-
-    def to_dict(self) -> Dict[str, Any]:
-        return self.model_dump(exclude_none=True)
-
-    def to_json(self) -> str:
-        return self.model_dump_json(exclude_none=True, indent=2)

agno/memory/workflow.py

@@ -1,38 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel, ConfigDict
-
-from agno.run.response import RunResponse
-from agno.utils.log import logger
-
-
-class WorkflowRun(BaseModel):
-    input: Optional[Dict[str, Any]] = None
-    response: Optional[RunResponse] = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class WorkflowMemory(BaseModel):
-    runs: List[WorkflowRun] = []
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def to_dict(self) -> Dict[str, Any]:
-        return self.model_dump(exclude_none=True)
-
-    def add_run(self, workflow_run: WorkflowRun) -> None:
-        """Adds a WorkflowRun to the runs list."""
-        self.runs.append(workflow_run)
-        logger.debug("Added WorkflowRun to WorkflowMemory")
-
-    def clear(self) -> None:
-        """Clear the WorkflowMemory"""
-
-        self.runs = []
-
-    def deep_copy(self, *, update: Optional[Dict[str, Any]] = None) -> "WorkflowMemory":
-        new_memory = self.model_copy(deep=True, update=update)
-        # clear the new memory to remove any references to the old memory
-        new_memory.clear()
-        return new_memory

agno/models/google/gemini_openai.py

@@ -1,26 +0,0 @@
-from dataclasses import dataclass
-from os import getenv
-from typing import Optional
-
-from agno.models.openai.like import OpenAILike
-
-
-@dataclass
-class GeminiOpenAI(OpenAILike):
-    """
-    Class for interacting with the Gemini API (OpenAI).
-
-    Attributes:
-        id (str): The ID of the API.
-        name (str): The name of the API.
-        provider (str): The provider of the API.
-        api_key (Optional[str]): The API key for the xAI API.
-        base_url (Optional[str]): The base URL for the xAI API.
-    """
-
-    id: str = "gemini-1.5-flash"
-    name: str = "Gemini"
-    provider: str = "Google"
-
-    api_key: Optional[str] = getenv("GOOGLE_API_KEY", None)
-    base_url: Optional[str] = "https://generativelanguage.googleapis.com/v1beta/"