agno 2.1.10__py3-none-any.whl → 2.2.1__py3-none-any.whl

agno/knowledge/knowledge.py

@@ -547,6 +547,8 @@ class Knowledge:
                 reader = self.pdf_reader
             elif file_extension == ".docx":
                 reader = self.docx_reader
+            elif file_extension == ".pptx":
+                reader = self.pptx_reader
             elif file_extension == ".json":
                 reader = self.json_reader
             elif file_extension == ".markdown":
@@ -835,6 +837,8 @@ class Knowledge:
                     reader = self.csv_reader
                 elif s3_object.uri.endswith(".docx"):
                     reader = self.docx_reader
+                elif s3_object.uri.endswith(".pptx"):
+                    reader = self.pptx_reader
                 elif s3_object.uri.endswith(".json"):
                     reader = self.json_reader
                 elif s3_object.uri.endswith(".markdown"):
@@ -917,6 +921,8 @@ class Knowledge:
                     reader = self.csv_reader
                 elif gcs_object.name.endswith(".docx"):
                     reader = self.docx_reader
+                elif gcs_object.name.endswith(".pptx"):
+                    reader = self.pptx_reader
                 elif gcs_object.name.endswith(".json"):
                     reader = self.json_reader
                 elif gcs_object.name.endswith(".markdown"):
@@ -1893,6 +1899,11 @@ class Knowledge:
         """Docx reader - lazy loaded via factory."""
         return self._get_reader("docx")
 
+    @property
+    def pptx_reader(self) -> Optional[Reader]:
+        """PPTX reader - lazy loaded via factory."""
+        return self._get_reader("pptx")
+
     @property
     def json_reader(self) -> Optional[Reader]:
         """JSON reader - lazy loaded via factory."""

agno/knowledge/reader/pptx_reader.py

@@ -0,0 +1,101 @@
+import asyncio
+from pathlib import Path
+from typing import IO, Any, List, Optional, Union
+from uuid import uuid4
+
+from agno.knowledge.chunking.document import DocumentChunking
+from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyType
+from agno.knowledge.document.base import Document
+from agno.knowledge.reader.base import Reader
+from agno.knowledge.types import ContentType
+from agno.utils.log import log_info, logger
+
+try:
+    from pptx import Presentation  # type: ignore
+except ImportError:
+    raise ImportError("The `python-pptx` package is not installed. Please install it via `pip install python-pptx`.")
+
+
+class PPTXReader(Reader):
+    """Reader for PPTX files"""
+
+    def __init__(self, chunking_strategy: Optional[ChunkingStrategy] = DocumentChunking(), **kwargs):
+        super().__init__(chunking_strategy=chunking_strategy, **kwargs)
+
+    @classmethod
+    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+        """Get the list of supported chunking strategies for PPTX readers."""
+        return [
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
+            ChunkingStrategyType.SEMANTIC_CHUNKER,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+        ]
+
+    @classmethod
+    def get_supported_content_types(self) -> List[ContentType]:
+        return [ContentType.PPTX]
+
+    def read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
+        """Read a pptx file and return a list of documents"""
+        try:
+            if isinstance(file, Path):
+                if not file.exists():
+                    raise FileNotFoundError(f"Could not find file: {file}")
+                log_info(f"Reading: {file}")
+                presentation = Presentation(str(file))
+                doc_name = name or file.stem
+            else:
+                log_info(f"Reading uploaded file: {getattr(file, 'name', 'pptx_file')}")
+                presentation = Presentation(file)
+                doc_name = name or (
+                    getattr(file, "name", "pptx_file").split(".")[0] if hasattr(file, "name") else "pptx_file"
+                )
+
+            # Extract text from all slides
+            slide_texts = []
+            for slide_number, slide in enumerate(presentation.slides, 1):
+                slide_text = f"Slide {slide_number}:\n"
+
+                # Extract text from shapes that contain text
+                text_content = []
+                for shape in slide.shapes:
+                    if hasattr(shape, "text") and shape.text.strip():
+                        text_content.append(shape.text.strip())
+
+                if text_content:
+                    slide_text += "\n".join(text_content)
+                else:
+                    slide_text += "(No text content)"
+
+                slide_texts.append(slide_text)
+
+            doc_content = "\n\n".join(slide_texts)
+
+            documents = [
+                Document(
+                    name=doc_name,
+                    id=str(uuid4()),
+                    content=doc_content,
+                )
+            ]
+
+            if self.chunk:
+                chunked_documents = []
+                for document in documents:
+                    chunked_documents.extend(self.chunk_document(document))
+                return chunked_documents
+            return documents
+
+        except Exception as e:
+            logger.error(f"Error reading file: {e}")
+            return []
+
+    async def async_read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
+        """Asynchronously read a pptx file and return a list of documents"""
+        try:
+            return await asyncio.to_thread(self.read, file, name)
+        except Exception as e:
+            logger.error(f"Error reading file asynchronously: {e}")
+            return []

