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

agno/tools/mem0.py

@@ -0,0 +1,193 @@
+import json
+from os import getenv
+from typing import Any, Dict, List, Optional, Union
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_error, log_warning
+
+try:
+    from mem0.client.main import MemoryClient
+    from mem0.memory.main import Memory
+except ImportError:
+    raise ImportError("`mem0ai` package not found. Please install it with `pip install mem0ai`")
+
+
+class Mem0Tools(Toolkit):
+    def __init__(
+        self,
+        config: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        user_id: Optional[str] = None,
+        org_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+        infer: bool = True,
+        enable_add_memory: bool = True,
+        enable_search_memory: bool = True,
+        enable_get_all_memories: bool = True,
+        enable_delete_all_memories: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        tools: List[Any] = []
+        if enable_add_memory or all:
+            tools.append(self.add_memory)
+        if enable_search_memory or all:
+            tools.append(self.search_memory)
+        if enable_get_all_memories or all:
+            tools.append(self.get_all_memories)
+        if enable_delete_all_memories or all:
+            tools.append(self.delete_all_memories)
+
+        super().__init__(name="mem0_tools", tools=tools, **kwargs)
+        self.api_key = api_key or getenv("MEM0_API_KEY")
+        self.user_id = user_id
+        self.org_id = org_id or getenv("MEM0_ORG_ID")
+        self.project_id = project_id or getenv("MEM0_PROJECT_ID")
+        self.client: Union[Memory, MemoryClient]
+        self.infer = infer
+
+        try:
+            if self.api_key:
+                log_debug("Using Mem0 Platform API key.")
+                client_kwargs = {"api_key": self.api_key}
+                if self.org_id:
+                    client_kwargs["org_id"] = self.org_id
+                if self.project_id:
+                    client_kwargs["project_id"] = self.project_id
+                self.client = MemoryClient(**client_kwargs)
+            elif config is not None:
+                log_debug("Using Mem0 with config.")
+                self.client = Memory.from_config(config)
+            else:
+                log_debug("Initializing Mem0 with default settings.")
+                self.client = Memory()
+        except Exception as e:
+            log_error(f"Failed to initialize Mem0 client: {e}")
+            raise ConnectionError("Failed to initialize Mem0 client. Ensure API keys/config are set.") from e
+
+    def _get_user_id(
+        self,
+        method_name: str,
+        session_state: Dict[str, Any],
+    ) -> str:
+        """Resolve the user ID"""
+        resolved_user_id = self.user_id
+        if not resolved_user_id:
+            try:
+                resolved_user_id = session_state.get("current_user_id")
+            except Exception:
+                pass
+        if not resolved_user_id:
+            error_msg = f"Error in {method_name}: A user_id must be provided in the method call."
+            log_error(error_msg)
+            return error_msg
+        return resolved_user_id
+
+    def add_memory(
+        self,
+        session_state,
+        content: Union[str, Dict[str, str]],
+    ) -> str:
+        """Add facts to the user's memory.
+        Args:
+            content(Union[str, Dict[str, str]]): The facts that should be stored.
+            Example:
+                content = "I live in NYC"
+                content = {"Name": "John", "Age": 30, "Location": "New York"}
+        Returns:
+            str: JSON-encoded Mem0 response or an error message.
+        """
+
+        resolved_user_id = self._get_user_id("add_memory", session_state=session_state)
+        if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in add_memory:"):
+            return resolved_user_id
+        try:
+            if isinstance(content, dict):
+                log_debug("Wrapping dict message into content string")
+                content = json.dumps(content)
+            elif not isinstance(content, str):
+                content = str(content)
+            messages_list = [{"role": "user", "content": content}]
+
+            result = self.client.add(
+                messages_list,
+                user_id=resolved_user_id,
+                infer=self.infer,
+            )
+            return json.dumps(result)
+        except Exception as e:
+            log_error(f"Error adding memory: {e}")
+            return f"Error adding memory: {e}"
+
+    def search_memory(
+        self,
+        session_state: Dict[str, Any],
+        query: str,
+    ) -> str:
+        """Semantic search for *query* across the user's stored memories."""
+
+        resolved_user_id = self._get_user_id("search_memory", session_state=session_state)
+        if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in search_memory:"):
+            return resolved_user_id
+        try:
+            results = self.client.search(
+                query=query,
+                user_id=resolved_user_id,
+            )
+
+            if isinstance(results, dict) and "results" in results:
+                search_results_list = results.get("results", [])
+            elif isinstance(results, list):
+                search_results_list = results
+            else:
+                log_warning(f"Unexpected return type from mem0.search: {type(results)}. Returning empty list.")
+                search_results_list = []
+
+            return json.dumps(search_results_list)
+        except ValueError as ve:
+            log_error(str(ve))
+            return str(ve)
+        except Exception as e:
+            log_error(f"Error searching memory: {e}")
+            return f"Error searching memory: {e}"
+
+    def get_all_memories(self, session_state: Dict[str, Any]) -> str:
+        """Return **all** memories for the current user as a JSON string."""
+
+        resolved_user_id = self._get_user_id("get_all_memories", session_state=session_state)
+        if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in get_all_memories:"):
+            return resolved_user_id
+        try:
+            results = self.client.get_all(
+                user_id=resolved_user_id,
+            )
+
+            if isinstance(results, dict) and "results" in results:
+                memories_list = results.get("results", [])
+            elif isinstance(results, list):
+                memories_list = results
+            else:
+                log_warning(f"Unexpected return type from mem0.get_all: {type(results)}. Returning empty list.")
+                memories_list = []
+            return json.dumps(memories_list)
+        except ValueError as ve:
+            log_error(str(ve))
+            return str(ve)
+        except Exception as e:
+            log_error(f"Error getting all memories: {e}")
+            return f"Error getting all memories: {e}"
+
+    def delete_all_memories(self, session_state: Dict[str, Any]) -> str:
+        """Delete *all* memories associated with the current user"""
+
+        resolved_user_id = self._get_user_id("delete_all_memories", session_state=session_state)
+        if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in delete_all_memories:"):
+            error_msg = resolved_user_id
+            log_error(error_msg)
+            return f"Error deleting all memories: {error_msg}"
+        try:
+            self.client.delete_all(user_id=resolved_user_id)
+            return f"Successfully deleted all memories for user_id: {resolved_user_id}."
+        except Exception as e:
+            log_error(f"Error deleting all memories: {e}")
+            return f"Error deleting all memories: {e}"

agno/tools/memory.py

@@ -0,0 +1,419 @@
+import json
+from textwrap import dedent
+from typing import Any, Dict, List, Optional
+from uuid import uuid4
+
+from agno.db.base import BaseDb
+from agno.db.schemas import UserMemory
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_error
+
+
+class MemoryTools(Toolkit):
+    def __init__(
+        self,
+        db: BaseDb,
+        enable_get_memories: bool = True,
+        enable_add_memory: bool = True,
+        enable_update_memory: bool = True,
+        enable_delete_memory: bool = True,
+        enable_analyze: bool = True,
+        enable_think: bool = True,
+        instructions: Optional[str] = None,
+        add_instructions: bool = True,
+        add_few_shot: bool = True,
+        few_shot_examples: Optional[str] = None,
+        all: bool = False,
+        **kwargs,
+    ):
+        # Add instructions for using this toolkit
+        if instructions is None:
+            self.instructions = self.DEFAULT_INSTRUCTIONS
+            if add_few_shot:
+                if few_shot_examples is not None:
+                    self.instructions += "\n" + few_shot_examples
+                else:
+                    self.instructions += "\n" + self.FEW_SHOT_EXAMPLES
+        else:
+            self.instructions = instructions
+
+        # The database to use for memory operations
+        self.db: BaseDb = db
+
+        tools: List[Any] = []
+        if enable_think or all:
+            tools.append(self.think)
+        if enable_get_memories or all:
+            tools.append(self.get_memories)
+        if enable_add_memory or all:
+            tools.append(self.add_memory)
+        if enable_update_memory or all:
+            tools.append(self.update_memory)
+        if enable_delete_memory or all:
+            tools.append(self.delete_memory)
+        if enable_analyze or all:
+            tools.append(self.analyze)
+
+        super().__init__(
+            name="memory_tools",
+            instructions=self.instructions,
+            add_instructions=add_instructions,
+            tools=tools,
+            **kwargs,
+        )
+
+    def think(self, session_state: Dict[str, Any], thought: str) -> str:
+        """Use this tool as a scratchpad to reason about memory operations, refine your approach, brainstorm memory content, or revise your plan.
+
+        Call `Think` whenever you need to figure out what to do next, analyze the user's requirements, plan memory operations, or decide on execution strategy.
+        You should use this tool as frequently as needed.
+
+        Args:
+            thought: Your thought process and reasoning about memory operations.
+        """
+        try:
+            log_debug(f"Memory Thought: {thought}")
+
+            # Add the thought to the session state
+            if session_state is None:
+                session_state = {}
+            if "memory_thoughts" not in session_state:
+                session_state["memory_thoughts"] = []
+            session_state["memory_thoughts"].append(thought)
+
+            # Return the full log of thoughts and the new thought
+            thoughts = "\n".join([f"- {t}" for t in session_state["memory_thoughts"]])
+            formatted_thoughts = dedent(
+                f"""Memory Thoughts:
+                {thoughts}
+                """
+            ).strip()
+            return formatted_thoughts
+        except Exception as e:
+            log_error(f"Error recording memory thought: {e}")
+            return f"Error recording memory thought: {e}"
+
+    def get_memories(self, session_state: Dict[str, Any]) -> str:
+        """
+        Use this tool to get a list of memories for the current user from the database.
+        """
+        try:
+            # Get user info from session state
+            user_id = session_state.get("current_user_id") if session_state else None
+
+            memories = self.db.get_user_memories(user_id=user_id)
+
+            # Store the result in session state for analysis
+            if session_state is None:
+                session_state = {}
+            if "memory_operations" not in session_state:
+                session_state["memory_operations"] = []
+
+            operation_result = {
+                "operation": "get_memories",
+                "success": True,
+                "memories": [memory.to_dict() for memory in memories],  # type: ignore
+                "error": None,
+            }
+            session_state["memory_operations"].append(operation_result)
+
+            return json.dumps([memory.to_dict() for memory in memories], indent=2)  # type: ignore
+        except Exception as e:
+            log_error(f"Error getting memories: {e}")
+            return json.dumps({"error": str(e)}, indent=2)
+
+    def add_memory(
+        self,
+        session_state: Dict[str, Any],
+        memory: str,
+        topics: Optional[List[str]] = None,
+    ) -> str:
+        """Use this tool to add a new memory to the database.
+
+        Args:
+            memory: The memory content to store
+            topics: Optional list of topics associated with this memory
+
+        Returns:
+            str: JSON string containing the created memory information
+        """
+        try:
+            log_debug(f"Adding memory: {memory}")
+
+            # Get user and agent info from session state
+            user_id = session_state.get("current_user_id") if session_state else None
+
+            # Create UserMemory object
+            user_memory = UserMemory(
+                memory_id=str(uuid4()),
+                memory=memory,
+                topics=topics,
+                user_id=user_id,
+            )
+
+            # Add to database
+            created_memory = self.db.upsert_user_memory(user_memory)
+
+            # Store the result in session state for analysis
+            if session_state is None:
+                session_state = {}
+            if "memory_operations" not in session_state:
+                session_state["memory_operations"] = []
+
+            memory_dict = created_memory.to_dict() if created_memory else None  # type: ignore
+
+            operation_result = {
+                "operation": "add_memory",
+                "success": created_memory is not None,
+                "memory": memory_dict,
+                "error": None,
+            }
+            session_state["memory_operations"].append(operation_result)
+
+            if created_memory:
+                return json.dumps({"success": True, "operation": "add_memory", "memory": memory_dict}, indent=2)
+            else:
+                return json.dumps(
+                    {"success": False, "operation": "add_memory", "error": "Failed to create memory"}, indent=2
+                )
+
+        except Exception as e:
+            log_error(f"Error adding memory: {e}")
+            return json.dumps({"success": False, "operation": "add_memory", "error": str(e)}, indent=2)
+
+    def update_memory(
+        self,
+        session_state: Dict[str, Any],
+        memory_id: str,
+        memory: Optional[str] = None,
+        topics: Optional[List[str]] = None,
+    ) -> str:
+        """Use this tool to update an existing memory in the database.
+
+        Args:
+            memory_id: The ID of the memory to update
+            memory: Updated memory content (if provided)
+            topics: Updated list of topics (if provided)
+
+        Returns:
+            str: JSON string containing the updated memory information
+        """
+        try:
+            log_debug(f"Updating memory: {memory_id}")
+
+            # First get the existing memory
+            existing_memory = self.db.get_user_memory(memory_id)
+            if not existing_memory:
+                return json.dumps(
+                    {"success": False, "operation": "update_memory", "error": f"Memory with ID {memory_id} not found"},
+                    indent=2,
+                )
+
+            # Update fields if provided
+            updated_memory = UserMemory(
+                memory=memory if memory is not None else existing_memory.memory,  # type: ignore
+                memory_id=memory_id,
+                topics=topics if topics is not None else existing_memory.topics,  # type: ignore
+                user_id=existing_memory.user_id,  # type: ignore
+            )
+
+            # Update in database
+            updated_result = self.db.upsert_user_memory(updated_memory)
+
+            # Store the result in session state for analysis
+            if session_state is None:
+                session_state = {}
+            if "memory_operations" not in session_state:
+                session_state["memory_operations"] = []
+
+            memory_dict = updated_result.to_dict() if updated_result else None  # type: ignore
+
+            operation_result = {
+                "operation": "update_memory",
+                "success": updated_result is not None,
+                "memory": memory_dict,
+                "error": None,
+            }
+            session_state["memory_operations"].append(operation_result)
+
+            if updated_result:
+                return json.dumps({"success": True, "operation": "update_memory", "memory": memory_dict}, indent=2)
+            else:
+                return json.dumps(
+                    {"success": False, "operation": "update_memory", "error": "Failed to update memory"}, indent=2
+                )
+
+        except Exception as e:
+            log_error(f"Error updating memory: {e}")
+            return json.dumps({"success": False, "operation": "update_memory", "error": str(e)}, indent=2)
+
+    def delete_memory(
+        self,
+        session_state: Dict[str, Any],
+        memory_id: str,
+    ) -> str:
+        """Use this tool to delete a memory from the database.
+
+        Args:
+            memory_id: The ID of the memory to delete
+
+        Returns:
+            str: JSON string containing the deletion result
+        """
+        try:
+            log_debug(f"Deleting memory: {memory_id}")
+
+            # Check if memory exists before deletion
+            existing_memory = self.db.get_user_memory(memory_id)
+            if not existing_memory:
+                return json.dumps(
+                    {"success": False, "operation": "delete_memory", "error": f"Memory with ID {memory_id} not found"},
+                    indent=2,
+                )
+
+            # Delete from database
+            self.db.delete_user_memory(memory_id)
+
+            # Store the result in session state for analysis
+            if session_state is None:
+                session_state = {}
+            if "memory_operations" not in session_state:
+                session_state["memory_operations"] = []
+
+            memory_dict = existing_memory.to_dict() if existing_memory else None  # type: ignore
+
+            operation_result = {
+                "operation": "delete_memory",
+                "success": True,
+                "memory_id": memory_id,
+                "deleted_memory": memory_dict,
+                "error": None,
+            }
+            session_state["memory_operations"].append(operation_result)
+
+            return json.dumps(
+                {
+                    "success": True,
+                    "operation": "delete_memory",
+                    "memory_id": memory_id,
+                    "deleted_memory": memory_dict,
+                },
+                indent=2,
+            )
+
+        except Exception as e:
+            log_error(f"Error deleting memory: {e}")
+            return json.dumps({"success": False, "operation": "delete_memory", "error": str(e)}, indent=2)
+
+    def analyze(self, session_state: Dict[str, Any], analysis: str) -> str:
+        """Use this tool to evaluate whether the memory operations results are correct and sufficient.
+        If not, go back to "Think" or use memory operations with refined parameters.
+
+        Args:
+            analysis: Your analysis of the memory operations results.
+        """
+        try:
+            log_debug(f"Memory Analysis: {analysis}")
+
+            # Add the analysis to the session state
+            if session_state is None:
+                session_state = {}
+            if "memory_analysis" not in session_state:
+                session_state["memory_analysis"] = []
+            session_state["memory_analysis"].append(analysis)
+
+            # Return the full log of analysis and the new analysis
+            analysis_log = "\n".join([f"- {a}" for a in session_state["memory_analysis"]])
+            formatted_analysis = dedent(
+                f"""Memory Analysis:
+                {analysis_log}
+                """
+            ).strip()
+            return formatted_analysis
+        except Exception as e:
+            log_error(f"Error recording memory analysis: {e}")
+            return f"Error recording memory analysis: {e}"
+
+    DEFAULT_INSTRUCTIONS = dedent("""\
+        You have access to the Think, Add Memory, Update Memory, Delete Memory, and Analyze tools that will help you manage user memories and analyze their operations. Use these tools as frequently as needed to successfully complete memory management tasks.
+
+        ## How to use the Think, Memory Operations, and Analyze tools:
+        
+        1. **Think**
+        - Purpose: A scratchpad for planning memory operations, brainstorming memory content, and refining your approach. You never reveal your "Think" content to the user.
+        - Usage: Call `think` whenever you need to figure out what memory operations to perform, analyze requirements, or decide on strategy.
+
+        2. **Get Memories**
+        - Purpose: Retrieves a list of memories from the database for the current user.
+        - Usage: Call `get_memories` when you need to retrieve memories for the current user.
+
+        3. **Add Memory**
+        - Purpose: Creates new memories in the database with specified content and metadata.
+        - Usage: Call `add_memory` with memory content and optional topics when you need to store new information.
+
+        4. **Update Memory**
+        - Purpose: Modifies existing memories in the database by memory ID.
+        - Usage: Call `update_memory` with a memory ID and the fields you want to change. Only specify the fields that need updating.
+
+        5. **Delete Memory**
+        - Purpose: Removes memories from the database by memory ID.
+        - Usage: Call `delete_memory` with a memory ID when a memory is no longer needed or requested to be removed.
+
+        6. **Analyze**
+        - Purpose: Evaluate whether the memory operations results are correct and sufficient. If not, go back to "Think" or use memory operations with refined parameters.
+        - Usage: Call `analyze` after performing memory operations to verify:
+            - Success: Did the operation complete successfully?
+            - Accuracy: Is the memory content correct and well-formed?
+            - Completeness: Are all required fields populated appropriately?
+            - Errors: Were there any failures or unexpected behaviors?
+
+        **Important Guidelines**:
+        - Do not include your internal chain-of-thought in direct user responses.
+        - Use "Think" to reason internally. These notes are never exposed to the user.
+        - When you provide a final answer to the user, be clear, concise, and based on the memory operation results.
+        - If memory operations fail or produce unexpected results, acknowledge limitations and explain what went wrong.
+        - Always verify memory IDs exist before attempting updates or deletions.
+        - Use descriptive topics and clear memory content to make memories easily searchable and understandable.\
+    """)
+
+    FEW_SHOT_EXAMPLES = dedent("""\
+        You can refer to the examples below as guidance for how to use each tool.
+
+        ### Examples
+
+        #### Example 1: Adding User Preferences
+
+        User: I prefer vegetarian recipes and I'm allergic to nuts.
+        Think: I should store the user's dietary preferences. I should create a memory with this information and use relevant topics for easy retrieval.
+        Add Memory: memory="User prefers vegetarian recipes and is allergic to nuts", topics=["dietary_preferences", "allergies", "food"]
+        Analyze: Successfully created memory with dietary preferences. The topics are well-chosen for future retrieval. This should help with future food-related requests.
+
+        Final Answer: Noted. I've stored your dietary preferences. I'll remember that you prefer vegetarian recipes and have a nut allergy for future reference.
+
+        #### Example 2: Updating Existing Information
+
+        User: Actually, update my dietary info - I'm now eating fish too, so I'm pescatarian.
+        Think: The user wants to update their previous dietary preference from vegetarian to pescatarian. I need to find their existing dietary memory and update it.
+        Update Memory: memory_id="previous_memory_id", memory="User follows pescatarian diet (vegetarian + fish) and is allergic to nuts", topics=["dietary_preferences", "allergies", "food", "pescatarian"]
+        Analyze: Successfully updated the dietary preference memory. The content now accurately reflects pescatarian diet and maintains the nut allergy information.
+
+        Final Answer: I've updated your dietary preferences to reflect that you follow a pescatarian diet (vegetarian plus fish) while maintaining your nut allergy information.
+
+        #### Example 3: Removing Outdated Information
+
+        User: Please forget about my old work schedule - it's completely changed.
+        Think: The user wants me to delete their old work schedule memory since it's no longer relevant. I should find and remove that memory.
+        Delete Memory: memory_id="work_schedule_memory_id"
+        Analyze: Successfully deleted the outdated work schedule memory. The old information won't interfere with future scheduling requests.
+
+        Final Answer: I've removed your old work schedule information. Feel free to share your new schedule when you're ready, and I'll store the updated information.
+        
+        #### Example 4: Retrieving Memories
+
+        User: What have you remembered about me?
+        Think: The user wants to retrieve memories about themselves. I should use the get_memories tool to retrieve the memories.
+        Get Memories: 
+        Analyze: Successfully retrieved the memories about the user. The memories are relevant to the user's preferences and activities.
+
+        Final Answer: I've retrieved the memories about you. You like to hike in the mountains on weekends and travel to new places and experience different cultures. You are planning to travel to Africa in December.\
+    """)

agno/tools/mlx_transcribe.py

@@ -20,7 +20,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_info, logger
 
 try:
     import mlx_whisper
@@ -32,7 +32,7 @@ class MLXTranscribeTools(Toolkit):
     def __init__(
         self,
         base_dir: Optional[Path] = None,
-        read_files_in_base_dir: bool = True,
+        enable_read_files_in_base_dir: bool = True,
         path_or_hf_repo: str = "mlx-community/whisper-large-v3-turbo",
         verbose: Optional[bool] = None,
         temperature: Optional[Union[float, Tuple[float, ...]]] = None,
@@ -47,9 +47,9 @@ class MLXTranscribeTools(Toolkit):
         clip_timestamps: Optional[Union[str, List[float]]] = None,
         hallucination_silence_threshold: Optional[float] = None,
         decode_options: Optional[dict] = None,
+        all: bool = False,
+        **kwargs,
     ):
-        super().__init__(name="mlx_transcribe")
-
         self.base_dir: Path = base_dir or Path.cwd()
         self.path_or_hf_repo: str = path_or_hf_repo
         self.verbose: Optional[bool] = verbose
@@ -66,9 +66,11 @@ class MLXTranscribeTools(Toolkit):
         self.hallucination_silence_threshold: Optional[float] = hallucination_silence_threshold
         self.decode_options: Optional[dict] = decode_options
 
-        self.register(self.transcribe)
-        if read_files_in_base_dir:
-            self.register(self.read_files)
+        tools: List[Any] = [self.transcribe]
+        if enable_read_files_in_base_dir or all:
+            tools.append(self.read_files)
+
+        super().__init__(name="mlx_transcribe", tools=tools, **kwargs)
 
     def transcribe(self, file_name: str) -> str:
         """
@@ -85,7 +87,7 @@ class MLXTranscribeTools(Toolkit):
             if audio_file_path is None:
                 return "No audio file path provided"
 
-            logger.info(f"Transcribing audio file {audio_file_path}")
+            log_info(f"Transcribing audio file {audio_file_path}")
             transcription_kwargs: Dict[str, Any] = {
                 "path_or_hf_repo": self.path_or_hf_repo,
             }
@@ -130,7 +132,7 @@ class MLXTranscribeTools(Toolkit):
             str: A JSON string containing the list of files in the base directory.
         """
         try:
-            logger.info(f"Reading files in : {self.base_dir}")
+            log_info(f"Reading files in : {self.base_dir}")
             return json.dumps([str(file_name) for file_name in self.base_dir.iterdir()], indent=4)
         except Exception as e:
             logger.error(f"Error reading files: {e}")