agno/knowledge/reader/reader_factory.py

@@ -58,6 +58,18 @@ class ReaderFactory:
         config.update(kwargs)
         return DocxReader(**config)
 
+    @classmethod
+    def _get_pptx_reader(cls, **kwargs) -> Reader:
+        """Get PPTX reader instance."""
+        from agno.knowledge.reader.pptx_reader import PPTXReader
+
+        config: Dict[str, Any] = {
+            "name": "PPTX Reader",
+            "description": "Extracts text content from Microsoft PowerPoint presentations (.pptx format)",
+        }
+        config.update(kwargs)
+        return PPTXReader(**config)
+
     @classmethod
     def _get_json_reader(cls, **kwargs) -> Reader:
         """Get JSON reader instance."""
@@ -202,6 +214,8 @@ class ReaderFactory:
             return cls.create_reader("csv")
         elif extension in [".docx", ".doc", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"]:
             return cls.create_reader("docx")
+        elif extension == ".pptx":
+            return cls.create_reader("pptx")
         elif extension == ".json":
             return cls.create_reader("json")
         elif extension in [".md", ".markdown"]:

agno/knowledge/types.py

@@ -20,6 +20,7 @@ class ContentType(str, Enum):
     MARKDOWN = ".md"
     DOCX = ".docx"
     DOC = ".doc"
+    PPTX = ".pptx"
     JSON = ".json"
 
     # Spreadsheet file extensions

agno/models/anthropic/claude.py

@@ -75,7 +75,7 @@ class Claude(Model):
     provider: str = "Anthropic"
 
     # Request parameters
-    max_tokens: Optional[int] = 4096
+    max_tokens: Optional[int] = 8192
     thinking: Optional[Dict[str, Any]] = None
     temperature: Optional[float] = None
     stop_sequences: Optional[List[str]] = None
@@ -656,7 +656,7 @@ class Claude(Model):
 
         # Anthropic-specific additional fields
         if response_usage.server_tool_use:
-            metrics.provider_metrics = {"server_tool_use": response_usage.server_tool_use}
+            metrics.provider_metrics = {"server_tool_use": response_usage.server_tool_use.model_dump()}
         if isinstance(response_usage, Usage):
             if response_usage.service_tier:
                 metrics.provider_metrics = metrics.provider_metrics or {}

agno/models/base.py

@@ -1237,8 +1237,8 @@ class Model(ABC):
                         if function_call.function.show_result:
                             yield ModelResponse(content=item.content)
 
-                        if isinstance(item, CustomEvent):
-                            function_call_output += str(item)
+                    if isinstance(item, CustomEvent):
+                        function_call_output += str(item)
 
                     # Yield the event itself to bubble it up
                     yield item
@@ -1626,8 +1626,8 @@ class Model(ABC):
                                 await event_queue.put(ModelResponse(content=item.content))
                                 continue
 
-                            if isinstance(item, CustomEvent):
-                                function_call_output += str(item)
+                        if isinstance(item, CustomEvent):
+                            function_call_output += str(item)
 
                         # Put the event into the queue to be yielded
                         await event_queue.put(item)

agno/models/ollama/chat.py

@@ -429,8 +429,13 @@ class Ollama(Model):
         """
         metrics = Metrics()
 
-        metrics.input_tokens = response.get("prompt_eval_count", 0)
-        metrics.output_tokens = response.get("eval_count", 0)
+        # Safely handle None values from Ollama Cloud responses
+        input_tokens = response.get("prompt_eval_count")
+        output_tokens = response.get("eval_count")
+
+        # Default to 0 if None
+        metrics.input_tokens = input_tokens if input_tokens is not None else 0
+        metrics.output_tokens = output_tokens if output_tokens is not None else 0
         metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
 
         return metrics

agno/os/app.py

@@ -312,7 +312,7 @@ class AgentOS:
                             async with self._mcp_app.lifespan(app):  # type: ignore
                                 yield
 
-                    final_lifespan = combined_lifespan
+                    final_lifespan = combined_lifespan  # type: ignore
 
                 fastapi_app = self._make_app(lifespan=final_lifespan)
             else:

agno/os/interfaces/a2a/router.py

@@ -221,7 +221,7 @@ def attach_routes(
                     session_id=context_id,
                     user_id=user_id,
                     stream=True,
-                    stream_intermediate_steps=True,
+                    stream_events=True,
                     **kwargs,
                 )
             else:
@@ -234,7 +234,7 @@ def attach_routes(
                     session_id=context_id,
                     user_id=user_id,
                     stream=True,
-                    stream_intermediate_steps=True,
+                    stream_events=True,
                     **kwargs,
                 )
 

agno/os/interfaces/agui/router.py

@@ -44,7 +44,7 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
             input=messages,
             session_id=run_input.thread_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             user_id=user_id,
         )
 
@@ -80,7 +80,7 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
             input=messages,
             session_id=input.thread_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_steps=True,
             user_id=user_id,
         )
 

agno/os/router.py

@@ -250,7 +250,7 @@ async def agent_response_streamer(
             videos=videos,
             files=files,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             **kwargs,
         )
         async for run_response_chunk in run_response:
@@ -287,7 +287,7 @@ async def agent_continue_response_streamer(
             session_id=session_id,
             user_id=user_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
         )
         async for run_response_chunk in continue_response:
             yield format_sse_event(run_response_chunk)  # type: ignore
@@ -335,7 +335,7 @@ async def team_response_streamer(
             videos=videos,
             files=files,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             **kwargs,
         )
         async for run_response_chunk in run_response:
@@ -389,12 +389,12 @@ async def handle_workflow_via_websocket(websocket: WebSocket, message: dict, os:
                 session_id = str(uuid4())
 
         # Execute workflow in background with streaming
-        workflow_result = await workflow.arun(
+        workflow_result = await workflow.arun(  # type: ignore
             input=user_message,
             session_id=session_id,
             user_id=user_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             background=True,
             websocket=websocket,
         )
@@ -435,12 +435,12 @@ async def workflow_response_streamer(
     **kwargs: Any,
 ) -> AsyncGenerator:
     try:
-        run_response = await workflow.arun(
+        run_response = workflow.arun(
             input=input,
             session_id=session_id,
             user_id=user_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             **kwargs,
         )
 

agno/os/routers/evals/schemas.py

@@ -2,7 +2,7 @@ from dataclasses import asdict
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from agno.db.schemas.evals import EvalType
 from agno.eval import AccuracyResult, PerformanceResult, ReliabilityResult
@@ -12,43 +12,43 @@ from agno.eval.reliability import ReliabilityEval
 
 
 class EvalRunInput(BaseModel):
-    agent_id: Optional[str] = None
-    team_id: Optional[str] = None
-
-    model_id: Optional[str] = None
-    model_provider: Optional[str] = None
-    eval_type: EvalType
-    input: str
-    additional_guidelines: Optional[str] = None
-    additional_context: Optional[str] = None
-    num_iterations: Optional[int] = 1
-    name: Optional[str] = None
+    agent_id: Optional[str] = Field(None, description="Agent ID to evaluate")
+    team_id: Optional[str] = Field(None, description="Team ID to evaluate")
+
+    model_id: Optional[str] = Field(None, description="Model ID to use for evaluation")
+    model_provider: Optional[str] = Field(None, description="Model provider name")
+    eval_type: EvalType = Field(..., description="Type of evaluation to run (accuracy, performance, or reliability)")
+    input: str = Field(..., description="Input text/query for the evaluation", min_length=1)
+    additional_guidelines: Optional[str] = Field(None, description="Additional guidelines for the evaluation")
+    additional_context: Optional[str] = Field(None, description="Additional context for the evaluation")
+    num_iterations: int = Field(1, description="Number of times to run the evaluation", ge=1, le=100)
+    name: Optional[str] = Field(None, description="Name for this evaluation run")
 
     # Accuracy eval specific fields
-    expected_output: Optional[str] = None
+    expected_output: Optional[str] = Field(None, description="Expected output for accuracy evaluation")
 
     # Performance eval specific fields
-    warmup_runs: Optional[int] = 0
+    warmup_runs: int = Field(0, description="Number of warmup runs before measuring performance", ge=0, le=10)
 
     # Reliability eval specific fields
-    expected_tool_calls: Optional[List[str]] = None
+    expected_tool_calls: Optional[List[str]] = Field(None, description="Expected tool calls for reliability evaluation")
 
 
 class EvalSchema(BaseModel):
-    id: str
-
-    agent_id: Optional[str] = None
-    model_id: Optional[str] = None
-    model_provider: Optional[str] = None
-    team_id: Optional[str] = None
-    workflow_id: Optional[str] = None
-    name: Optional[str] = None
-    evaluated_component_name: Optional[str] = None
-    eval_type: EvalType
-    eval_data: Dict[str, Any]
-    eval_input: Optional[Dict[str, Any]] = None
-    created_at: Optional[datetime] = None
-    updated_at: Optional[datetime] = None
+    id: str = Field(..., description="Unique identifier for the evaluation run")
+
+    agent_id: Optional[str] = Field(None, description="Agent ID that was evaluated")
+    model_id: Optional[str] = Field(None, description="Model ID used in evaluation")
+    model_provider: Optional[str] = Field(None, description="Model provider name")
+    team_id: Optional[str] = Field(None, description="Team ID that was evaluated")
+    workflow_id: Optional[str] = Field(None, description="Workflow ID that was evaluated")
+    name: Optional[str] = Field(None, description="Name of the evaluation run")
+    evaluated_component_name: Optional[str] = Field(None, description="Name of the evaluated component")
+    eval_type: EvalType = Field(..., description="Type of evaluation (accuracy, performance, or reliability)")
+    eval_data: Dict[str, Any] = Field(..., description="Evaluation results and metrics")
+    eval_input: Optional[Dict[str, Any]] = Field(None, description="Input parameters used for the evaluation")
+    created_at: Optional[datetime] = Field(None, description="Timestamp when evaluation was created")
+    updated_at: Optional[datetime] = Field(None, description="Timestamp when evaluation was last updated")
 
     @classmethod
     def from_dict(cls, eval_run: Dict[str, Any]) -> "EvalSchema":
@@ -135,8 +135,8 @@ class EvalSchema(BaseModel):
 
 
 class DeleteEvalRunsRequest(BaseModel):
-    eval_run_ids: List[str]
+    eval_run_ids: List[str] = Field(..., description="List of evaluation run IDs to delete", min_length=1)
 
 
 class UpdateEvalRunRequest(BaseModel):
-    name: str
+    name: str = Field(..., description="New name for the evaluation run", min_length=1, max_length=255)

agno/os/routers/health.py

@@ -1,3 +1,5 @@
+from datetime import datetime, timezone
+
 from fastapi import APIRouter
 
 from agno.os.schema import HealthResponse
@@ -6,6 +8,8 @@ from agno.os.schema import HealthResponse
 def get_health_router() -> APIRouter:
     router = APIRouter(tags=["Health"])
 
+    started_time_stamp = datetime.now(timezone.utc).timestamp()
+
     @router.get(
         "/health",
         operation_id="health_check",
@@ -15,11 +19,11 @@ def get_health_router() -> APIRouter:
         responses={
             200: {
                 "description": "API is healthy and operational",
-                "content": {"application/json": {"example": {"status": "ok"}}},
+                "content": {"application/json": {"example": {"status": "ok", "instantiated_at": "1760169236.778903"}}},
             }
         },
     )
     async def health_check() -> HealthResponse:
-        return HealthResponse(status="ok")
+        return HealthResponse(status="ok", instantiated_at=str(started_time_stamp))
 
     return router

agno/os/routers/knowledge/schemas.py

@@ -16,23 +16,23 @@ class ContentStatus(str, Enum):
 class ContentStatusResponse(BaseModel):
     """Response model for content status endpoint."""
 
-    status: ContentStatus
-    status_message: str = ""
+    status: ContentStatus = Field(..., description="Current processing status of the content")
+    status_message: str = Field("", description="Status message or error details")
 
 
 class ContentResponseSchema(BaseModel):
-    id: str
-    name: Optional[str] = None
-    description: Optional[str] = None
-    type: Optional[str] = None
-    size: Optional[str] = None
-    linked_to: Optional[str] = None
-    metadata: Optional[dict] = None
-    access_count: Optional[int] = None
-    status: Optional[ContentStatus] = None
-    status_message: Optional[str] = None
-    created_at: Optional[datetime] = None
-    updated_at: Optional[datetime] = None
+    id: str = Field(..., description="Unique identifier for the content")
+    name: Optional[str] = Field(None, description="Name of the content")
+    description: Optional[str] = Field(None, description="Description of the content")
+    type: Optional[str] = Field(None, description="MIME type of the content")
+    size: Optional[str] = Field(None, description="Size of the content in bytes")
+    linked_to: Optional[str] = Field(None, description="ID of related content if linked")
+    metadata: Optional[dict] = Field(None, description="Additional metadata as key-value pairs")
+    access_count: Optional[int] = Field(None, description="Number of times content has been accessed", ge=0)
+    status: Optional[ContentStatus] = Field(None, description="Processing status of the content")
+    status_message: Optional[str] = Field(None, description="Status message or error details")
+    created_at: Optional[datetime] = Field(None, description="Timestamp when content was created")
+    updated_at: Optional[datetime] = Field(None, description="Timestamp when content was last updated")
 
     @classmethod
     def from_dict(cls, content: Dict[str, Any]) -> "ContentResponseSchema":
@@ -99,37 +99,39 @@ class ContentUpdateSchema(BaseModel):
 
 
 class ReaderSchema(BaseModel):
-    id: str
-    name: Optional[str] = None
-    description: Optional[str] = None
-    chunkers: Optional[List[str]] = None
+    id: str = Field(..., description="Unique identifier for the reader")
+    name: Optional[str] = Field(None, description="Name of the reader")
+    description: Optional[str] = Field(None, description="Description of the reader's capabilities")
+    chunkers: Optional[List[str]] = Field(None, description="List of supported chunking strategies")
 
 
 class ChunkerSchema(BaseModel):
-    key: str
-    name: Optional[str] = None
-    description: Optional[str] = None
+    key: str = Field(..., description="Unique key for the chunker")
+    name: Optional[str] = Field(None, description="Name of the chunker")
+    description: Optional[str] = Field(None, description="Description of the chunking strategy")
 
 
 class VectorDbSchema(BaseModel):
-    id: str
-    name: Optional[str] = None
-    description: Optional[str] = None
-    search_types: Optional[List[str]] = None
+    id: str = Field(..., description="Unique identifier for the vector database")
+    name: Optional[str] = Field(None, description="Name of the vector database")
+    description: Optional[str] = Field(None, description="Description of the vector database")
+    search_types: Optional[List[str]] = Field(
+        None, description="List of supported search types (vector, keyword, hybrid)"
+    )
 
 
 class VectorSearchResult(BaseModel):
     """Schema for search result documents."""
 
-    id: str
-    content: str
-    name: Optional[str] = None
-    meta_data: Optional[Dict[str, Any]] = None
-    usage: Optional[Dict[str, Any]] = None
-    reranking_score: Optional[float] = None
-    content_id: Optional[str] = None
-    content_origin: Optional[str] = None
-    size: Optional[int] = None
+    id: str = Field(..., description="Unique identifier for the search result document")
+    content: str = Field(..., description="Content text of the document")
+    name: Optional[str] = Field(None, description="Name of the document")
+    meta_data: Optional[Dict[str, Any]] = Field(None, description="Metadata associated with the document")
+    usage: Optional[Dict[str, Any]] = Field(None, description="Usage statistics (e.g., token counts)")
+    reranking_score: Optional[float] = Field(None, description="Reranking score for relevance", ge=0.0, le=1.0)
+    content_id: Optional[str] = Field(None, description="ID of the source content")
+    content_origin: Optional[str] = Field(None, description="Origin URL or source of the content")
+    size: Optional[int] = Field(None, description="Size of the content in bytes", ge=0)
 
     @classmethod
     def from_document(cls, document) -> "VectorSearchResult":
@@ -153,23 +155,23 @@ class VectorSearchRequestSchema(BaseModel):
     class Meta(BaseModel):
         """Inline metadata schema for pagination."""
 
-        limit: Optional[int] = Field(20, description="Number of results per page", ge=1, le=100)
-        page: Optional[int] = Field(1, description="Page number", ge=1)
+        limit: int = Field(20, description="Number of results per page", ge=1, le=100)
+        page: int = Field(1, description="Page number", ge=1)
 
-    query: str = Field(..., description="The search query")
-    db_id: Optional[str] = Field(None, description="The content database id")
-    vector_db_ids: Optional[List[str]] = Field(None, description="List of vector database ids to search in")
-    search_type: Optional[str] = Field(None, description="The type of search to perform")
-    max_results: Optional[int] = Field(None, description="The maximum number of results to return")
-    filters: Optional[Dict[str, Any]] = Field(None, description="The filters to apply to the search")
+    query: str = Field(..., description="The search query text")
+    db_id: Optional[str] = Field(None, description="The content database ID to search in")
+    vector_db_ids: Optional[List[str]] = Field(None, description="List of vector database IDs to search in")
+    search_type: Optional[str] = Field(None, description="The type of search to perform (vector, keyword, hybrid)")
+    max_results: Optional[int] = Field(None, description="The maximum number of results to return", ge=1, le=1000)
+    filters: Optional[Dict[str, Any]] = Field(None, description="Filters to apply to the search results")
     meta: Optional[Meta] = Field(
         None, description="Pagination metadata. Limit and page number to return a subset of results."
     )
 
 
 class ConfigResponseSchema(BaseModel):
-    readers: Optional[Dict[str, ReaderSchema]] = None
-    readersForType: Optional[Dict[str, List[str]]] = None
-    chunkers: Optional[Dict[str, ChunkerSchema]] = None
-    filters: Optional[List[str]] = None
-    vector_dbs: Optional[List[VectorDbSchema]] = None
+    readers: Optional[Dict[str, ReaderSchema]] = Field(None, description="Available content readers")
+    readersForType: Optional[Dict[str, List[str]]] = Field(None, description="Mapping of content types to reader IDs")
+    chunkers: Optional[Dict[str, ChunkerSchema]] = Field(None, description="Available chunking strategies")
+    filters: Optional[List[str]] = Field(None, description="Available filter tags")
+    vector_dbs: Optional[List[VectorDbSchema]] = Field(None, description="Configured vector databases")

agno/os/routers/memory/schemas.py

@@ -1,24 +1,24 @@
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class DeleteMemoriesRequest(BaseModel):
-    memory_ids: List[str]
-    user_id: Optional[str] = None
+    memory_ids: List[str] = Field(..., description="List of memory IDs to delete", min_length=1)
+    user_id: Optional[str] = Field(None, description="User ID to filter memories for deletion")
 
 
 class UserMemorySchema(BaseModel):
-    memory_id: str
-    memory: str
-    topics: Optional[List[str]]
+    memory_id: str = Field(..., description="Unique identifier for the memory")
+    memory: str = Field(..., description="Memory content text", min_length=1)
+    topics: Optional[List[str]] = Field(None, description="Topics or tags associated with the memory")
 
-    agent_id: Optional[str]
-    team_id: Optional[str]
-    user_id: Optional[str]
+    agent_id: Optional[str] = Field(None, description="Agent ID associated with this memory")
+    team_id: Optional[str] = Field(None, description="Team ID associated with this memory")
+    user_id: Optional[str] = Field(None, description="User ID who owns this memory")
 
-    updated_at: Optional[datetime]
+    updated_at: Optional[datetime] = Field(None, description="Timestamp when memory was last updated")
 
     @classmethod
     def from_dict(cls, memory_dict: Dict[str, Any]) -> "UserMemorySchema":
@@ -36,17 +36,17 @@ class UserMemorySchema(BaseModel):
 class UserMemoryCreateSchema(BaseModel):
     """Define the payload expected for creating a new user memory"""
 
-    memory: str
-    user_id: Optional[str] = None
-    topics: Optional[List[str]] = None
+    memory: str = Field(..., description="Memory content text", min_length=1, max_length=5000)
+    user_id: Optional[str] = Field(None, description="User ID who owns this memory")
+    topics: Optional[List[str]] = Field(None, description="Topics or tags to categorize the memory")
 
 
 class UserStatsSchema(BaseModel):
     """Schema for user memory statistics"""
 
-    user_id: str
-    total_memories: int
-    last_memory_updated_at: Optional[datetime] = None
+    user_id: str = Field(..., description="User ID")
+    total_memories: int = Field(..., description="Total number of memories for this user", ge=0)
+    last_memory_updated_at: Optional[datetime] = Field(None, description="Timestamp of the most recent memory update")
 
     @classmethod
     def from_dict(cls, user_stats_dict: Dict[str, Any]) -> "UserStatsSchema":