Merge pull request #284 from MervinPraison/develop

Update PraisonAI to version 2.0.41 and enhance documentation

.gitignore

@@ -65,4 +65,5 @@ outputs
 agents/praisonaiagents/build
 agents/praisonaiagents/dist
 agents/praisonaiagents/praisonaiagents.egg-info
-.codegpt
+.codegpt
+.praison

Dockerfile

@@ -1,6 +1,6 @@
 FROM python:3.11-slim
 WORKDIR /app
 COPY . .
-RUN pip install flask praisonai==2.0.33 gunicorn markdown
+RUN pip install flask praisonai==2.0.41 gunicorn markdown
 EXPOSE 8080
 CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]

agents.yaml

@@ -1,6 +1,7 @@
 framework: praisonai
 process: sequential
 topic: create movie script about cat in mars
+memory: false
 roles:
   researcher:
     backstory: Skilled in research, with a focus on gathering accurate and relevant

agents/.cursorrules

@@ -0,0 +1,8 @@
+1. Make minimal code changes as possible
+2. if you are creating function, make sure to name it in more easy, user friendly , optimised manner. 
+3. Never copy the exact code if presented with a code from other location or file or codebase, just make it optimised
+4. Always Follow the principle LESS IS MORE
+5. Make it minimal change as possible
+6. Firstly try not to make any modification to the existing code as possible
+7. Only modify the existing code if its highly required, without that if it cant be done, then add new code section. 
+8. If you are adding new code, make sure to add it in a way that it can be easily integrated with the existing codebase. 

agents/.gitignore

@@ -83,4 +83,5 @@ dist
 build
 *.mp4 
 *.png 
-graph.py
+graph.py
+chroma_db/

agents/.praisonignore

@@ -0,0 +1,32 @@
+.cursorrules
+.gitignore
+.praisoncontext
+.praisonignore
+.windsurfrules
+async_example.py
+async_example_full.py
+async_example_full_multigroups.py
+auto_agents_example.py
+code_agents_example.py
+example_callback.py
+example_custom_tools.py
+example_sequential.py
+image.jpg
+langchain_example.py
+langchain_logs.py
+long_term.db
+mini_agents_example.py
+multimodal.py
+praisonaiagents/tools/*
+praisonaiagents/process/*
+pyproject.toml
+short_term.db
+structured_agents_example.py
+structured_response_example.py
+test.py
+tools_example.py
+uv.lock
+workflow_example_basic.py
+workflow_example_detailed.py
+__pycache__
+__pycache__/*

agents/.windsurfrules

@@ -0,0 +1,8 @@
+1. Make minimal code changes as possible
+2. if you are creating function, make sure to name it in more easy, user friendly , optimised manner. 
+3. Never copy the exact code if presented with a code from other location or file or codebase, just make it optimised
+4. Always Follow the principle LESS IS MORE
+5. Make it minimal change as possible
+6. Firstly try not to make any modification to the existing code as possible
+7. Only modify the existing code if its highly required, without that if it cant be done, then add new code section. 
+8. If you are adding new code, make sure to add it in a way that it can be easily integrated with the existing codebase. 

agents/auto_agents_example.py

@@ -0,0 +1,11 @@
+from praisonaiagents import AutoAgents
+from praisonaiagents.tools import duckduckgo
+
+agents = AutoAgents(
+    instructions="Search for information about AI Agents",
+    tools=[duckduckgo],
+    process="sequential",
+    verbose=True
+)
+
+agents.start()

agents/example2.py

@@ -1,74 +0,0 @@
-from praisonaiagents import Agent, Task, PraisonAIAgents
-from typing import List, Dict
-from duckduckgo_search import DDGS
-
-# 1. Tool
-def internet_search_tool(query: str) -> List[Dict]:
-    """
-    Perform a search using DuckDuckGo.
-
-    Args:
-        query (str): The search query.
-
-    Returns:
-        list: A list of search result titles, URLs, and snippets.
-    """
-    try:
-        results = []
-        ddgs = DDGS()
-        for result in ddgs.text(keywords=query, max_results=10):
-            results.append({
-                "title": result.get("title", ""),
-                "url": result.get("href", ""),
-                "snippet": result.get("body", "")
-            })
-        return results
-
-    except Exception as e:
-        print(f"Error during DuckDuckGo search: {e}")
-        return []
-    
-# 2. Agent
-data_agent = Agent(
-    name="DataCollector",
-    role="Search Specialist",
-    goal="Perform internet searches to collect relevant information.",
-    backstory="Expert in finding and organising internet data.",
-    tools=[internet_search_tool],
-    self_reflect=False
-)
-
-# 3. Tasks
-collect_task = Task(
-    description="Perform an internet search using the query: 'AI job trends in 2024'. Return results as a list of title, URL, and snippet.",
-    expected_output="List of search results with titles, URLs, and snippets.",
-    agent=data_agent,
-    name="collect_data",
-    is_start=True,
-    next_tasks=["validate_data"]
-)
-
-validate_task = Task(
-    description="""Validate the collected data. Check if:
-    1. At least 5 results are returned.
-    2. Each result contains a title and a URL.
-    Return validation_result as 'valid' or 'invalid' only no other text.""",
-    expected_output="Validation result indicating if data is valid or invalid.",
-    agent=data_agent,
-    name="validate_data",
-    task_type="decision",
-    condition={
-        "valid": [],  # End the workflow on valid data
-        "invalid": ["collect_data"]  # Retry data collection on invalid data
-    },
-)
-
-# 4. Workflow
-agents = PraisonAIAgents(
-    agents=[data_agent],
-    tasks=[collect_task, validate_task],
-    verbose=1,
-    process="workflow"
-)
-
-agents.start()

agents/example_custom_tools.py

@@ -0,0 +1,151 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from typing import List, Dict, Union
+from duckduckgo_search import DDGS
+from langchain_community.tools import YouTubeSearchTool
+from langchain_community.utilities import WikipediaAPIWrapper
+
+# 1. Tool
+def internet_search_tool(query: str) -> List[Dict]:
+    """
+    Perform a search using DuckDuckGo.
+
+    Args:
+        query (str): The search query.
+
+    Returns:
+        list: A list of search result titles, URLs, and snippets.
+    """
+    try:
+        results = []
+        ddgs = DDGS()
+        for result in ddgs.text(keywords=query, max_results=10):
+            results.append({
+                "title": result.get("title", ""),
+                "url": result.get("href", ""),
+                "snippet": result.get("body", "")
+            })
+        return results
+
+    except Exception as e:
+        print(f"Error during DuckDuckGo search: {e}")
+        return []
+    
+def youtube_search_tool(query: str, inspect: bool = False, max_results: int = 2):
+    """
+    Provide a custom wrapper around the YouTubeSearchTool.
+    
+    Args:
+        query (str): The search query for YouTube.
+        inspect (bool): If True, returns tool inspection info instead of search results.
+        max_results (int): Maximum number of results to return (default: 2).
+    Returns:
+        Union[List[str], dict]: List of YouTube video URLs or tool inspection info.
+    """
+    yt = YouTubeSearchTool()
+    
+    if inspect:
+        inspection_info = {
+            "type": type(yt),
+            "attributes": [attr for attr in dir(yt) if not attr.startswith('_')],
+            "methods": {
+                "run": getattr(yt, 'run', None),
+                "arun": getattr(yt, 'arun', None)
+            },
+            "properties": {
+                "name": getattr(yt, 'name', 'youtube_search'),
+                "description": getattr(yt, 'description', 'Search YouTube videos'),
+                "return_direct": getattr(yt, 'return_direct', False)
+            }
+        }
+        return inspection_info
+    
+    # Format query with max_results
+    formatted_query = f"{query}, {max_results}"
+    return yt.run(formatted_query)
+
+def wikipedia_search_tool(query: str, inspect: bool = False, max_chars: int = 4000, top_k: int = 3):
+    """
+    Provide a custom wrapper around langchain_community's WikipediaAPIWrapper.
+
+    Args:
+        query (str): A search query for Wikipedia.
+        inspect (bool): If True, returns tool inspection info instead of search results.
+        max_chars (int): Maximum characters to return (default: 4000).
+        top_k (int): Number of top results to consider (default: 3).
+    Returns:
+        Union[str, dict]: Summary from Wikipedia or tool inspection info if inspect=True.
+    """
+    w = WikipediaAPIWrapper(
+        top_k_results=top_k,
+        doc_content_chars_max=max_chars,
+        lang='en'
+    )
+    
+    if inspect:
+        inspection_info = {
+            "type": type(w),
+            "attributes": [attr for attr in dir(w) if not attr.startswith('_')],
+            "methods": {
+                "run": getattr(w, 'run', None),
+                "arun": getattr(w, 'arun', None)
+            },
+            "properties": {
+                "name": "wikipedia",
+                "description": "Search and get summaries from Wikipedia",
+                "top_k": w.top_k_results,
+                "lang": w.lang,
+                "max_chars": w.doc_content_chars_max
+            }
+        }
+        return inspection_info
+    
+    try:
+        result = w.run(query)
+        return result
+    except Exception as e:
+        return f"Error searching Wikipedia: {str(e)}"
+
+# 2. Agent
+data_agent = Agent(
+    name="DataCollector",
+    role="Search Specialist",
+    goal="Perform internet searches to collect relevant information.",
+    backstory="Expert in finding and organizing internet data from multiple sources.",
+    tools=[internet_search_tool, youtube_search_tool, wikipedia_search_tool],
+    self_reflect=False
+)
+
+# 3. Tasks
+collect_task = Task(
+    description="Perform an internet search using the query: 'AI job trends in 2024'. Return results as a list of title, URL, and snippet.",
+    expected_output="List of search results with titles, URLs, and snippets.",
+    agent=data_agent,
+    name="collect_data",
+    is_start=True,
+    next_tasks=["validate_data"]
+)
+
+validate_task = Task(
+    description="""Validate the collected data. Check if:
+    1. At least 5 results are returned.
+    2. Each result contains a title and a URL.
+    Return validation_result as 'valid' or 'invalid' only no other text.""",
+    expected_output="Validation result indicating if data is valid or invalid.",
+    agent=data_agent,
+    name="validate_data",
+    task_type="decision",
+    condition={
+        "valid": [],  # End the workflow on valid data
+        "invalid": ["collect_data"]  # Retry data collection on invalid data
+    },
+)
+
+# 4. Workflow
+agents = PraisonAIAgents(
+    agents=[data_agent],
+    tasks=[collect_task, validate_task],
+    verbose=1,
+    process="workflow"
+)
+
+agents.start()

agents/langchain_example.py

@@ -0,0 +1,30 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from langchain_community.tools import YouTubeSearchTool
+from langchain_community.utilities import WikipediaAPIWrapper
+
+# Create an agent with both tools
+agent = Agent(
+    name="SearchAgent",
+    role="Research Assistant",
+    goal="Search for information from multiple sources",
+    backstory="I am an AI assistant that can search YouTube and Wikipedia.",
+    tools=[YouTubeSearchTool, WikipediaAPIWrapper],
+    self_reflect=False
+)
+
+# Create tasks to demonstrate both tools
+task = Task(
+    name="search_task",
+    description="Search for information about 'AI advancements' on both YouTube and Wikipedia",
+    expected_output="Combined information from YouTube videos and Wikipedia articles",
+    agent=agent
+)
+
+# Create and start the workflow
+agents = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task],
+    verbose=True
+)
+
+agents.start()

agents/langchain_logs.py

@@ -0,0 +1,73 @@
+from langchain_community.tools import YouTubeSearchTool
+from langchain_community.utilities import WikipediaAPIWrapper
+
+def test_tools():
+    """Test both YouTube and Wikipedia tools"""
+    
+    print("\n=== Testing YouTube Search ===")
+    # Test YouTube
+    yt = YouTubeSearchTool()
+    
+    # Test basic search
+    print("\nBasic YouTube Search:")
+    query = "AI advancements 2024"
+    print(f"Query: {query}")
+    result = yt.run(query)
+    print(f"Results: {result}")
+    
+    # Test with max results
+    print("\nYouTube Search with max results:")
+    query = "AI advancements 2024, 3"  # Format: query, max_results
+    print(f"Query: {query}")
+    result = yt.run(query)
+    print(f"Results: {result}")
+    
+    print("\n=== Testing Wikipedia Search ===")
+    # Test Wikipedia
+    wiki = WikipediaAPIWrapper(
+        top_k_results=2,
+        doc_content_chars_max=500
+    )
+    
+    # Test basic search
+    print("\nBasic Wikipedia Search:")
+    query = "Artificial Intelligence"
+    print(f"Query: {query}")
+    result = wiki.run(query)
+    print(f"Results: {result[:200]}..." if result else "No result")
+    
+    # Test with different parameters
+    print("\nWikipedia Search with different language:")
+    wiki_fr = WikipediaAPIWrapper(
+        lang='fr',
+        top_k_results=1,
+        doc_content_chars_max=300
+    )
+    result = wiki_fr.run("Intelligence Artificielle")
+    print(f"French Results: {result[:200]}..." if result else "No result")
+
+def print_tool_info():
+    """Print detailed information about the tools"""
+    
+    print("\n=== Tool Information ===")
+    
+    # YouTube Tool Info
+    print("\nYouTube Tool:")
+    yt = YouTubeSearchTool()
+    print("Type:", type(yt))
+    print("Name:", getattr(yt, 'name', None))
+    print("Description:", getattr(yt, 'description', None))
+    print("Arguments:", getattr(yt, 'args', None))
+    
+    # Wikipedia Tool Info
+    print("\nWikipedia Tool:")
+    wiki = WikipediaAPIWrapper()
+    print("Type:", type(wiki))
+    print("Available Settings:")
+    print("- Language:", wiki.lang)
+    print("- Top K Results:", wiki.top_k_results)
+    print("- Max Characters:", wiki.doc_content_chars_max)
+
+if __name__ == "__main__":
+    print_tool_info()
+    test_tools() 

agents/memory_example.py

@@ -0,0 +1,183 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import logging
+import os
+
+def main():
+    # Initialize memory config
+    memory_config = {
+        "provider": "rag",
+        "use_embedding": True,
+        "storage": {
+            "type": "sqlite",
+            "path": "./.praison/memory.db"
+        },
+        "rag_db_path": "./.praison/chroma_db"
+    }
+    
+    # Test facts
+    fact1 = "The capital city of Jujuha is Hahanu and its population is 102300"
+    fact2 = "Three main ingredients in a classic proloder are eggs, sugar, and flour"
+    fact3 = "The year the first Josinga was released is 2007"
+    
+    # # Check if database exists
+    # if os.path.exists("./memory.db"):
+    #     logger.info("Found existing memory database")
+    # else:
+    #     logger.info("Creating new memory database")
+    
+    # Create task config (without memory config since it's moved to PraisonAIAgents)
+    task_config = {}
+
+    # Create agents with different roles
+    researcher = Agent(
+        role="Research Analyst",
+        goal="Research and document key information about topics",
+        backstory="Expert at analyzing and storing information in memory",
+        llm="gpt-4o-mini"
+    )
+    
+    retriever = Agent(
+        role="Information Retriever",
+        goal="Retrieve and verify stored information from memory",
+        backstory="Specialist in searching and validating information from memory",
+        llm="gpt-4o-mini"
+    )
+
+    # Task 1: Process the facts
+    store_task = Task(
+        description=f"""
+        Process and analyze this information:
+        1. {fact1}
+        2. {fact2}
+        3. {fact3}
+
+        Provide a clear summary of each fact.
+        """,
+        expected_output="""
+        Clear statements summarizing each fact.
+        Example format:
+        1. [Summary of fact 1]
+        2. [Summary of fact 2]
+        3. [Summary of fact 3]
+        """,
+        agent=researcher
+    )
+
+    # Task 2: Write essay about AI
+    verify_task = Task(
+        description="""
+        write few points about AI
+        """,
+        expected_output="Points about AI",
+        agent=retriever
+    )
+
+    # Task 3: Query memory
+    query_task = Task(
+        description="""
+        Using ONLY information found in memory:
+        1. What is stored in memory about Hahanu?
+        2. What ingredients for proloder are recorded in memory?
+        3. What year is stored in memory for the Josinga release?
+
+        For each answer, cite the memory record you found.
+        """,
+        expected_output="Answers based solely on memory records with citations",
+        agent=retriever
+    )
+
+    # Task 4: Query both short-term and long-term memory
+    query_both_task = Task(
+        description="""
+        Using ONLY information found in memory:
+        1. What is stored in both short-term and long-term memory about Jujuha?
+        2. What ingredients for proloder are recorded in both short-term and long-term memory?
+        3. What year is stored in both short-term and long-term memory for the Josinga release?
+
+        For each answer, cite the memory record you found.
+        """,
+        expected_output="Answers based solely on memory records with citations",
+        agent=retriever
+    )
+
+    # Initialize PraisonAIAgents with memory configuration
+    agents = PraisonAIAgents(
+        agents=[researcher, retriever],
+        tasks=[store_task, verify_task, query_task, query_both_task],
+        verbose=True,  # Use same verbose level as memory
+        memory=True,
+        embedder={
+            "provider": "openai",
+            "config": {
+                "model": "text-embedding-3-small"
+            }
+        }
+    )
+
+    # agents = PraisonAIAgents(
+    #     agents=[researcher, retriever],
+    #     tasks=[store_task, verify_task, query_task, query_both_task],
+    #     verbose=True,  # Use same verbose level as memory
+    #     memory=True
+    # )
+    
+    # Execute tasks
+    print("\nExecuting Memory Test Tasks...")
+    print("-" * 50)
+    agents.start()
+    
+    # Use shared memory for final checks
+    memory = agents.shared_memory
+    
+    # Test memory retrieval with different quality thresholds
+    if memory:
+        print("\nFinal Memory Check:")
+        print("-" * 50)
+        
+        queries = ["Jujuha", "proloder", "Josinga"]
+        for query in queries:
+            print(f"\nSearching memory for: {query}")
+            
+            # Search in both short-term and long-term memory
+            print("\nShort-term memory results:")
+            stm_results = memory.search_short_term(query)
+            if stm_results:
+                for item in stm_results:
+                    print(f"Content: {item.get('content', '')[:200]}")
+                    if 'meta' in item:
+                        print(f"Metadata: {item['meta']}")
+                    print("-" * 20)
+            else:
+                print("No results found in short-term memory")
+
+            print("\nLong-term memory results:")
+            ltm_results = memory.search_long_term(query)
+            if ltm_results:
+                for item in ltm_results:
+                    print(f"Content: {item.get('text', '')[:200]}")
+                    if 'metadata' in item:
+                        print(f"Metadata: {item['metadata']}")
+                    print("-" * 20)
+            else:
+                print("No results found in long-term memory")
+                
+            # Also check ChromaDB if using RAG
+            if memory.use_rag and hasattr(memory, "chroma_col"):
+                print("\nChromaDB results:")
+                try:
+                    all_items = memory.chroma_col.get()
+                    print(f"Found {len(all_items['ids'])} items in ChromaDB")
+                    for i in range(len(all_items['ids'])):
+                        print(f"ID: {all_items['ids'][i]}")
+                        print(f"Content: {all_items['documents'][i][:200]}")
+                        print(f"Metadata: {all_items['metadatas'][i]}")
+                        print("-" * 20)
+                except Exception as e:
+                    print(f"Error querying ChromaDB: {e}")
+            
+            print("-" * 30)
+    else:
+        print("\nNo memory available for final checks")
+
+if __name__ == "__main__":
+    main()

agents/memory_simple.py

@@ -0,0 +1,63 @@
+from praisonaiagents.agents.agents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import duckduckgo
+
+# Test facts
+fact1 = "The capital city of Jujuha is Hahanu and its population is 102300"
+fact2 = "Three main ingredients in a classic proloder are eggs, sugar, and flour"
+fact3 = "The year the first Josinga was released is 2007"
+
+fact_agent = Agent(
+    name="Fact Agent",
+    instructions="You are a fact agent, you store and retrieve facts in memory",
+    llm="gpt-4o-mini"
+)
+
+research_agent = Agent(
+    name="Research Agent",
+    instructions="You are a research analyst, you research and document key points about topics",
+    llm="gpt-4o-mini"
+)
+
+blog_agent = Agent(
+    name="Blog Agent",
+    instructions="You are a blog writer, you write a blog post about the research",
+    llm="gpt-4o-mini"
+)
+
+fact_task = Task(
+    description="Store the following facts in memory: " + fact1 + ", " + fact2 + ", " + fact3,
+    agent=fact_agent
+)
+
+research_task = Task(
+    description="Research and document 2 key points about AI",
+    agent=research_agent
+)
+
+research_task2 = Task(
+    description="Research and document 2 key points about AI in healthcare",
+    agent=research_agent
+)
+
+research_task3 = Task(
+    description="Research and document 2 key points about AI in education",
+    agent=research_agent
+)
+
+research_task4 = Task(
+    description="Research and document 2 key points about AI in finance",
+    agent=research_agent
+)
+
+blog_task = Task(
+    description="Write a blog post about Jujuha",
+    agent=blog_agent
+)
+
+agents = PraisonAIAgents(
+    agents=[fact_agent, research_agent, blog_agent],
+    tasks=[fact_task, research_task, research_task2, research_task3, research_task4, blog_task],
+    memory=True
+)   
+
+agents.start()

agents/praisonaiagents/__init__.py

@@ -6,6 +6,8 @@ from .agent.agent import Agent
 from .agents.agents import PraisonAIAgents
 from .task.task import Task
 from .tools.tools import Tools
+from .agents.autoagents import AutoAgents
+from .memory.memory import Memory
 from .main import (
     TaskOutput,
     ReflectionOutput,
@@ -33,6 +35,8 @@ __all__ = [
     'Task',
     'TaskOutput',
     'ReflectionOutput',
+    'AutoAgents',
+    'Memory',
     'display_interaction',
     'display_self_reflection',
     'display_instruction',

agents/praisonaiagents/agent/agent.py

@@ -18,6 +18,7 @@ from ..main import (
     client,
     error_logs
 )
+import inspect
 
 if TYPE_CHECKING:
     from ..task.task import Task
@@ -67,9 +68,24 @@ class Agent:
             return None
 
         import inspect
+        # Langchain tools
+        if inspect.isclass(func) and hasattr(func, 'run'):
+            original_func = func
+            func = func.run
+            function_name = original_func.__name__
+
         sig = inspect.signature(func)
         logging.debug(f"Function signature: {sig}")
         
+        # Skip self, *args, **kwargs, so they don't get passed in arguments
+        parameters_list = []
+        for name, param in sig.parameters.items():
+            if name == "self":
+                continue
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+            parameters_list.append((name, param))
+
         parameters = {
             "type": "object",
             "properties": {},
@@ -95,7 +111,7 @@ class Agent:
         
         logging.debug(f"Parameter descriptions: {param_descriptions}")
 
-        for name, param in sig.parameters.items():
+        for name, param in parameters_list:
             param_type = "string"  # Default type
             if param.annotation != inspect.Parameter.empty:
                 if param.annotation == int:
@@ -146,7 +162,7 @@ class Agent:
         max_iter: int = 20,
         max_rpm: Optional[int] = None,
         max_execution_time: Optional[int] = None,
-        memory: bool = True,
+        memory: Optional[Any] = None,
         verbose: bool = True,
         allow_delegation: bool = False,
         step_callback: Optional[Any] = None,
@@ -162,7 +178,7 @@ class Agent:
         knowledge_sources: Optional[List[Any]] = None,
         use_system_prompt: Optional[bool] = True,
         markdown: bool = True,
-        self_reflect: Optional[bool] = None,
+        self_reflect: bool = False,
         max_reflect: int = 3,
         min_reflect: int = 1,
         reflect_llm: Optional[str] = None
@@ -249,25 +265,31 @@ Your Goal: {self.goal}
         # Try to find the function in the agent's tools list first
         func = None
         for tool in self.tools:
-            if callable(tool) and getattr(tool, '__name__', '') == function_name:
+            if (callable(tool) and getattr(tool, '__name__', '') == function_name) or \
+               (inspect.isclass(tool) and tool.__name__ == function_name):
                 func = tool
                 break
         
-        logging.debug(f"Looking for {function_name} in agent tools: {func is not None}")
-        
-        # If not found in tools, try globals and main
-        if not func:
+        if func is None:
+            # If not found in tools, try globals and main
             func = globals().get(function_name)
-            logging.debug(f"Looking for {function_name} in globals: {func is not None}")
-            
             if not func:
                 import __main__
                 func = getattr(__main__, function_name, None)
-                logging.debug(f"Looking for {function_name} in __main__: {func is not None}")
 
-        if func and callable(func):
+        if func:
             try:
-                return func(**arguments)
+                # If it's a class with run method, instantiate and call run
+                if inspect.isclass(func) and hasattr(func, 'run'):
+                    instance = func()
+                    # Extract only the parameters that run() expects
+                    run_params = {k: v for k, v in arguments.items() 
+                                if k in inspect.signature(instance.run).parameters 
+                                and k != 'self'}
+                    return instance.run(**run_params)
+                # Otherwise treat as regular function
+                elif callable(func):
+                    return func(**arguments)
             except Exception as e:
                 error_msg = str(e)
                 logging.error(f"Error executing tool {function_name}: {error_msg}")
@@ -359,7 +381,7 @@ Your Goal: {self.goal}
                     display_generating("", start_time),
                     console=self.console,
                     refresh_per_second=4,
-                    transient=False,  # Changed to False to preserve output
+                    transient=True,  # Changed to False to preserve output
                     vertical_overflow="ellipsis",
                     auto_refresh=True
                 ) as live:
@@ -444,7 +466,15 @@ Your Goal: {self.goal}
                         display_text = next((item["text"] for item in prompt if item["type"] == "text"), "")
                     
                     if display_text and str(display_text).strip():
-                        display_instruction(f"Agent {self.name} is processing prompt: {display_text}", console=self.console)
+                        # Pass agent information to display_instruction
+                        agent_tools = [t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools]
+                        display_instruction(
+                            f"Agent {self.name} is processing prompt: {display_text}", 
+                            console=self.console,
+                            agent_name=self.name,
+                            agent_role=self.role,
+                            agent_tools=agent_tools
+                        )
 
                 response = self._chat_completion(messages, temperature=temperature, tools=tools if tools else None)
                 if not response:
@@ -503,7 +533,7 @@ Your Goal: {self.goal}
                     self.chat_history.append({"role": "user", "content": original_prompt})
                     self.chat_history.append({"role": "assistant", "content": response_text})
                     if self.verbose:
-                        logging.info(f"Agent {self.name} final response: {response_text}")
+                        logging.debug(f"Agent {self.name} final response: {response_text}")
                     display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
                     return response_text
 
@@ -608,6 +638,22 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             item["text"] += "\nReturn ONLY a valid JSON object. No other text or explanation."
                             break
 
+            # Display instruction with agent info if verbose
+            if self.verbose:
+                display_text = prompt
+                if isinstance(prompt, list):
+                    display_text = next((item["text"] for item in prompt if item["type"] == "text"), "")
+                
+                if display_text and str(display_text).strip():
+                    agent_tools = [t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools]
+                    await adisplay_instruction(
+                        f"Agent {self.name} is processing prompt: {display_text}",
+                        console=self.console,
+                        agent_name=self.name,
+                        agent_role=self.role,
+                        agent_tools=agent_tools
+                    )
+
             # Format tools if provided
             formatted_tools = []
             if tools:
@@ -711,4 +757,8 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             return None
         except Exception as e:
             display_error(f"Error in _achat_completion: {e}")
-            return None 
+            return None 
+
+    def run(self):
+        """Alias for start() method"""
+        return self.start() 

agents/praisonaiagents/agents/__init__.py

@@ -1,4 +1,5 @@
 """Agents module for managing multiple AI agents"""
 from .agents import PraisonAIAgents
+from .autoagents import AutoAgents
 
-__all__ = ['PraisonAIAgents'] 
+__all__ = ['PraisonAIAgents', 'AutoAgents'] 

agents/praisonaiagents/agents/agents.py

@@ -13,6 +13,9 @@ from ..task.task import Task
 from ..process.process import Process, LoopItems
 import asyncio
 
+# Set up logger
+logger = logging.getLogger(__name__)
+
 def encode_file_to_base64(file_path: str) -> str:
     """Base64-encode a file."""
     import base64
@@ -41,7 +44,7 @@ def process_video(video_path: str, seconds_per_frame=2):
     return base64_frames
 
 class PraisonAIAgents:
-    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None):
+    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None, memory=False, memory_config=None, embedder=None):
         if not agents:
             raise ValueError("At least one agent must be provided")
             
@@ -57,8 +60,21 @@ class PraisonAIAgents:
         
         # Check for manager_llm in environment variable if not provided
         self.manager_llm = manager_llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
+        
+        # Set logger level based on verbose
+        if verbose >= 5:
+            logger.setLevel(logging.INFO)
+        else:
+            logger.setLevel(logging.WARNING)
+            
+        # Also set third-party loggers to WARNING
+        logging.getLogger('chromadb').setLevel(logging.WARNING)
+        logging.getLogger('openai').setLevel(logging.WARNING)
+        logging.getLogger('httpx').setLevel(logging.WARNING)
+        logging.getLogger('httpcore').setLevel(logging.WARNING)
+
         if self.verbose:
-            logging.info(f"Using model {self.manager_llm} for manager")
+            logger.info(f"Using model {self.manager_llm} for manager")
         
         # If no tasks provided, generate them from agents
         if tasks is None:
@@ -66,12 +82,12 @@ class PraisonAIAgents:
             for agent in self.agents:
                 task = agent.generate_task()
                 tasks.append(task)
-            logging.info(f"Auto-generated {len(tasks)} tasks from agents")
+            logger.info(f"Auto-generated {len(tasks)} tasks from agents")
         else:
             # Validate tasks for backward compatibility
             if not tasks:
                 raise ValueError("If tasks are provided, at least one task must be present")
-            logging.info(f"Using {len(tasks)} provided tasks")
+            logger.info(f"Using {len(tasks)} provided tasks")
         
         # Add tasks and set their status
         for task in tasks:
@@ -87,9 +103,65 @@ class PraisonAIAgents:
                 if tasks[i + 1].context is None:
                     tasks[i + 1].context = []
                 tasks[i + 1].context.append(tasks[i])
-            logging.info("Set up sequential flow with automatic context passing")
+            logger.info("Set up sequential flow with automatic context passing")
         
         self._state = {}  # Add state storage at PraisonAIAgents level
+        
+        # Initialize memory system
+        self.shared_memory = None
+        if memory:
+            try:
+                from ..memory.memory import Memory
+                
+                # Get memory config from parameter or first task
+                mem_cfg = memory_config
+                if not mem_cfg:
+                    mem_cfg = next((t.config.get('memory_config') for t in tasks if hasattr(t, 'config') and t.config), None)
+                    
+                # Set default memory config if none provided
+                if not mem_cfg:
+                    mem_cfg = {
+                        "provider": "rag",
+                        "use_embedding": True,
+                        "storage": {
+                            "type": "sqlite",
+                            "path": "./.praison/memory.db"
+                        },
+                        "rag_db_path": "./.praison/chroma_db"
+                    }
+                
+                # Add embedder config if provided
+                if embedder:
+                    if isinstance(embedder, dict):
+                        mem_cfg = mem_cfg or {}
+                        mem_cfg["embedder"] = embedder
+                    else:
+                        # Handle direct embedder function
+                        mem_cfg = mem_cfg or {}
+                        mem_cfg["embedder_function"] = embedder
+
+                if mem_cfg:
+                    # Pass verbose level to Memory
+                    self.shared_memory = Memory(config=mem_cfg, verbose=verbose)
+                    if verbose >= 5:
+                        logger.info("Initialized shared memory for PraisonAIAgents")
+                    
+                    # Distribute memory to tasks
+                    for task in tasks:
+                        if not task.memory:
+                            task.memory = self.shared_memory
+                            if verbose >= 5:
+                                logger.info(f"Assigned shared memory to task {task.id}")
+                            
+            except Exception as e:
+                logger.error(f"Failed to initialize shared memory: {e}")
+            
+        # Update tasks with shared memory
+        if self.shared_memory:
+            for task in tasks:
+                if not task.memory:
+                    task.memory = self.shared_memory
+                    logger.info(f"Assigned shared memory to task {task.id}")
 
     def add_task(self, task):
         task_id = self.task_id_counter
@@ -142,7 +214,7 @@ class PraisonAIAgents:
         task_prompt = f"""
 You need to do the following task: {task.description}.
 Expected Output: {task.expected_output}.
-        """
+"""
         if task.context:
             context_results = ""
             for context_task in task.context:
@@ -157,8 +229,8 @@ Here are the results of previous tasks that might be useful:\n
         task_prompt += "Please provide only the final result of your work. Do not add any conversation or extra explanation."
 
         if self.verbose >= 2:
-            logging.info(f"Executing task {task_id}: {task.description} using {executor_agent.name}")
-        logging.debug(f"Starting execution of task {task_id} with prompt:\n{task_prompt}")
+            logger.info(f"Executing task {task_id}: {task.description} using {executor_agent.name}")
+        logger.debug(f"Starting execution of task {task_id} with prompt:\n{task_prompt}")
 
         if task.images:
             def _get_multimodal_message(text_prompt, images):
@@ -223,8 +295,8 @@ Here are the results of previous tasks that might be useful:\n
                     task_output.json_dict = parsed
                     task_output.output_format = "JSON"
                 except:
-                    logging.warning(f"Warning: Could not parse output of task {task_id} as JSON")
-                    logging.debug(f"Output that failed JSON parsing: {agent_output}")
+                    logger.warning(f"Warning: Could not parse output of task {task_id} as JSON")
+                    logger.debug(f"Output that failed JSON parsing: {agent_output}")
 
             if task.output_pydantic:
                 cleaned = self.clean_json_output(agent_output)
@@ -234,8 +306,8 @@ Here are the results of previous tasks that might be useful:\n
                     task_output.pydantic = pyd_obj
                     task_output.output_format = "Pydantic"
                 except:
-                    logging.warning(f"Warning: Could not parse output of task {task_id} as Pydantic Model")
-                    logging.debug(f"Output that failed Pydantic parsing: {agent_output}")
+                    logger.warning(f"Warning: Could not parse output of task {task_id} as Pydantic Model")
+                    logger.debug(f"Output that failed Pydantic parsing: {agent_output}")
 
             task.result = task_output
             return task_output
@@ -250,37 +322,53 @@ Here are the results of previous tasks that might be useful:\n
             return
         task = self.tasks[task_id]
         if task.status == "completed":
-            logging.info(f"Task with ID {task_id} is already completed")
+            logger.info(f"Task with ID {task_id} is already completed")
             return
 
         retries = 0
         while task.status != "completed" and retries < self.max_retries:
-            logging.debug(f"Attempt {retries+1} for task {task_id}")
+            logger.debug(f"Attempt {retries+1} for task {task_id}")
             if task.status in ["not started", "in progress"]:
                 task_output = await self.aexecute_task(task_id)
                 if task_output and self.completion_checker(task, task_output.raw):
                     task.status = "completed"
-                    if task.callback:
+                    # Run execute_callback for memory operations
+                    try:
                         await task.execute_callback(task_output)
+                    except Exception as e:
+                        logger.error(f"Error executing memory callback for task {task_id}: {e}")
+                        logger.exception(e)
+                    
+                    # Run task callback if exists
+                    if task.callback:
+                        try:
+                            if asyncio.iscoroutinefunction(task.callback):
+                                await task.callback(task_output)
+                            else:
+                                task.callback(task_output)
+                        except Exception as e:
+                            logger.error(f"Error executing task callback for task {task_id}: {e}")
+                            logger.exception(e)
+                            
                     self.save_output_to_file(task, task_output)
                     if self.verbose >= 1:
-                        logging.info(f"Task {task_id} completed successfully.")
+                        logger.info(f"Task {task_id} completed successfully.")
                 else:
                     task.status = "in progress"
                     if self.verbose >= 1:
-                        logging.info(f"Task {task_id} not completed, retrying")
+                        logger.info(f"Task {task_id} not completed, retrying")
                     await asyncio.sleep(1)
                     retries += 1
             else:
                 if task.status == "failed":
-                    logging.info("Task is failed, resetting to in-progress for another try...")
+                    logger.info("Task is failed, resetting to in-progress for another try...")
                     task.status = "in progress"
                 else:
-                    logging.info("Invalid Task status")
+                    logger.info("Invalid Task status")
                     break
 
         if retries == self.max_retries and task.status != "completed":
-            logging.info(f"Task {task_id} failed after {self.max_retries} retries.")
+            logger.info(f"Task {task_id} failed after {self.max_retries} retries.")
 
     async def arun_all_tasks(self):
         """Async version of run_all_tasks method"""
@@ -328,7 +416,7 @@ Here are the results of previous tasks that might be useful:\n
                 with open(task.output_file, "w") as f:
                     f.write(str(task_output))
                 if self.verbose >= 1:
-                    logging.info(f"Task output saved to {task.output_file}")
+                    logger.info(f"Task output saved to {task.output_file}")
             except Exception as e:
                 display_error(f"Error saving task output to file: {e}")
 
@@ -339,6 +427,15 @@ Here are the results of previous tasks that might be useful:\n
             return
         task = self.tasks[task_id]
         
+        logger.info(f"Starting execution of task {task_id}")
+        logger.info(f"Task config: {task.config}")
+        
+        # Initialize memory before task execution
+        if not task.memory:
+            task.memory = task.initialize_memory()
+        
+        logger.info(f"Task memory status: {'Initialized' if task.memory else 'Not initialized'}")
+        
         # Only import multimodal dependencies if task has images
         if task.images and task.status == "not started":
             try:
@@ -371,11 +468,20 @@ Expected Output: {task.expected_output}.
 Here are the results of previous tasks that might be useful:\n
 {context_results}
 """
+        # Add memory context if available
+        if task.memory:
+            try:
+                memory_context = task.memory.build_context_for_task(task.description)
+                if memory_context:
+                    task_prompt += f"\n\nRelevant memory context:\n{memory_context}"
+            except Exception as e:
+                logger.error(f"Error getting memory context: {e}")
+
         task_prompt += "Please provide only the final result of your work. Do not add any conversation or extra explanation."
 
         if self.verbose >= 2:
-            logging.info(f"Executing task {task_id}: {task.description} using {executor_agent.name}")
-        logging.debug(f"Starting execution of task {task_id} with prompt:\n{task_prompt}")
+            logger.info(f"Executing task {task_id}: {task.description} using {executor_agent.name}")
+        logger.debug(f"Starting execution of task {task_id} with prompt:\n{task_prompt}")
 
         if task.images:
             def _get_multimodal_message(text_prompt, images):
@@ -425,6 +531,17 @@ Here are the results of previous tasks that might be useful:\n
             )
 
         if agent_output:
+            # Store the response in memory
+            if task.memory:
+                try:
+                    task.store_in_memory(
+                        content=agent_output,
+                        agent_name=executor_agent.name,
+                        task_id=task_id
+                    )
+                except Exception as e:
+                    logger.error(f"Failed to store agent output in memory: {e}")
+
             task_output = TaskOutput(
                 description=task.description,
                 summary=task.description[:10],
@@ -440,8 +557,8 @@ Here are the results of previous tasks that might be useful:\n
                     task_output.json_dict = parsed
                     task_output.output_format = "JSON"
                 except:
-                    logging.warning(f"Warning: Could not parse output of task {task_id} as JSON")
-                    logging.debug(f"Output that failed JSON parsing: {agent_output}")
+                    logger.warning(f"Warning: Could not parse output of task {task_id} as JSON")
+                    logger.debug(f"Output that failed JSON parsing: {agent_output}")
 
             if task.output_pydantic:
                 cleaned = self.clean_json_output(agent_output)
@@ -451,8 +568,8 @@ Here are the results of previous tasks that might be useful:\n
                     task_output.pydantic = pyd_obj
                     task_output.output_format = "Pydantic"
                 except:
-                    logging.warning(f"Warning: Could not parse output of task {task_id} as Pydantic Model")
-                    logging.debug(f"Output that failed Pydantic parsing: {agent_output}")
+                    logger.warning(f"Warning: Could not parse output of task {task_id} as Pydantic Model")
+                    logger.debug(f"Output that failed Pydantic parsing: {agent_output}")
 
             task.result = task_output
             return task_output
@@ -467,37 +584,54 @@ Here are the results of previous tasks that might be useful:\n
             return
         task = self.tasks[task_id]
         if task.status == "completed":
-            logging.info(f"Task with ID {task_id} is already completed")
+            logger.info(f"Task with ID {task_id} is already completed")
             return
 
         retries = 0
         while task.status != "completed" and retries < self.max_retries:
-            logging.debug(f"Attempt {retries+1} for task {task_id}")
+            logger.debug(f"Attempt {retries+1} for task {task_id}")
             if task.status in ["not started", "in progress"]:
                 task_output = self.execute_task(task_id)
                 if task_output and self.completion_checker(task, task_output.raw):
                     task.status = "completed"
+                    # Run execute_callback for memory operations
+                    try:
+                        loop = asyncio.get_event_loop()
+                        loop.run_until_complete(task.execute_callback(task_output))
+                    except Exception as e:
+                        logger.error(f"Error executing memory callback for task {task_id}: {e}")
+                        logger.exception(e)
+                    
+                    # Run task callback if exists
                     if task.callback:
-                        task.callback(task_output)
+                        try:
+                            if asyncio.iscoroutinefunction(task.callback):
+                                loop.run_until_complete(task.callback(task_output))
+                            else:
+                                task.callback(task_output)
+                        except Exception as e:
+                            logger.error(f"Error executing task callback for task {task_id}: {e}")
+                            logger.exception(e)
+                            
                     self.save_output_to_file(task, task_output)
                     if self.verbose >= 1:
-                        logging.info(f"Task {task_id} completed successfully.")
+                        logger.info(f"Task {task_id} completed successfully.")
                 else:
                     task.status = "in progress"
                     if self.verbose >= 1:
-                        logging.info(f"Task {task_id} not completed, retrying")
+                        logger.info(f"Task {task_id} not completed, retrying")
                     time.sleep(1)
                     retries += 1
             else:
                 if task.status == "failed":
-                    logging.info("Task is failed, resetting to in-progress for another try...")
+                    logger.info("Task is failed, resetting to in-progress for another try...")
                     task.status = "in progress"
                 else:
-                    logging.info("Invalid Task status")
+                    logger.info("Invalid Task status")
                     break
 
         if retries == self.max_retries and task.status != "completed":
-            logging.info(f"Task {task_id} failed after {self.max_retries} retries.")
+            logger.info(f"Task {task_id} failed after {self.max_retries} retries.")
 
     def run_all_tasks(self):
         """Synchronous version of run_all_tasks method"""

agents/praisonaiagents/agents/autoagents.py

@@ -0,0 +1,335 @@
+"""
+AutoAgents - A class for automatically creating and managing AI agents and tasks.
+
+This class provides a simplified interface for creating and running AI agents with tasks.
+It automatically handles agent creation, task setup, and execution flow.
+"""
+
+from .agents import PraisonAIAgents
+from ..agent.agent import Agent
+from ..task.task import Task
+from typing import List, Any, Optional, Dict, Union
+import logging
+import os
+from pydantic import BaseModel, Field
+from ..main import display_instruction, display_tool_call, display_interaction, client
+
+# Define Pydantic models for structured output
+class TaskConfig(BaseModel):
+    name: str
+    description: str
+    expected_output: str
+    tools: List[str]
+
+class AgentConfig(BaseModel):
+    name: str
+    role: str
+    goal: str
+    backstory: str
+    tools: List[str]
+    tasks: List[TaskConfig]
+
+class AutoAgentsConfig(BaseModel):
+    main_instruction: str
+    process_type: str
+    agents: List[AgentConfig]
+
+class AutoAgents(PraisonAIAgents):
+    def __init__(
+        self,
+        instructions: str,
+        tools: Optional[List[Any]] = None,
+        verbose: bool = False,
+        process: str = "sequential",
+        manager_llm: Optional[str] = None,
+        max_retries: int = 5,
+        completion_checker: Optional[Any] = None,
+        allow_code_execution: bool = False,
+        memory: bool = True,
+        markdown: bool = True,
+        self_reflect: bool = False,
+        max_reflect: int = 3,
+        min_reflect: int = 1,
+        llm: Optional[str] = None,
+        function_calling_llm: Optional[str] = None,
+        respect_context_window: bool = True,
+        code_execution_mode: str = "safe",
+        embedder_config: Optional[Dict[str, Any]] = None,
+        knowledge_sources: Optional[List[Any]] = None,
+        use_system_prompt: bool = True,
+        cache: bool = True,
+        allow_delegation: bool = False,
+        step_callback: Optional[Any] = None,
+        system_template: Optional[str] = None,
+        prompt_template: Optional[str] = None,
+        response_template: Optional[str] = None,
+        max_rpm: Optional[int] = None,
+        max_execution_time: Optional[int] = None,
+        max_iter: int = 20,
+        reflect_llm: Optional[str] = None,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        max_agents: int = 3  # New parameter for maximum number of agents
+    ):
+        """Initialize AutoAgents with configuration for automatic agent and task creation."""
+        if max_agents < 1:
+            raise ValueError("max_agents must be at least 1")
+        if max_agents > 10:
+            raise ValueError("max_agents cannot exceed 10")
+            
+        # Store all configuration parameters first
+        self.instructions = instructions
+        self.tools = tools or []
+        self.verbose = verbose  # Store verbose parameter
+        self.max_agents = max_agents  # Store max_agents parameter
+        self.allow_code_execution = allow_code_execution
+        self.memory = memory
+        self.markdown = markdown
+        self.self_reflect = self_reflect
+        self.max_reflect = max_reflect
+        self.min_reflect = min_reflect
+        self.llm = llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
+        self.function_calling_llm = function_calling_llm
+        self.respect_context_window = respect_context_window
+        self.code_execution_mode = code_execution_mode
+        self.embedder_config = embedder_config
+        self.knowledge_sources = knowledge_sources
+        self.use_system_prompt = use_system_prompt
+        self.cache = cache
+        self.allow_delegation = allow_delegation
+        self.step_callback = step_callback
+        self.system_template = system_template
+        self.prompt_template = prompt_template
+        self.response_template = response_template
+        self.max_rpm = max_rpm
+        self.max_execution_time = max_execution_time
+        self.max_iter = max_iter
+        self.reflect_llm = reflect_llm
+        
+        # Display initial instruction
+        if self.verbose:
+            display_instruction(f"🎯 Main Task: {self.instructions}")
+            display_instruction(f"📊 Maximum Agents: {self.max_agents}")
+            if self.tools:
+                tool_names = [t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools]
+                display_tool_call(f"🛠️  Available Tools: {', '.join(tool_names)}")
+        
+        # Generate agents and tasks configuration
+        config = self._generate_config()
+        agents, tasks = self._create_agents_and_tasks(config)
+        
+        # Display agents and their tasks
+        if self.verbose:
+            self._display_agents_and_tasks(agents, tasks)
+        
+        # Initialize parent class with generated agents and tasks
+        super().__init__(
+            agents=agents,
+            tasks=tasks,
+            verbose=verbose,
+            completion_checker=completion_checker,
+            max_retries=max_retries,
+            process=process,
+            manager_llm=manager_llm
+        )
+
+    def _display_agents_and_tasks(self, agents: List[Agent], tasks: List[Task]):
+        """Display the created agents and their assigned tasks"""
+        display_instruction("\n🤖 Generated Agents and Tasks:")
+        
+        # Create a mapping of agents to their tasks
+        agent_tasks = {}
+        for task in tasks:
+            if task.agent not in agent_tasks:
+                agent_tasks[task.agent] = []
+            agent_tasks[task.agent].append(task)
+        
+        # Display each agent and their tasks
+        for agent in agents:
+            agent_tools = [t.__name__ if hasattr(t, '__name__') else str(t) for t in agent.tools]
+            display_interaction(
+                f"\n👤 Agent: {agent.name}",
+                f"""Role: {agent.role}
+Goal: {agent.goal}
+Tools: {', '.join(agent_tools)}"""
+            )
+            
+            # Display tasks for this agent
+            if agent in agent_tasks:
+                for i, task in enumerate(agent_tasks[agent], 1):
+                    task_tools = [t.__name__ if hasattr(t, '__name__') else str(t) for t in task.tools]
+                    display_instruction(
+                        f"""  📋 Task {i}: {task.name}
+     Description: {task.description}
+     Expected Output: {task.expected_output}
+     Tools: {', '.join(task_tools)}"""
+                    )
+
+    def _get_available_tools(self) -> List[str]:
+        """Get list of available tools"""
+        if not self.tools:
+            return []
+        return [t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools]
+
+    def _get_tool_by_name(self, tool_name: str) -> Optional[Any]:
+        """Get tool object by its name"""
+        for tool in self.tools:
+            if (hasattr(tool, '__name__') and tool.__name__ == tool_name) or str(tool) == tool_name:
+                return tool
+        return None
+
+    def _assign_tools_to_agent(self, agent_config: AgentConfig) -> List[Any]:
+        """
+        Assign appropriate tools to an agent based on its role and tasks.
+        
+        Args:
+            agent_config: The agent configuration containing role and required tools
+            
+        Returns:
+            List of tool objects assigned to this agent
+        """
+        assigned_tools = []
+        tool_names = set(agent_config.tools)
+        
+        # Also look at task requirements
+        for task in agent_config.tasks:
+            tool_names.update(task.tools)
+        
+        # Assign tools that match the requirements
+        for tool_name in tool_names:
+            tool = self._get_tool_by_name(tool_name)
+            if tool:
+                assigned_tools.append(tool)
+        
+        # If no specific tools matched but we have tools available,
+        # assign all tools to ensure functionality
+        if not assigned_tools and self.tools:
+            assigned_tools = self.tools
+            
+        return assigned_tools
+
+    def _generate_config(self) -> AutoAgentsConfig:
+        """Generate the configuration for agents and tasks"""
+        prompt = f"""
+Generate a configuration for AI agents to accomplish this task: "{self.instructions}"
+
+The configuration should include:
+1. A main instruction that clearly states the overall goal
+2. A process type (sequential, workflow, or hierarchical)
+3. A list of maximum {self.max_agents} agents (no more, no less), each with:
+   - Name, role, goal, and backstory
+   - List of required tools from: {self._get_available_tools()}
+   - Only add tools that are needed for the agent to perform its task
+   - Only one task per agent. Add more than one task if absolutely necessary.
+   - List of specific tasks they need to perform
+   - Whether they should self-reflect or allow delegation
+
+Requirements:
+1. Each agent should have clear, focused responsibilities
+2. Tasks should be broken down into manageable steps
+3. Tool selection should be appropriate for each task
+4. The process type should match the task requirements
+5. Generate maximum {self.max_agents} agents to handle this task efficiently
+
+Return the configuration in a structured JSON format matching the AutoAgentsConfig schema.
+"""
+        
+        try:
+            response = client.beta.chat.completions.parse(
+                model=self.llm,
+                response_format=AutoAgentsConfig,
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant designed to generate AI agent configurations."},
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            
+            # Ensure we have exactly max_agents number of agents
+            if len(response.choices[0].message.parsed.agents) > self.max_agents:
+                response.choices[0].message.parsed.agents = response.choices[0].message.parsed.agents[:self.max_agents]
+            elif len(response.choices[0].message.parsed.agents) < self.max_agents:
+                logging.warning(f"Generated {len(response.choices[0].message.parsed.agents)} agents, expected {self.max_agents}")
+            
+            return response.choices[0].message.parsed
+        except Exception as e:
+            logging.error(f"Error generating configuration: {e}")
+            raise
+
+    def _create_agents_and_tasks(self, config: AutoAgentsConfig) -> tuple[List[Agent], List[Task]]:
+        """Create agents and tasks from configuration"""
+        agents = []
+        tasks = []
+        
+        for agent_config in config.agents:
+            # Get appropriate tools for this agent
+            agent_tools = self._assign_tools_to_agent(agent_config)
+            
+            # Create the agent with all parameters
+            agent = Agent(
+                name=agent_config.name,
+                role=agent_config.role,
+                goal=agent_config.goal,
+                backstory=agent_config.backstory,
+                tools=agent_tools,  # Use assigned tools
+                verbose=self.verbose >= 1,
+                allow_code_execution=self.allow_code_execution,
+                memory=self.memory,
+                markdown=self.markdown,
+                self_reflect=self.self_reflect,
+                max_reflect=self.max_reflect,
+                min_reflect=self.min_reflect,
+                llm=self.llm,
+                function_calling_llm=self.function_calling_llm,
+                respect_context_window=self.respect_context_window,
+                code_execution_mode=self.code_execution_mode,
+                embedder_config=self.embedder_config,
+                knowledge_sources=self.knowledge_sources,
+                use_system_prompt=self.use_system_prompt,
+                cache=self.cache,
+                allow_delegation=self.allow_delegation,
+                step_callback=self.step_callback,
+                system_template=self.system_template,
+                prompt_template=self.prompt_template,
+                response_template=self.response_template,
+                max_rpm=self.max_rpm,
+                max_execution_time=self.max_execution_time,
+                max_iter=self.max_iter,
+                reflect_llm=self.reflect_llm
+            )
+            agents.append(agent)
+            
+            # Create tasks for this agent
+            for task_config in agent_config.tasks:
+                # Get task-specific tools
+                task_tools = [self._get_tool_by_name(t) for t in task_config.tools]
+                task_tools = [t for t in task_tools if t]  # Remove None values
+                
+                # If no specific tools matched, use agent's tools
+                if not task_tools:
+                    task_tools = agent_tools
+                
+                task = Task(
+                    name=task_config.name,
+                    description=task_config.description,
+                    expected_output=task_config.expected_output,
+                    agent=agent,
+                    tools=task_tools  # Use task-specific tools
+                )
+                tasks.append(task)
+        
+        return agents, tasks
+
+    async def astart(self):
+        """
+        Async version of start() method.
+        Creates tasks based on the instructions, then starts execution.
+        Returns the task status and results dictionary.
+        """
+        return await super().astart()
+
+    def start(self):
+        """
+        Creates tasks based on the instructions, then starts execution.
+        Returns the task status and results dictionary.
+        """
+        return super().start() 

agents/praisonaiagents/main.py

@@ -116,10 +116,10 @@ def display_interaction(message, response, markdown=True, generation_time=None,
         console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
 
     if markdown:
-        console.print(Panel.fit(Markdown(message), title="Message", border_style="cyan"))
+        console.print(Panel.fit(Markdown(message), title="Task", border_style="cyan"))
         console.print(Panel.fit(Markdown(response), title="Response", border_style="cyan"))
     else:
-        console.print(Panel.fit(Text(message, style="bold green"), title="Message", border_style="cyan"))
+        console.print(Panel.fit(Text(message, style="bold green"), title="Task", border_style="cyan"))
         console.print(Panel.fit(Text(response, style="bold blue"), title="Response", border_style="cyan"))
 
 def display_self_reflection(message: str, console=None):
@@ -135,7 +135,7 @@ def display_self_reflection(message: str, console=None):
     
     console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
 
-def display_instruction(message: str, console=None):
+def display_instruction(message: str, console=None, agent_name: str = None, agent_role: str = None, agent_tools: List[str] = None):
     if not message or not message.strip():
         return
     if console is None:
@@ -146,7 +146,19 @@ def display_instruction(message: str, console=None):
     if 'instruction' in sync_display_callbacks:
         sync_display_callbacks['instruction'](message=message)
     
-    console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
+    # Display agent info if available
+    if agent_name:
+        agent_info = f"[bold #FF9B9B]👤 Agent:[/] [#FFE5E5]{agent_name}[/]"
+        if agent_role:
+            agent_info += f"\n[bold #B4B4B3]Role:[/] [#FFE5E5]{agent_role}[/]"
+        if agent_tools:
+            tools_str = ", ".join(f"[italic #B4D4FF]{tool}[/]" for tool in agent_tools)
+            agent_info += f"\n[bold #86A789]Tools:[/] {tools_str}"
+        console.print(Panel(agent_info, border_style="#D2E3C8", title="[bold]Agent Info[/]", title_align="left", padding=(1, 2)))
+    
+    # Only print if log level is DEBUG
+    if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+        console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
 
 def display_tool_call(message: str, console=None):
     if not message or not message.strip():
@@ -222,10 +234,10 @@ async def adisplay_interaction(message, response, markdown=True, generation_time
         console.print(Text(f"Response generated in {generation_time:.1f}s", style="dim"))
 
     if markdown:
-        console.print(Panel.fit(Markdown(message), title="Message", border_style="cyan"))
+        console.print(Panel.fit(Markdown(message), title="Task", border_style="cyan"))
         console.print(Panel.fit(Markdown(response), title="Response", border_style="cyan"))
     else:
-        console.print(Panel.fit(Text(message, style="bold green"), title="Message", border_style="cyan"))
+        console.print(Panel.fit(Text(message, style="bold green"), title="Task", border_style="cyan"))
         console.print(Panel.fit(Text(response, style="bold blue"), title="Response", border_style="cyan"))
 
 async def adisplay_self_reflection(message: str, console=None):
@@ -241,7 +253,7 @@ async def adisplay_self_reflection(message: str, console=None):
     
     console.print(Panel.fit(Text(message, style="bold yellow"), title="Self Reflection", border_style="magenta"))
 
-async def adisplay_instruction(message: str, console=None):
+async def adisplay_instruction(message: str, console=None, agent_name: str = None, agent_role: str = None, agent_tools: List[str] = None):
     """Async version of display_instruction."""
     if not message or not message.strip():
         return
@@ -252,7 +264,19 @@ async def adisplay_instruction(message: str, console=None):
     if 'instruction' in async_display_callbacks:
         await async_display_callbacks['instruction'](message=message)
     
-    console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
+    # Display agent info if available
+    if agent_name:
+        agent_info = f"[bold #FF9B9B]👤 Agent:[/] [#FFE5E5]{agent_name}[/]"
+        if agent_role:
+            agent_info += f"\n[bold #B4B4B3]Role:[/] [#FFE5E5]{agent_role}[/]"
+        if agent_tools:
+            tools_str = ", ".join(f"[italic #B4D4FF]{tool}[/]" for tool in agent_tools)
+            agent_info += f"\n[bold #86A789]Tools:[/] {tools_str}"
+        console.print(Panel(agent_info, border_style="#D2E3C8", title="[bold]Agent Info[/]", title_align="left", padding=(1, 2)))
+    
+    # Only print if log level is DEBUG
+    if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
+        console.print(Panel.fit(Text(message, style="bold blue"), title="Instruction", border_style="cyan"))
 
 async def adisplay_tool_call(message: str, console=None):
     """Async version of display_tool_call."""

agents/praisonaiagents/memory/memory.py

@@ -0,0 +1,931 @@
+import os
+import sqlite3
+import json
+import time
+import shutil
+from typing import Any, Dict, List, Optional, Union, Literal
+import logging
+
+# Set up logger
+logger = logging.getLogger(__name__)
+
+try:
+    import chromadb
+    from chromadb.config import Settings as ChromaSettings
+    CHROMADB_AVAILABLE = True
+except ImportError:
+    CHROMADB_AVAILABLE = False
+    logger.warning("To use memory features, please run: pip install \"praisonaiagents[memory]\"")
+
+try:
+    import mem0
+    MEM0_AVAILABLE = True
+except ImportError:
+    MEM0_AVAILABLE = False
+
+try:
+    import openai
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+
+
+
+
+class Memory:
+    """
+    A single-file memory manager covering:
+    - Short-term memory (STM) for ephemeral context
+    - Long-term memory (LTM) for persistent knowledge
+    - Entity memory (structured data about named entities)
+    - User memory (preferences/history for each user)
+    - Quality score logic for deciding which data to store in LTM
+    - Context building from multiple memory sources
+
+    Config example:
+    {
+      "provider": "rag" or "mem0" or "none",
+      "use_embedding": True,
+      "short_db": "short_term.db",
+      "long_db": "long_term.db",
+      "rag_db_path": "rag_db",   # optional path for local embedding store
+      "config": {
+        "api_key": "...",       # if mem0 usage
+        "org_id": "...",
+        "project_id": "...",
+        ...
+      }
+    }
+    """
+
+    def __init__(self, config: Dict[str, Any], verbose: int = 0):
+        self.cfg = config or {}
+        self.verbose = verbose
+        
+        # Set logger level based on verbose
+        if verbose >= 5:
+            logger.setLevel(logging.INFO)
+        else:
+            logger.setLevel(logging.WARNING)
+            
+        # Also set ChromaDB and OpenAI client loggers to WARNING
+        logging.getLogger('chromadb').setLevel(logging.WARNING)
+        logging.getLogger('openai').setLevel(logging.WARNING)
+        logging.getLogger('httpx').setLevel(logging.WARNING)
+        logging.getLogger('httpcore').setLevel(logging.WARNING)
+        logging.getLogger('chromadb.segment.impl.vector.local_persistent_hnsw').setLevel(logging.ERROR)
+            
+        self.provider = self.cfg.get("provider", "rag")
+        self.use_mem0 = (self.provider.lower() == "mem0") and MEM0_AVAILABLE
+        self.use_rag = (self.provider.lower() == "rag") and CHROMADB_AVAILABLE and self.cfg.get("use_embedding", False)
+
+        # Create .praison directory if it doesn't exist
+        os.makedirs(".praison", exist_ok=True)
+
+        # Short-term DB
+        self.short_db = self.cfg.get("short_db", ".praison/short_term.db")
+        self._init_stm()
+
+        # Long-term DB
+        self.long_db = self.cfg.get("long_db", ".praison/long_term.db")
+        self._init_ltm()
+
+        # Conditionally init Mem0 or local RAG
+        if self.use_mem0:
+            self._init_mem0()
+        elif self.use_rag:
+            self._init_chroma()
+
+    def _log_verbose(self, msg: str, level: int = logging.INFO):
+        """Only log if verbose >= 5"""
+        if self.verbose >= 5:
+            logger.log(level, msg)
+
+    # -------------------------------------------------------------------------
+    #                          Initialization
+    # -------------------------------------------------------------------------
+    def _init_stm(self):
+        """Creates or verifies short-term memory table."""
+        os.makedirs(os.path.dirname(self.short_db) or ".", exist_ok=True)
+        conn = sqlite3.connect(self.short_db)
+        c = conn.cursor()
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS short_mem (
+            id TEXT PRIMARY KEY,
+            content TEXT,
+            meta TEXT,
+            created_at REAL
+        )
+        """)
+        conn.commit()
+        conn.close()
+
+    def _init_ltm(self):
+        """Creates or verifies long-term memory table."""
+        os.makedirs(os.path.dirname(self.long_db) or ".", exist_ok=True)
+        conn = sqlite3.connect(self.long_db)
+        c = conn.cursor()
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS long_mem (
+            id TEXT PRIMARY KEY,
+            content TEXT,
+            meta TEXT,
+            created_at REAL
+        )
+        """)
+        conn.commit()
+        conn.close()
+
+    def _init_mem0(self):
+        """Initialize Mem0 client for agent or user memory."""
+        from mem0 import MemoryClient
+        mem_cfg = self.cfg.get("config", {})
+        api_key = mem_cfg.get("api_key", os.getenv("MEM0_API_KEY"))
+        org_id = mem_cfg.get("org_id")
+        proj_id = mem_cfg.get("project_id")
+        if org_id and proj_id:
+            self.mem0_client = MemoryClient(api_key=api_key, org_id=org_id, project_id=proj_id)
+        else:
+            self.mem0_client = MemoryClient(api_key=api_key)
+
+    def _init_chroma(self):
+        """Initialize a local Chroma client for embedding-based search."""
+        try:
+            # Create directory if it doesn't exist
+            rag_path = self.cfg.get("rag_db_path", "chroma_db")
+            os.makedirs(rag_path, exist_ok=True)
+
+            # Initialize ChromaDB with persistent storage
+            self.chroma_client = chromadb.PersistentClient(
+                path=rag_path,
+                settings=ChromaSettings(
+                    anonymized_telemetry=False,
+                    allow_reset=True
+                )
+            )
+
+            collection_name = "memory_store"
+            try:
+                self.chroma_col = self.chroma_client.get_collection(name=collection_name)
+                self._log_verbose("Using existing ChromaDB collection")
+            except Exception as e:
+                self._log_verbose(f"Collection '{collection_name}' not found. Creating new collection. Error: {e}")
+                self.chroma_col = self.chroma_client.create_collection(
+                    name=collection_name,
+                    metadata={"hnsw:space": "cosine"}
+                )
+                self._log_verbose("Created new ChromaDB collection")
+
+        except Exception as e:
+            self._log_verbose(f"Failed to initialize ChromaDB: {e}", logging.ERROR)
+            self.use_rag = False
+
+    # -------------------------------------------------------------------------
+    #                      Basic Quality Score Computation
+    # -------------------------------------------------------------------------
+    def compute_quality_score(
+        self,
+        completeness: float,
+        relevance: float,
+        clarity: float,
+        accuracy: float,
+        weights: Dict[str, float] = None
+    ) -> float:
+        """
+        Combine multiple sub-metrics into one final score, as an example.
+
+        Args:
+            completeness (float): 0-1
+            relevance (float): 0-1
+            clarity (float): 0-1
+            accuracy (float): 0-1
+            weights (Dict[str, float]): optional weighting like {"completeness": 0.25, "relevance": 0.3, ...}
+
+        Returns:
+            float: Weighted average 0-1
+        """
+        if not weights:
+            weights = {
+                "completeness": 0.25,
+                "relevance": 0.25,
+                "clarity": 0.25,
+                "accuracy": 0.25
+            }
+        total = (completeness * weights["completeness"]
+                 + relevance   * weights["relevance"]
+                 + clarity     * weights["clarity"]
+                 + accuracy    * weights["accuracy"]
+                )
+        return round(total, 3)  # e.g. round to 3 decimal places
+
+    # -------------------------------------------------------------------------
+    #                           Short-Term Methods
+    # -------------------------------------------------------------------------
+    def store_short_term(
+        self,
+        text: str,
+        metadata: Dict[str, Any] = None,
+        completeness: float = None,
+        relevance: float = None,
+        clarity: float = None,
+        accuracy: float = None,
+        weights: Dict[str, float] = None,
+        evaluator_quality: float = None
+    ):
+        """Store in short-term memory with optional quality metrics"""
+        logger.info(f"Storing in short-term memory: {text[:100]}...")
+        logger.info(f"Metadata: {metadata}")
+        
+        metadata = self._process_quality_metrics(
+            metadata, completeness, relevance, clarity, 
+            accuracy, weights, evaluator_quality
+        )
+        logger.info(f"Processed metadata: {metadata}")
+        
+        # Existing store logic
+        try:
+            conn = sqlite3.connect(self.short_db)
+            ident = str(time.time_ns())
+            conn.execute(
+                "INSERT INTO short_mem (id, content, meta, created_at) VALUES (?,?,?,?)",
+                (ident, text, json.dumps(metadata), time.time())
+            )
+            conn.commit()
+            conn.close()
+            logger.info(f"Successfully stored in short-term memory with ID: {ident}")
+        except Exception as e:
+            logger.error(f"Failed to store in short-term memory: {e}")
+            raise
+
+    def search_short_term(
+        self, 
+        query: str, 
+        limit: int = 5,
+        min_quality: float = 0.0,
+        relevance_cutoff: float = 0.0
+    ) -> List[Dict[str, Any]]:
+        """Search short-term memory with optional quality filter"""
+        self._log_verbose(f"Searching short memory for: {query}")
+        
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            results = self.mem0_client.search(query=query, limit=limit)
+            filtered = [r for r in results if r.get("score", 1.0) >= relevance_cutoff]
+            return filtered
+            
+        elif self.use_rag and hasattr(self, "chroma_col"):
+            try:
+                from openai import OpenAI
+                client = OpenAI()
+                
+                response = client.embeddings.create(
+                    input=query,
+                    model="text-embedding-3-small"
+                )
+                query_embedding = response.data[0].embedding
+                
+                resp = self.chroma_col.query(
+                    query_embeddings=[query_embedding],
+                    n_results=limit
+                )
+                
+                results = []
+                if resp["ids"]:
+                    for i in range(len(resp["ids"][0])):
+                        metadata = resp["metadatas"][0][i] if "metadatas" in resp else {}
+                        quality = metadata.get("quality", 0.0)
+                        score = 1.0 - (resp["distances"][0][i] if "distances" in resp else 0.0)
+                        if quality >= min_quality and score >= relevance_cutoff:
+                            results.append({
+                                "id": resp["ids"][0][i],
+                                "text": resp["documents"][0][i],
+                                "metadata": metadata,
+                                "score": score
+                            })
+                return results
+            except Exception as e:
+                self._log_verbose(f"Error searching ChromaDB: {e}", logging.ERROR)
+                return []
+        
+        else:
+            # Local fallback
+            conn = sqlite3.connect(self.short_db)
+            c = conn.cursor()
+            rows = c.execute(
+                "SELECT id, content, meta FROM short_mem WHERE content LIKE ? LIMIT ?",
+                (f"%{query}%", limit)
+            ).fetchall()
+            conn.close()
+
+            results = []
+            for row in rows:
+                meta = json.loads(row[2] or "{}")
+                quality = meta.get("quality", 0.0)
+                if quality >= min_quality:
+                    results.append({
+                        "id": row[0],
+                        "text": row[1],
+                        "metadata": meta
+                    })
+            return results
+
+    def reset_short_term(self):
+        """Completely clears short-term memory."""
+        conn = sqlite3.connect(self.short_db)
+        conn.execute("DELETE FROM short_mem")
+        conn.commit()
+        conn.close()
+
+    # -------------------------------------------------------------------------
+    #                           Long-Term Methods
+    # -------------------------------------------------------------------------
+    def _sanitize_metadata(self, metadata: Dict) -> Dict:
+        """Sanitize metadata for ChromaDB - convert to acceptable types"""
+        sanitized = {}
+        for k, v in metadata.items():
+            if v is None:
+                continue
+            if isinstance(v, (str, int, float, bool)):
+                sanitized[k] = v
+            elif isinstance(v, dict):
+                # Convert dict to string representation
+                sanitized[k] = str(v)
+            else:
+                # Convert other types to string
+                sanitized[k] = str(v)
+        return sanitized
+
+    def store_long_term(
+        self,
+        text: str,
+        metadata: Dict[str, Any] = None,
+        completeness: float = None,
+        relevance: float = None,
+        clarity: float = None,
+        accuracy: float = None,
+        weights: Dict[str, float] = None,
+        evaluator_quality: float = None
+    ):
+        """Store in long-term memory with optional quality metrics"""
+        logger.info(f"Storing in long-term memory: {text[:100]}...")
+        logger.info(f"Initial metadata: {metadata}")
+        
+        # Process metadata
+        metadata = metadata or {}
+        metadata = self._process_quality_metrics(
+            metadata, completeness, relevance, clarity,
+            accuracy, weights, evaluator_quality
+        )
+        logger.info(f"Processed metadata: {metadata}")
+        
+        # Generate unique ID
+        ident = str(time.time_ns())
+        created = time.time()
+
+        # Store in SQLite
+        try:
+            conn = sqlite3.connect(self.long_db)
+            conn.execute(
+                "INSERT INTO long_mem (id, content, meta, created_at) VALUES (?,?,?,?)",
+                (ident, text, json.dumps(metadata), created)
+            )
+            conn.commit()
+            conn.close()
+            logger.info(f"Successfully stored in SQLite with ID: {ident}")
+        except Exception as e:
+            logger.error(f"Error storing in SQLite: {e}")
+            return
+
+        # Store in vector database if enabled
+        if self.use_rag and hasattr(self, "chroma_col"):
+            try:
+                from openai import OpenAI
+                client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))  # Ensure API key is correctly set
+                
+                logger.info("Getting embeddings from OpenAI...")
+                logger.debug(f"Embedding input text: {text}")  # Log the input text
+                
+                response = client.embeddings.create(
+                    input=text,
+                    model="text-embedding-3-small"
+                )
+                embedding = response.data[0].embedding
+                logger.info("Successfully got embeddings")
+                logger.debug(f"Received embedding of length: {len(embedding)}")  # Log embedding details
+                
+                # Sanitize metadata for ChromaDB
+                sanitized_metadata = self._sanitize_metadata(metadata)
+                
+                # Store in ChromaDB with embedding
+                self.chroma_col.add(
+                    documents=[text],
+                    metadatas=[sanitized_metadata],
+                    ids=[ident],
+                    embeddings=[embedding]
+                )
+                logger.info(f"Successfully stored in ChromaDB with ID: {ident}")
+            except Exception as e:
+                logger.error(f"Error storing in ChromaDB: {e}")
+        
+        elif self.use_mem0 and hasattr(self, "mem0_client"):
+            try:
+                self.mem0_client.add(text, metadata=metadata)
+                logger.info("Successfully stored in Mem0")
+            except Exception as e:
+                logger.error(f"Error storing in Mem0: {e}")
+
+
+    def search_long_term(
+        self, 
+        query: str, 
+        limit: int = 5, 
+        relevance_cutoff: float = 0.0,
+        min_quality: float = 0.0
+    ) -> List[Dict[str, Any]]:
+        """Search long-term memory with optional quality filter"""
+        self._log_verbose(f"Searching long memory for: {query}")
+        self._log_verbose(f"Min quality: {min_quality}")
+
+        found = []
+
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            results = self.mem0_client.search(query=query, limit=limit)
+            # Filter by quality
+            filtered = [r for r in results if r.get("metadata", {}).get("quality", 0.0) >= min_quality]
+            logger.info(f"Found {len(filtered)} results in Mem0")
+            return filtered
+
+        elif self.use_rag and hasattr(self, "chroma_col"):
+            try:
+                from openai import OpenAI
+                client = OpenAI()
+                
+                # Get query embedding
+                response = client.embeddings.create(
+                    input=query,
+                    model="text-embedding-3-small"  # Using consistent model
+                )
+                query_embedding = response.data[0].embedding
+                
+                # Search ChromaDB with embedding
+                resp = self.chroma_col.query(
+                    query_embeddings=[query_embedding],
+                    n_results=limit,
+                    include=["documents", "metadatas", "distances"]
+                )
+                
+                results = []
+                if resp["ids"]:
+                    for i in range(len(resp["ids"][0])):
+                        metadata = resp["metadatas"][0][i] if "metadatas" in resp else {}
+                        text = resp["documents"][0][i]
+                        # Add memory record citation
+                        text = f"{text} (Memory record: {text})"
+                        found.append({
+                            "id": resp["ids"][0][i],
+                            "text": text,
+                            "metadata": metadata,
+                            "score": 1.0 - (resp["distances"][0][i] if "distances" in resp else 0.0)
+                        })
+                logger.info(f"Found {len(found)} results in ChromaDB")
+
+            except Exception as e:
+                self._log_verbose(f"Error searching ChromaDB: {e}", logging.ERROR)
+
+        # Always try SQLite as fallback or additional source
+        conn = sqlite3.connect(self.long_db)
+        c = conn.cursor()
+        rows = c.execute(
+            "SELECT id, content, meta, created_at FROM long_mem WHERE content LIKE ? LIMIT ?",
+            (f"%{query}%", limit)
+        ).fetchall()
+        conn.close()
+
+        for row in rows:
+            meta = json.loads(row[2] or "{}")
+            text = row[1]
+            # Add memory record citation if not already present
+            if "(Memory record:" not in text:
+                text = f"{text} (Memory record: {text})"
+            # Only add if not already found by ChromaDB/Mem0
+            if not any(f["id"] == row[0] for f in found):
+                found.append({
+                    "id": row[0],
+                    "text": text,
+                    "metadata": meta,
+                    "created_at": row[3]
+                })
+        logger.info(f"Found {len(found)} total results after SQLite")
+
+        results = found
+
+        # Filter by quality if needed
+        if min_quality > 0:
+            self._log_verbose(f"Found {len(results)} initial results")
+            results = [
+                r for r in results 
+                if r.get("metadata", {}).get("quality", 0.0) >= min_quality
+            ]
+            self._log_verbose(f"After quality filter: {len(results)} results")
+
+        # Apply relevance cutoff if specified
+        if relevance_cutoff > 0:
+            results = [r for r in results if r.get("score", 1.0) >= relevance_cutoff]
+            logger.info(f"After relevance filter: {len(results)} results")
+        
+        return results[:limit]
+
+    def reset_long_term(self):
+        """Clear local LTM DB, plus Chroma or mem0 if in use."""
+        conn = sqlite3.connect(self.long_db)
+        conn.execute("DELETE FROM long_mem")
+        conn.commit()
+        conn.close()
+
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            # Mem0 has no universal reset API. Could implement partial or no-op.
+            pass
+        if self.use_rag and hasattr(self, "chroma_client"):
+            self.chroma_client.reset()  # entire DB
+            self._init_chroma()         # re-init fresh
+
+    # -------------------------------------------------------------------------
+    #                       Entity Memory Methods
+    # -------------------------------------------------------------------------
+    def store_entity(self, name: str, type_: str, desc: str, relations: str):
+        """
+        Save entity info in LTM (or mem0/rag). 
+        We'll label the metadata type = entity for easy filtering.
+        """
+        data = f"Entity {name}({type_}): {desc} | relationships: {relations}"
+        self.store_long_term(data, metadata={"category": "entity"})
+
+    def search_entity(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        Filter to items that have metadata 'category=entity'.
+        """
+        all_hits = self.search_long_term(query, limit=20)  # gather more
+        ents = []
+        for h in all_hits:
+            meta = h.get("metadata") or {}
+            if meta.get("category") == "entity":
+                ents.append(h)
+        return ents[:limit]
+
+    def reset_entity_only(self):
+        """
+        If you only want to drop entity items from LTM, you'd do a custom 
+        delete from local DB where meta LIKE '%category=entity%'. 
+        For brevity, we do a full LTM reset here.
+        """
+        self.reset_long_term()
+
+    # -------------------------------------------------------------------------
+    #                       User Memory Methods
+    # -------------------------------------------------------------------------
+    def store_user_memory(self, user_id: str, text: str, extra: Dict[str, Any] = None):
+        """
+        If mem0 is used, do user-based addition. Otherwise store in LTM with user in metadata.
+        """
+        meta = {"user_id": user_id}
+        if extra:
+            meta.update(extra)
+
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            self.mem0_client.add(text, user_id=user_id, metadata=meta)
+        else:
+            self.store_long_term(text, metadata=meta)
+
+    def search_user_memory(self, user_id: str, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        If mem0 is used, pass user_id in. Otherwise fallback to local filter on user in metadata.
+        """
+        if self.use_mem0 and hasattr(self, "mem0_client"):
+            return self.mem0_client.search(query=query, limit=limit, user_id=user_id)
+        else:
+            hits = self.search_long_term(query, limit=20)
+            filtered = []
+            for h in hits:
+                meta = h.get("metadata", {})
+                if meta.get("user_id") == user_id:
+                    filtered.append(h)
+            return filtered[:limit]
+
+    def reset_user_memory(self):
+        """
+        Clear all user-based info. For simplicity, we do a full LTM reset. 
+        Real usage might filter only metadata "user_id".
+        """
+        self.reset_long_term()
+
+    # -------------------------------------------------------------------------
+    #                 Putting it all Together: Task Finalization
+    # -------------------------------------------------------------------------
+    def finalize_task_output(
+        self,
+        content: str,
+        agent_name: str,
+        quality_score: float,
+        threshold: float = 0.7,
+        metrics: Dict[str, Any] = None,
+        task_id: str = None
+    ):
+        """Store task output in memory with appropriate metadata"""
+        logger.info(f"Finalizing task output: {content[:100]}...")
+        logger.info(f"Agent: {agent_name}, Quality: {quality_score}, Threshold: {threshold}")
+        
+        metadata = {
+            "task_id": task_id,
+            "agent": agent_name,
+            "quality": quality_score,
+            "metrics": metrics,
+            "task_type": "output",
+            "stored_at": time.time()
+        }
+        logger.info(f"Prepared metadata: {metadata}")
+        
+        # Always store in short-term memory
+        try:
+            logger.info("Storing in short-term memory...")
+            self.store_short_term(
+                text=content,
+                metadata=metadata
+            )
+            logger.info("Successfully stored in short-term memory")
+        except Exception as e:
+            logger.error(f"Failed to store in short-term memory: {e}")
+        
+        # Store in long-term memory if quality meets threshold
+        if quality_score >= threshold:
+            try:
+                logger.info(f"Quality score {quality_score} >= {threshold}, storing in long-term memory...")
+                self.store_long_term(
+                    text=content,
+                    metadata=metadata
+                )
+                logger.info("Successfully stored in long-term memory")
+            except Exception as e:
+                logger.error(f"Failed to store in long-term memory: {e}")
+        else:
+            logger.info(f"Quality score {quality_score} < {threshold}, skipping long-term storage")
+
+    # -------------------------------------------------------------------------
+    #                 Building Context (Short, Long, Entities, User)
+    # -------------------------------------------------------------------------
+    def build_context_for_task(
+        self,
+        task_descr: str,
+        user_id: Optional[str] = None,
+        additional: str = "",
+        max_items: int = 3
+    ) -> str:
+        """
+        Merges relevant short-term, long-term, entity, user memories
+        into a single text block with deduplication and clean formatting.
+        """
+        q = (task_descr + " " + additional).strip()
+        lines = []
+        seen_contents = set()  # Track unique contents
+
+        def normalize_content(content: str) -> str:
+            """Normalize content for deduplication"""
+            # Extract just the main content without citations for comparison
+            normalized = content.split("(Memory record:")[0].strip()
+            # Keep more characters to reduce false duplicates
+            normalized = ''.join(c.lower() for c in normalized if not c.isspace())
+            return normalized
+
+        def format_content(content: str, max_len: int = 150) -> str:
+            """Format content with clean truncation at word boundaries"""
+            if not content:
+                return ""
+            
+            # Clean up content by removing extra whitespace and newlines
+            content = ' '.join(content.split())
+            
+            # If content contains a memory citation, preserve it
+            if "(Memory record:" in content:
+                return content  # Keep original citation format
+            
+            # Regular content truncation
+            if len(content) <= max_len:
+                return content
+            
+            truncate_at = content.rfind(' ', 0, max_len - 3)
+            if truncate_at == -1:
+                truncate_at = max_len - 3
+            return content[:truncate_at] + "..."
+
+        def add_section(title: str, hits: List[Any]) -> None:
+            """Add a section of memory hits with deduplication"""
+            if not hits:
+                return
+                
+            formatted_hits = []
+            for h in hits:
+                content = h.get('text', '') if isinstance(h, dict) else str(h)
+                if not content:
+                    continue
+                    
+                # Keep original format if it has a citation
+                if "(Memory record:" in content:
+                    formatted = content
+                else:
+                    formatted = format_content(content)
+                
+                # Only add if we haven't seen this normalized content before
+                normalized = normalize_content(formatted)
+                if normalized not in seen_contents:
+                    seen_contents.add(normalized)
+                    formatted_hits.append(formatted)
+            
+            if formatted_hits:
+                # Add section header
+                if lines:
+                    lines.append("")  # Space before new section
+                lines.append(title)
+                lines.append("=" * len(title))  # Underline the title
+                lines.append("")  # Space after title
+                
+                # Add formatted content with bullet points
+                for content in formatted_hits:
+                    lines.append(f" • {content}")
+
+        # Add each section
+        # First get all results
+        short_term = self.search_short_term(q, limit=max_items)
+        long_term = self.search_long_term(q, limit=max_items)
+        entities = self.search_entity(q, limit=max_items)
+        user_mem = self.search_user_memory(user_id, q, limit=max_items) if user_id else []
+
+        # Add sections in order of priority
+        add_section("Short-term Memory Context", short_term)
+        add_section("Long-term Memory Context", long_term)
+        add_section("Entity Context", entities)
+        if user_id:
+            add_section("User Context", user_mem)
+
+        return "\n".join(lines) if lines else ""
+
+    # -------------------------------------------------------------------------
+    #                      Master Reset (Everything)
+    # -------------------------------------------------------------------------
+    def reset_all(self):
+        """
+        Fully wipes short-term, long-term, and any memory in mem0 or rag.
+        """
+        self.reset_short_term()
+        self.reset_long_term()
+        # Entities & user memory are stored in LTM or mem0, so no separate step needed.
+
+    def _process_quality_metrics(
+        self,
+        metadata: Dict[str, Any],
+        completeness: float = None,
+        relevance: float = None,
+        clarity: float = None, 
+        accuracy: float = None,
+        weights: Dict[str, float] = None,
+        evaluator_quality: float = None
+    ) -> Dict[str, Any]:
+        """Process and store quality metrics in metadata"""
+        metadata = metadata or {}
+        
+        # Handle sub-metrics if provided
+        if None not in [completeness, relevance, clarity, accuracy]:
+            metadata.update({
+                "completeness": completeness,
+                "relevance": relevance,
+                "clarity": clarity,
+                "accuracy": accuracy,
+                "quality": self.compute_quality_score(
+                    completeness, relevance, clarity, accuracy, weights
+                )
+            })
+        # Handle external evaluator quality if provided
+        elif evaluator_quality is not None:
+            metadata["quality"] = evaluator_quality
+        
+        return metadata
+
+    def calculate_quality_metrics(
+        self,
+        output: str,
+        expected_output: str,
+        llm: Optional[str] = None,
+        custom_prompt: Optional[str] = None
+    ) -> Dict[str, float]:
+        """Calculate quality metrics using LLM"""
+        logger.info("Calculating quality metrics for output")
+        logger.info(f"Output: {output[:100]}...")
+        logger.info(f"Expected: {expected_output[:100]}...")
+        
+        # Default evaluation prompt
+        default_prompt = f"""
+        Evaluate the following output against expected output.
+        Score each metric from 0.0 to 1.0:
+        - Completeness: Does it address all requirements?
+        - Relevance: Does it match expected output?
+        - Clarity: Is it clear and well-structured?
+        - Accuracy: Is it factually correct?
+
+        Expected: {expected_output}
+        Actual: {output}
+
+        Return ONLY a JSON with these keys: completeness, relevance, clarity, accuracy
+        Example: {{"completeness": 0.95, "relevance": 0.8, "clarity": 0.9, "accuracy": 0.85}}
+        """
+
+        try:
+            # Use OpenAI client from main.py
+            from ..main import client
+            
+            response = client.chat.completions.create(
+                model=llm or "gpt-4o",
+                messages=[{
+                    "role": "user", 
+                    "content": custom_prompt or default_prompt
+                }],
+                response_format={"type": "json_object"},
+                temperature=0.3
+            )
+            
+            metrics = json.loads(response.choices[0].message.content)
+            
+            # Validate metrics
+            required = ["completeness", "relevance", "clarity", "accuracy"]
+            if not all(k in metrics for k in required):
+                raise ValueError("Missing required metrics in LLM response")
+            
+            logger.info(f"Calculated metrics: {metrics}")
+            return metrics
+            
+        except Exception as e:
+            logger.error(f"Error calculating metrics: {e}")
+            return {
+                "completeness": 0.0,
+                "relevance": 0.0,
+                "clarity": 0.0,
+                "accuracy": 0.0
+            }
+
+    def store_quality(
+        self,
+        text: str,
+        quality_score: float,
+        task_id: Optional[str] = None,
+        iteration: Optional[int] = None,
+        metrics: Optional[Dict[str, float]] = None,
+        memory_type: Literal["short", "long"] = "long"
+    ) -> None:
+        """Store quality metrics in memory"""
+        logger.info(f"Attempting to store in {memory_type} memory: {text[:100]}...")
+        
+        metadata = {
+            "quality": quality_score,
+            "task_id": task_id,
+            "iteration": iteration
+        }
+        
+        if metrics:
+            metadata.update({
+                k: v for k, v in metrics.items()  # Remove metric_ prefix
+            })
+            
+        logger.info(f"With metadata: {metadata}")
+        
+        try:
+            if memory_type == "short":
+                self.store_short_term(text, metadata=metadata)
+                logger.info("Successfully stored in short-term memory")
+            else:
+                self.store_long_term(text, metadata=metadata)
+                logger.info("Successfully stored in long-term memory")
+        except Exception as e:
+            logger.error(f"Failed to store in memory: {e}")
+
+    def search_with_quality(
+        self,
+        query: str,
+        min_quality: float = 0.0,
+        memory_type: Literal["short", "long"] = "long",
+        limit: int = 5
+    ) -> List[Dict[str, Any]]:
+        """Search with quality filter"""
+        logger.info(f"Searching {memory_type} memory for: {query}")
+        logger.info(f"Min quality: {min_quality}")
+        
+        search_func = (
+            self.search_short_term if memory_type == "short" 
+            else self.search_long_term
+        )
+        
+        results = search_func(query, limit=limit)
+        logger.info(f"Found {len(results)} initial results")
+        
+        filtered = [
+            r for r in results 
+            if r.get("metadata", {}).get("quality", 0.0) >= min_quality
+        ]
+        logger.info(f"After quality filter: {len(filtered)} results")
+        
+        return filtered

agents/praisonaiagents/task/task.py

@@ -5,12 +5,17 @@ from pydantic import BaseModel
 from ..main import TaskOutput
 from ..agent.agent import Agent
 import uuid
+import os
+import time
+
+# Set up logger
+logger = logging.getLogger(__name__)
 
 class Task:
     def __init__(
         self,
         description: str,
-        expected_output: str,
+        expected_output: Optional[str] = None,
         agent: Optional[Agent] = None,
         name: Optional[str] = None,
         tools: Optional[List[Any]] = None,
@@ -30,12 +35,14 @@ class Task:
         task_type: str = "task",
         condition: Optional[Dict[str, List[str]]] = None,
         is_start: bool = False,
-        loop_state: Optional[Dict[str, Union[str, int]]] = None
+        loop_state: Optional[Dict[str, Union[str, int]]] = None,
+        memory=None,
+        quality_check=True
     ):
         self.id = str(uuid.uuid4()) if id is None else str(id)
         self.name = name
         self.description = description
-        self.expected_output = expected_output
+        self.expected_output = expected_output if expected_output is not None else "Complete the task successfully"
         self.agent = agent
         self.tools = tools if tools else []
         self.context = context if context else []
@@ -54,6 +61,21 @@ class Task:
         self.condition = condition if condition else {}
         self.is_start = is_start
         self.loop_state = loop_state if loop_state else {}
+        self.memory = memory
+        self.quality_check = quality_check
+
+        # Set logger level based on config verbose level
+        verbose = self.config.get("verbose", 0)
+        if verbose >= 5:
+            logger.setLevel(logging.INFO)
+        else:
+            logger.setLevel(logging.WARNING)
+            
+        # Also set third-party loggers to WARNING
+        logging.getLogger('chromadb').setLevel(logging.WARNING)
+        logging.getLogger('openai').setLevel(logging.WARNING)
+        logging.getLogger('httpx').setLevel(logging.WARNING)
+        logging.getLogger('httpcore').setLevel(logging.WARNING)
 
         if self.output_json and self.output_pydantic:
             raise ValueError("Only one output type can be defined")
@@ -64,11 +86,137 @@ class Task:
     def __str__(self):
         return f"Task(name='{self.name if self.name else 'None'}', description='{self.description}', agent='{self.agent.name if self.agent else 'None'}', status='{self.status}')"
 
+    def initialize_memory(self):
+        """Initialize memory if config exists but memory doesn't"""
+        if not self.memory and self.config.get('memory_config'):
+            try:
+                from ..memory.memory import Memory
+                logger.info(f"Task {self.id}: Initializing memory from config: {self.config['memory_config']}")
+                self.memory = Memory(config=self.config['memory_config'])
+                logger.info(f"Task {self.id}: Memory initialized successfully")
+                
+                # Verify database was created
+                if os.path.exists(self.config['memory_config']['storage']['path']):
+                    logger.info(f"Task {self.id}: Memory database exists after initialization")
+                else:
+                    logger.error(f"Task {self.id}: Failed to create memory database!")
+                return self.memory
+            except Exception as e:
+                logger.error(f"Task {self.id}: Failed to initialize memory: {e}")
+                logger.exception(e)
+        return None
+
+    def store_in_memory(self, content: str, agent_name: str = None, task_id: str = None):
+        """Store content in memory with metadata"""
+        if self.memory:
+            try:
+                logger.info(f"Task {self.id}: Storing content in memory...")
+                self.memory.store_long_term(
+                    text=content,
+                    metadata={
+                        "agent_name": agent_name or "Agent",
+                        "task_id": task_id or self.id,
+                        "timestamp": time.time()
+                    }
+                )
+                logger.info(f"Task {self.id}: Content stored in memory")
+            except Exception as e:
+                logger.error(f"Task {self.id}: Failed to store content in memory: {e}")
+                logger.exception(e)
+
     async def execute_callback(self, task_output: TaskOutput) -> None:
-        """Execute the callback function, handling both sync and async callbacks"""
+        """Execute callback and store quality metrics if enabled"""
+        logger.info(f"Task {self.id}: execute_callback called")
+        logger.info(f"Quality check enabled: {self.quality_check}")
+        
+        # Initialize memory if not already initialized
+        if not self.memory:
+            self.memory = self.initialize_memory()
+        
+        logger.info(f"Memory object exists: {self.memory is not None}")
+        if self.memory:
+            logger.info(f"Memory config: {self.memory.cfg}")
+            # Store task output in memory
+            try:
+                logger.info(f"Task {self.id}: Storing task output in memory...")
+                self.store_in_memory(
+                    content=task_output.raw,
+                    agent_name=self.agent.name if self.agent else "Agent",
+                    task_id=self.id
+                )
+                logger.info(f"Task {self.id}: Task output stored in memory")
+            except Exception as e:
+                logger.error(f"Task {self.id}: Failed to store task output in memory: {e}")
+                logger.exception(e)
+        
+        logger.info(f"Task output: {task_output.raw[:100]}...")
+        
+        if self.quality_check and self.memory:
+            try:
+                logger.info(f"Task {self.id}: Starting memory operations")
+                logger.info(f"Task {self.id}: Calculating quality metrics for output: {task_output.raw[:100]}...")
+                
+                # Get quality metrics from LLM
+                metrics = self.memory.calculate_quality_metrics(
+                    task_output.raw,
+                    self.expected_output
+                )
+                logger.info(f"Task {self.id}: Quality metrics calculated: {metrics}")
+                
+                quality_score = metrics.get("accuracy", 0.0)
+                logger.info(f"Task {self.id}: Quality score: {quality_score}")
+                
+                # Store in both short and long-term memory with higher threshold
+                logger.info(f"Task {self.id}: Finalizing task output in memory...")
+                self.memory.finalize_task_output(
+                    content=task_output.raw,
+                    agent_name=self.agent.name if self.agent else "Agent",
+                    quality_score=quality_score,
+                    threshold=0.7,  # Only high quality outputs in long-term memory
+                    metrics=metrics,
+                    task_id=self.id
+                )
+                logger.info(f"Task {self.id}: Finalized task output in memory")
+                
+                # Store quality metrics separately
+                logger.info(f"Task {self.id}: Storing quality metrics...")
+                self.memory.store_quality(
+                    text=task_output.raw,
+                    quality_score=quality_score,
+                    task_id=self.id,
+                    metrics=metrics
+                )
+                
+                # Store in both short and long-term memory with higher threshold
+                self.memory.finalize_task_output(
+                    content=task_output.raw,
+                    agent_name=self.agent.name if self.agent else "Agent",
+                    quality_score=quality_score,
+                    threshold=0.7  # Only high quality outputs in long-term memory
+                )
+                
+                # Build context for next tasks
+                if self.next_tasks:
+                    logger.info(f"Task {self.id}: Building context for next tasks...")
+                    context = self.memory.build_context_for_task(
+                        task_descr=task_output.raw,
+                        max_items=5
+                    )
+                    logger.info(f"Task {self.id}: Built context for next tasks: {len(context)} items")
+                
+                logger.info(f"Task {self.id}: Memory operations complete")
+            except Exception as e:
+                logger.error(f"Task {self.id}: Failed to process memory operations: {e}")
+                logger.exception(e)  # Print full stack trace
+                # Continue execution even if memory operations fail
+
+        # Execute original callback
         if self.callback:
-            if asyncio.iscoroutinefunction(self.callback):
-                await self.callback(task_output)
-            else:
-                loop = asyncio.get_event_loop()
-                await loop.run_in_executor(None, self.callback, task_output) 
+            try:
+                if asyncio.iscoroutinefunction(self.callback):
+                    await self.callback(task_output)
+                else:
+                    self.callback(task_output)
+            except Exception as e:
+                logger.error(f"Task {self.id}: Failed to execute callback: {e}")
+                logger.exception(e)

agents/praisonaiagents/tools/__init__.py

@@ -8,6 +8,59 @@ TOOL_MAPPINGS = {
     'internet_search': ('.duckduckgo_tools', None),
     'duckduckgo': ('.duckduckgo_tools', None),
     
+    # arXiv Tools
+    'search_arxiv': ('.arxiv_tools', None),
+    'get_arxiv_paper': ('.arxiv_tools', None),
+    'get_papers_by_author': ('.arxiv_tools', None),
+    'get_papers_by_category': ('.arxiv_tools', None),
+    'arxiv_tools': ('.arxiv_tools', None),
+    
+    # Wikipedia Tools
+    'wiki_search': ('.wikipedia_tools', None),
+    'wiki_summary': ('.wikipedia_tools', None),
+    'wiki_page': ('.wikipedia_tools', None),
+    'wiki_random': ('.wikipedia_tools', None),
+    'wiki_language': ('.wikipedia_tools', None),
+    'wikipedia_tools': ('.wikipedia_tools', None),
+    
+    # Newspaper Tools
+    'get_article': ('.newspaper_tools', None),
+    'get_news_sources': ('.newspaper_tools', None),
+    'get_articles_from_source': ('.newspaper_tools', None),
+    'get_trending_topics': ('.newspaper_tools', None),
+    'newspaper_tools': ('.newspaper_tools', None),
+    
+    # Spider Tools
+    'scrape_page': ('.spider_tools', None),
+    'extract_links': ('.spider_tools', None),
+    'crawl': ('.spider_tools', None),
+    'extract_text': ('.spider_tools', None),
+    'spider_tools': ('.spider_tools', None),
+    
+    # DuckDB Tools
+    'query': ('.duckdb_tools', None),
+    'create_table': ('.duckdb_tools', None),
+    'load_data': ('.duckdb_tools', None),
+    'export_data': ('.duckdb_tools', None),
+    'get_table_info': ('.duckdb_tools', None),
+    'analyze_data': ('.duckdb_tools', None),
+    'duckdb_tools': ('.duckdb_tools', None),
+    
+    # Shell Tools
+    'execute_command': ('.shell_tools', None),
+    'list_processes': ('.shell_tools', None),
+    'kill_process': ('.shell_tools', None),
+    'get_system_info': ('.shell_tools', None),
+    'shell_tools': ('.shell_tools', None),
+
+    # Calculator Tools
+    'evaluate': ('.calculator_tools', None),
+    'solve_equation': ('.calculator_tools', None),
+    'convert_units': ('.calculator_tools', None),
+    'calculate_statistics': ('.calculator_tools', None),
+    'calculate_financial': ('.calculator_tools', None),
+    'calculator_tools': ('.calculator_tools', None),
+
     # Class methods from YFinance
     'get_stock_price': ('.yfinance_tools', 'YFinanceTools'),
     'get_stock_info': ('.yfinance_tools', 'YFinanceTools'),
@@ -68,14 +121,6 @@ TOOL_MAPPINGS = {
     'transform_yaml': ('.yaml_tools', 'YAMLTools'),
     'yaml_tools': ('.yaml_tools', 'YAMLTools'),
 
-    # Calculator Tools
-    'evaluate': ('.calculator_tools', 'CalculatorTools'),
-    'solve_equation': ('.calculator_tools', 'CalculatorTools'),
-    'convert_units': ('.calculator_tools', 'CalculatorTools'),
-    'calculate_statistics': ('.calculator_tools', 'CalculatorTools'),
-    'calculate_financial': ('.calculator_tools', 'CalculatorTools'),
-    'calculator_tools': ('.calculator_tools', 'CalculatorTools'),
-
     # Python Tools
     'execute_code': ('.python_tools', 'PythonTools'),
     'analyze_code': ('.python_tools', 'PythonTools'),
@@ -90,51 +135,6 @@ TOOL_MAPPINGS = {
     'group_by': ('.pandas_tools', 'PandasTools'),
     'pivot_table': ('.pandas_tools', 'PandasTools'),
     'pandas_tools': ('.pandas_tools', 'PandasTools'),
-
-    # Wikipedia Tools
-    'search': ('.wikipedia_tools', 'WikipediaTools'),
-    'get_wikipedia_summary': ('.wikipedia_tools', 'WikipediaTools'),
-    'get_wikipedia_page': ('.wikipedia_tools', 'WikipediaTools'),
-    'get_random_wikipedia': ('.wikipedia_tools', 'WikipediaTools'),
-    'set_wikipedia_language': ('.wikipedia_tools', 'WikipediaTools'),
-    'wikipedia_tools': ('.wikipedia_tools', 'WikipediaTools'),
-
-    # Newspaper Tools
-    'get_article': ('.newspaper_tools', 'NewspaperTools'),
-    'get_news_sources': ('.newspaper_tools', 'NewspaperTools'),
-    'get_articles_from_source': ('.newspaper_tools', 'NewspaperTools'),
-    'get_trending_topics': ('.newspaper_tools', 'NewspaperTools'),
-    'newspaper_tools': ('.newspaper_tools', 'NewspaperTools'),
-
-    # arXiv Tools
-    'search_arxiv': ('.arxiv_tools', 'ArxivTools'),
-    'get_arxiv_paper': ('.arxiv_tools', 'ArxivTools'),
-    'get_papers_by_author': ('.arxiv_tools', 'ArxivTools'),
-    'get_papers_by_category': ('.arxiv_tools', 'ArxivTools'),
-    'arxiv_tools': ('.arxiv_tools', 'ArxivTools'),
-
-    # Spider Tools
-    'scrape_page': ('.spider_tools', 'SpiderTools'),
-    'extract_links': ('.spider_tools', 'SpiderTools'),
-    'crawl': ('.spider_tools', 'SpiderTools'),
-    'extract_text': ('.spider_tools', 'SpiderTools'),
-    'spider_tools': ('.spider_tools', 'SpiderTools'),
-
-    # DuckDB Tools
-    'query': ('.duckdb_tools', 'DuckDBTools'),
-    'create_table': ('.duckdb_tools', 'DuckDBTools'),
-    'load_data': ('.duckdb_tools', 'DuckDBTools'),
-    'export_data': ('.duckdb_tools', 'DuckDBTools'),
-    'get_table_info': ('.duckdb_tools', 'DuckDBTools'),
-    'analyze_data': ('.duckdb_tools', 'DuckDBTools'),
-    'duckdb_tools': ('.duckdb_tools', 'DuckDBTools'),
-
-    # Shell Tools
-    'execute_command': ('.shell_tools', 'ShellTools'),
-    'list_processes': ('.shell_tools', 'ShellTools'),
-    'kill_process': ('.shell_tools', 'ShellTools'),
-    'get_system_info': ('.shell_tools', 'ShellTools'),
-    'shell_tools': ('.shell_tools', 'ShellTools'),
 }
 
 _instances = {}  # Cache for class instances
@@ -149,7 +149,18 @@ def __getattr__(name: str) -> Any:
     if class_name is None:
         # Direct function import
         module = import_module(module_path, __package__)
-        if name in ['duckduckgo', 'file_tools', 'pandas_tools', 'wikipedia_tools',
+        if name in [
+            'duckduckgo', 'internet_search',
+            'search_arxiv', 'get_arxiv_paper', 'get_papers_by_author', 'get_papers_by_category',
+            'wiki_search', 'wiki_summary', 'wiki_page', 'wiki_random', 'wiki_language',
+            'get_article', 'get_news_sources', 'get_articles_from_source', 'get_trending_topics',
+            'scrape_page', 'extract_links', 'crawl', 'extract_text',
+            'query', 'create_table', 'load_data', 'export_data', 'get_table_info', 'analyze_data',
+            'execute_command', 'list_processes', 'kill_process', 'get_system_info',
+            'evaluate', 'solve_equation', 'convert_units', 'calculate_statistics', 'calculate_financial'
+        ]:
+            return getattr(module, name)
+        if name in ['file_tools', 'pandas_tools', 'wikipedia_tools',
                    'newspaper_tools', 'arxiv_tools', 'spider_tools', 'duckdb_tools', 'csv_tools', 'json_tools', 'excel_tools', 'xml_tools', 'yaml_tools', 'calculator_tools', 'python_tools', 'shell_tools']:
             return module  # Returns the callable module
         return getattr(module, name)

agents/praisonaiagents/tools/duckduckgo_tools.py

@@ -12,7 +12,6 @@ results = duckduckgo("AI news")
 from typing import List, Dict
 import logging
 from importlib import util
-import sys
 
 def internet_search(query: str) -> List[Dict]:
     """Perform an internet search using DuckDuckGo."""
@@ -40,8 +39,9 @@ def internet_search(query: str) -> List[Dict]:
         logging.error(error_msg)
         return [{"error": error_msg}]
 
-# Make the module callable
-sys.modules[__name__].__call__ = internet_search
+def duckduckgo(query: str) -> List[Dict]:
+    """Alias for internet_search function."""
+    return internet_search(query)
 
 if __name__ == "__main__":
     # Example usage

agents/praisonaiagents/tools/tools.py

@@ -1,5 +1,5 @@
 """Tools module for PraisonAI Agents"""
-from .internet_search import internet_search
+from .duckduckgo_tools import internet_search
 
 class Tools:
     """Tools class for backward compatibility"""

agents/praisonaiagents/tools/wikipedia_tools.py

@@ -2,13 +2,13 @@
 
 Usage:
 from praisonaiagents.tools import wikipedia_tools
-summary = wikipedia_tools.get_summary("Python programming language")
-page = wikipedia_tools.get_page("Python programming language")
-results = wikipedia_tools.search("Python programming")
+summary = wikipedia_tools.wiki_summary("Python programming language")
+page = wikipedia_tools.wiki_page("Python programming language")
+results = wikipedia_tools.wiki_search("Python programming")
 
 or
-from praisonaiagents.tools import get_wikipedia_summary, get_wikipedia_page
-summary = get_wikipedia_summary("Python programming language")
+from praisonaiagents.tools import wiki_search, wiki_summary, wiki_page
+summary = wiki_summary("Python programming language")
 """
 
 import logging
@@ -32,7 +32,7 @@ class WikipediaTools:
         # Set default language to English
         wikipedia.set_lang("en")
 
-    def search(
+    def wiki_search(
         self, 
         query: str, 
         results: int = 10, 
@@ -63,7 +63,7 @@ class WikipediaTools:
             logging.error(error_msg)
             return {"error": error_msg}
 
-    def get_summary(
+    def wiki_summary(
         self, 
         title: str, 
         sentences: int = 5, 
@@ -92,7 +92,7 @@ class WikipediaTools:
             logging.error(error_msg)
             return {"error": error_msg}
 
-    def get_page(
+    def wiki_page(
         self, 
         title: str, 
         auto_suggest: bool = True
@@ -168,7 +168,7 @@ class WikipediaTools:
         
         return sections
 
-    def get_random(self, pages: int = 1) -> Union[List[str], Dict[str, str]]:
+    def wiki_random(self, pages: int = 1) -> Union[List[str], Dict[str, str]]:
         """
         Get random Wikipedia page titles.
         
@@ -185,7 +185,7 @@ class WikipediaTools:
             logging.error(error_msg)
             return {"error": error_msg}
 
-    def set_language(self, language: str) -> bool:
+    def wiki_language(self, language: str) -> bool:
         """
         Set the language for Wikipedia searches.
         
@@ -205,11 +205,11 @@ class WikipediaTools:
 
 # Create instance for direct function access
 _wikipedia_tools = WikipediaTools()
-search = _wikipedia_tools.search
-get_summary = _wikipedia_tools.get_summary
-get_page = _wikipedia_tools.get_page
-get_random = _wikipedia_tools.get_random
-set_language = _wikipedia_tools.set_language
+wiki_search = _wikipedia_tools.wiki_search
+wiki_summary = _wikipedia_tools.wiki_summary
+wiki_page = _wikipedia_tools.wiki_page
+wiki_random = _wikipedia_tools.wiki_random
+wiki_language = _wikipedia_tools.wiki_language
 
 if __name__ == "__main__":
     # Example usage
@@ -220,7 +220,7 @@ if __name__ == "__main__":
     # 1. Search for a topic
     print("1. Searching Wikipedia")
     print("------------------------------")
-    search_results = search("Python programming language")
+    search_results = wiki_search("Python programming language")
     print("Search results:")
     print(json.dumps(search_results, indent=2))
     print()
@@ -228,7 +228,7 @@ if __name__ == "__main__":
     # 2. Get a page summary
     print("2. Getting Page Summary")
     print("------------------------------")
-    summary = get_summary("Python programming language", sentences=3)
+    summary = wiki_summary("Python programming language", sentences=3)
     print("Summary:")
     print(summary)
     print()
@@ -236,7 +236,7 @@ if __name__ == "__main__":
     # 3. Get detailed page information
     print("3. Getting Full Page Information")
     print("------------------------------")
-    page = get_page("Python programming language")
+    page = wiki_page("Python programming language")
     if isinstance(page, dict) and "error" not in page:
         print("Page sections:")
         for section in page["sections"]:
@@ -252,7 +252,7 @@ if __name__ == "__main__":
     # 4. Get random pages
     print("4. Getting Random Pages")
     print("------------------------------")
-    random_pages = get_random(3)
+    random_pages = wiki_random(3)
     print("Random page titles:")
     print(json.dumps(random_pages, indent=2))
     print()
@@ -260,9 +260,9 @@ if __name__ == "__main__":
     # 5. Try different language
     print("5. Changing Language")
     print("------------------------------")
-    success = set_language("es")
+    success = wiki_language("es")
     if success:
-        summary = get_summary("Python (lenguaje de programación)", sentences=1)
+        summary = wiki_summary("Python (lenguaje de programación)", sentences=1)
         print("Spanish summary:")
         print(summary)
     print()

agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.24"
+version = "0.0.31"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 authors = [
     { name="Mervin Praison" }
@@ -13,4 +13,9 @@ dependencies = [
     "pydantic",
     "rich",
     "openai"
+]
+
+[project.optional-dependencies]
+memory = [
+    "chromadb>=0.6.0"
 ] 

agents/structured_response_example.py

@@ -0,0 +1,95 @@
+from praisonaiagents import Agent
+from pydantic import BaseModel
+from typing import List, Optional
+
+# Define structured output models
+class SearchResult(BaseModel):
+    title: str
+    url: Optional[str]
+    snippet: str
+
+class AnalysisReport(BaseModel):
+    topic: str
+    key_findings: List[str]
+    search_results: List[SearchResult]
+    summary: str
+    confidence_score: float
+
+def get_structured_analysis(query: str, verbose: bool = True) -> AnalysisReport:
+    """
+    Performs a search and returns a structured analysis using an AI agent.
+    
+    Args:
+        query (str): The search query or topic to analyze
+        verbose (bool): Whether to show detailed output
+        
+    Returns:
+        AnalysisReport: A structured report containing the analysis
+    """
+    # Create an agent with search capabilities
+    agent = Agent(
+        name="StructuredAnalyst",
+        role="Research Analyst",
+        goal="Analyze topics and provide structured reports",
+        backstory="Expert at gathering information and providing structured analysis",
+        verbose=verbose,
+        self_reflect=True,  # Enable self-reflection for better quality
+        markdown=True,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create the analysis prompt
+    prompt = f"""
+Analyze the following topic: "{query}"
+
+Provide a structured analysis in JSON format that matches this schema:
+{{
+    "topic": "string",
+    "key_findings": ["string"],
+    "search_results": [
+        {{
+            "title": "string",
+            "url": "string",
+            "snippet": "string"
+        }}
+    ],
+    "summary": "string",
+    "confidence_score": float (0-1)
+}}
+
+Requirements:
+1. Include at least 3 key findings
+2. Include at least 2 relevant search results
+3. Provide a comprehensive summary
+4. Set confidence score based on quality of sources (0-1)
+
+Return ONLY the JSON object, no other text.
+"""
+    
+    # Get structured response from agent
+    response = agent.chat(
+        prompt=prompt,
+        output_json=AnalysisReport  # This ensures response matches our model
+    )
+    
+    return AnalysisReport.model_validate_json(response)
+
+if __name__ == "__main__":
+    # Example usage
+    analysis = get_structured_analysis("Latest developments in AI agents and autonomous systems")
+    print(analysis)
+    # Print the structured results
+    print("\n=== Structured Analysis Report ===")
+    print(f"Topic: {analysis.topic}")
+    print("\nKey Findings:")
+    for i, finding in enumerate(analysis.key_findings, 1):
+        print(f"{i}. {finding}")
+    
+    print("\nSearch Results:")
+    for result in analysis.search_results:
+        print(f"\nTitle: {result.title}")
+        print(f"URL: {result.url}")
+        print(f"Snippet: {result.snippet}")
+    
+    print(f"\nSummary: {analysis.summary}")
+    print(f"Confidence Score: {analysis.confidence_score:.2f}") 

agents/tools_example.py

@@ -0,0 +1,30 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import get_article, get_news_sources, get_articles_from_source, get_trending_topics
+
+# Create Wikipedia agent
+news_agent = Agent(
+    name="NewsAgent",
+    role="News Analyst",
+    goal="Collect and analyze news articles from various sources.",
+    backstory="Expert in news gathering and content analysis.",
+    tools=[get_article, get_news_sources, get_articles_from_source, get_trending_topics],
+    self_reflect=False
+)
+
+
+# Define research task
+news_task = Task(
+    description="Analyze news articles about 'AI developments' from major tech news sources.",
+    expected_output="Summary of key AI developments with source articles.",
+    agent=news_agent,
+    name="ai_news"
+)
+
+
+# Run agent
+agents = PraisonAIAgents(
+    agents=[news_agent],
+    tasks=[news_task],
+    process="sequential"
+)
+agents.start()

docs/api/praisonai/deploy.html

@@ -110,7 +110,7 @@ Loads environment variables from .env file or system and sets them.</p>
             file.write(&#34;FROM python:3.11-slim\n&#34;)
             file.write(&#34;WORKDIR /app\n&#34;)
             file.write(&#34;COPY . .\n&#34;)
-            file.write(&#34;RUN pip install flask praisonai==2.0.33 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.0.41 gunicorn markdown\n&#34;)
             file.write(&#34;EXPOSE 8080\n&#34;)
             file.write(&#39;CMD [&#34;gunicorn&#34;, &#34;-b&#34;, &#34;0.0.0.0:8080&#34;, &#34;api:app&#34;]\n&#39;)
             

docs/api/praisonaiagents/agents/autoagents.mdx

@@ -0,0 +1,187 @@
+---
+title: "AutoAgents Module"
+description: "Documentation for the praisonaiagents.agents.autoagents module"
+icon: "robot"
+---
+
+# Module praisonaiagents.agents.autoagents
+
+The AutoAgents module provides automatic creation and management of AI agents and tasks based on high-level instructions.
+
+## Classes
+
+### AutoAgents
+The main class for automatically creating and managing AI agents and tasks.
+
+#### Parameters
+- `instructions: str` - High-level task description for the agents
+- `tools: Optional[List[Any]] = None` - List of tools available to the agents
+- `verbose: bool = False` - Enable detailed logging
+- `process: str = "sequential"` - Process type (sequential or hierarchical)
+- `manager_llm: Optional[str] = None` - Language model for manager agent
+- `max_retries: int = 5` - Maximum retry attempts
+- `completion_checker: Optional[Any] = None` - Custom completion checker
+- `allow_code_execution: bool = False` - Allow code execution
+- `memory: bool = True` - Enable agent memory
+- `markdown: bool = True` - Enable markdown formatting
+- `self_reflect: bool = False` - Enable agent self-reflection
+- `max_reflect: int = 3` - Maximum reflection iterations
+- `min_reflect: int = 1` - Minimum reflection iterations
+- `llm: Optional[str] = None` - Language model for agents
+- `function_calling_llm: Optional[str] = None` - Language model for tool calling
+- `respect_context_window: bool = True` - Respect model context window
+- `code_execution_mode: str = "safe"` - Code execution mode (safe/unsafe)
+- `embedder_config: Optional[Dict[str, Any]] = None` - Embedder configuration
+- `knowledge_sources: Optional[List[Any]] = None` - Knowledge sources
+- `use_system_prompt: bool = True` - Use system prompts
+- `cache: bool = True` - Enable caching
+- `allow_delegation: bool = False` - Allow task delegation
+- `step_callback: Optional[Any] = None` - Callback for each step
+- `system_template: Optional[str] = None` - Custom system template
+- `prompt_template: Optional[str] = None` - Custom prompt template
+- `response_template: Optional[str] = None` - Custom response template
+- `max_rpm: Optional[int] = None` - Maximum requests per minute
+- `max_execution_time: Optional[int] = None` - Maximum execution time
+- `max_iter: int = 20` - Maximum iterations
+- `reflect_llm: Optional[str] = None` - Language model for reflection
+- `max_agents: int = 3` - Maximum number of agents to create
+
+#### Methods
+
+##### start()
+Start the agents synchronously.
+
+```python
+def start(self):
+    """
+    Creates tasks based on the instructions, then starts execution.
+    Returns the task status and results dictionary.
+    """
+    return super().start()
+```
+
+##### astart()
+Start the agents asynchronously.
+
+```python
+async def astart(self):
+    """
+    Async version of start() method.
+    Creates tasks based on the instructions, then starts execution.
+    Returns the task status and results dictionary.
+    """
+    return await super().astart()
+```
+
+#### Internal Methods
+
+##### _generate_config()
+Generate the configuration for agents and tasks.
+
+```python
+def _generate_config(self) -> AutoAgentsConfig:
+    """
+    Generate the configuration for agents and tasks based on instructions.
+    Returns AutoAgentsConfig object containing agent and task configurations.
+    """
+```
+
+##### _create_agents_and_tasks()
+Create agents and tasks from configuration.
+
+```python
+def _create_agents_and_tasks(self, config: AutoAgentsConfig) -> tuple[List[Agent], List[Task]]:
+    """
+    Create agents and tasks based on the generated configuration.
+    Returns tuple of (agents, tasks).
+    """
+```
+
+##### _assign_tools_to_agent()
+Assign appropriate tools to an agent.
+
+```python
+def _assign_tools_to_agent(self, agent_config: AgentConfig) -> List[Any]:
+    """
+    Assign tools to an agent based on its role and tasks.
+    Returns list of assigned tools.
+    """
+```
+
+## Pydantic Models
+
+### TaskConfig
+Configuration for a task.
+
+#### Attributes
+- `name: str` - Task name
+- `description: str` - Task description
+- `expected_output: str` - Expected output description
+- `tools: List[str]` - Required tools for the task
+
+### AgentConfig
+Configuration for an agent.
+
+#### Attributes
+- `name: str` - Agent name
+- `role: str` - Agent role
+- `goal: str` - Agent goal
+- `backstory: str` - Agent backstory
+- `tools: List[str]` - Required tools
+- `tasks: List[TaskConfig]` - Tasks assigned to the agent
+
+### AutoAgentsConfig
+Overall configuration for AutoAgents.
+
+#### Attributes
+- `main_instruction: str` - Main instruction for the agents
+- `process_type: str` - Process type (sequential/hierarchical)
+- `agents: List[AgentConfig]` - List of agent configurations
+
+## Example Usage
+
+### Basic Usage
+```python
+from praisonaiagents import AutoAgents
+from praisonaiagents.tools import SerperDevTool
+
+agents = AutoAgents(
+    instructions="Research recent AI developments",
+    tools=[SerperDevTool()],
+    verbose=True
+)
+result = agents.start()
+```
+
+### Async Usage
+```python
+async def main():
+    agents = AutoAgents(
+        instructions="Research recent AI developments",
+        tools=[SerperDevTool()],
+        process="hierarchical"
+    )
+    result = await agents.astart()
+
+import asyncio
+asyncio.run(main())
+```
+
+### Advanced Configuration
+```python
+agents = AutoAgents(
+    instructions="Complex research task",
+    tools=[SerperDevTool()],
+    max_agents=5,
+    process="hierarchical",
+    manager_llm="gpt-4o",
+    memory=True,
+    allow_delegation=True,
+    max_execution_time=600,
+    self_reflect=True
+)
+```
+
+<Note>
+  For optimal results, provide clear instructions and appropriate tools for your use case.
+</Note>

docs/code/installation.mdx

@@ -1,69 +0,0 @@
----
-title: Installation
-description: Set up PraisonAI in your development environment
-icon: download
----
-
-<Note>
-  **Requirements**
-  
-  - Python 3.10 or higher
-  - pip package manager
-  - Virtual environment (recommended)
-</Note>
-
-# Installing PraisonAI
-
-Follow these steps to set up PraisonAI in your development environment.
-
-<Steps>
-  <Step title="Create Virtual Environment (Optional)">
-    First, create and activate a virtual environment:
-    <CodeGroup>
-    ```bash Mac/Linux
-    python -m venv praisonai-env
-    source praisonai-env/bin/activate
-    ```
-
-    ```bash Windows
-    python -m venv praisonai-env
-    .\praisonai-env\Scripts\activate
-    ```
-    </CodeGroup>
-  </Step>
-
-  <Step title="Install PraisonAI">
-    Install the core package and tools:
-    ```bash Terminal
-    pip install praisonaiagents
-    ```
-  </Step>
-
-  <Step title="Configure Environment">
-    ```bash Terminal
-    export OPENAI_API_KEY=your_openai_key
-    ```
-    Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
-    You can also use other LLM providers like Anthropic, Google, etc. Please refer to the [Models](/models) for more information.
-  </Step>
-
-</Steps>
-
-## Next Steps
-
-<CardGroup cols={2}>
-  <Card
-    title="Quick Start Guide"
-    icon="bolt"
-    href="/code/quickstart"
-  >
-    Build your first AI agent
-  </Card>
-  <Card
-    title="API Reference"
-    icon="code"
-    href="/api/praisonaiagents/index"
-  >
-    Explore the API documentation
-  </Card>
-</CardGroup> 

docs/code/introduction.mdx

@@ -1,188 +0,0 @@
----
-title: "Introduction"
-description: "Welcome to PraisonAI - The Next Generation AI Agent Framework"
-icon: "book-open"
----
-
-<Note>
-  PraisonAI is a powerful framework for building and deploying AI agents that can understand, reason, and execute complex tasks autonomously.
-</Note>
-
-# What is PraisonAI?
-
-```mermaid
-graph LR
-    %% Define the main flow
-    Start([▶ Start]) --> Agent1
-    Agent1 --> Process[⚙ Process]
-    Process --> Agent2
-    Agent2 --> Output([✓ Output])
-    Process -.-> Agent1
-    
-    %% Styling for main elements
-    style Start fill:#2D3047,stroke:#7C90A0,color:#fff
-    style Output fill:#2D3047,stroke:#7C90A0,color:#fff
-    style Process fill:#5C80BC,stroke:#7C90A0,color:#fff
-    
-    %% Define subgraphs for agents and their tasks
-    subgraph Agent1[" "]
-        Task1[📋 Task]
-        AgentIcon1[🤖 AI Agent]
-        Tools1[🔧 Tools]
-        
-        Task1 --- AgentIcon1
-        AgentIcon1 --- Tools1
-        
-        style Task1 fill:#2D3047,stroke:#7C90A0,color:#fff
-        style AgentIcon1 fill:#5C80BC,stroke:#7C90A0,color:#fff
-        style Tools1 fill:#2D3047,stroke:#7C90A0,color:#fff
-    end
-    
-    subgraph Agent2[" "]
-        Task2[📋 Task]
-        AgentIcon2[🤖 AI Agent]
-        Tools2[🔧 Tools]
-        
-        Task2 --- AgentIcon2
-        AgentIcon2 --- Tools2
-        
-        style Task2 fill:#2D3047,stroke:#7C90A0,color:#fff
-        style AgentIcon2 fill:#5C80BC,stroke:#7C90A0,color:#fff
-        style Tools2 fill:#2D3047,stroke:#7C90A0,color:#fff
-    end
-    
-    %% Style for agent containers
-    style Agent1 fill:#1B1F3B,stroke:#7C90A0,color:#fff
-    style Agent2 fill:#1B1F3B,stroke:#7C90A0,color:#fff
-    
-    %% Global styles
-    classDef default fill:#2D3047,stroke:#7C90A0,color:#fff
-    linkStyle default stroke:#7C90A0,stroke-width:2px
-```
-
-## Core Components
-
-<CardGroup cols={2}>
-  <Card title="Agents" icon="user-robot">
-    Autonomous AI entities that can understand context and execute tasks
-  </Card>
-  <Card title="Tasks" icon="list-check">
-    Units of work that agents can execute independently or collaboratively
-  </Card>
-  <Card title="Process" icon="diagram-project">
-    Workflow management for coordinating agent activities
-  </Card>
-  <Card title="Tools" icon="toolbox">
-    Extensible capabilities that agents can leverage
-  </Card>
-</CardGroup>
-
-## Key Features
-
-<Steps>
-  <Step title="Autonomous Agents">
-    Create intelligent agents that can:
-    - Understand natural language instructions
-    - Make decisions based on context
-    - Execute complex tasks autonomously
-  </Step>
-  <Step title="Flexible Architecture">
-    Build with:
-    - Modular components
-    - Extensible tools
-    - Customizable workflows
-  </Step>
-  <Step title="Advanced Capabilities">
-    Leverage:
-    - Multi-agent collaboration
-    - Memory and context management
-    - Tool integration
-  </Step>
-</Steps>
-
-## Use Cases
-
-<CardGroup cols={2}>
-  <Card title="Customer Service" icon="headset">
-    Build intelligent support agents that can handle customer inquiries and resolve issues autonomously.
-  </Card>
-  <Card title="Data Analysis" icon="chart-line">
-    Create agents that can process, analyze, and derive insights from complex datasets.
-  </Card>
-  <Card title="Content Creation" icon="pen-nib">
-    Deploy agents that can generate, edit, and optimize content across various formats.
-  </Card>
-  <Card title="Process Automation" icon="gears">
-    Automate complex workflows with intelligent agents that can coordinate and execute tasks.
-  </Card>
-</CardGroup>
-
-## Getting Started
-
-<Warning>
-  Before proceeding, ensure you have Python 3.9+ installed on your system.
-</Warning>
-
-### Quick Setup
-
-<CodeGroup>
-  ```bash pip
-  pip install praisonai
-  ```
-</CodeGroup>
-
-### Basic Example
-
-```python
-from praisonaiagents import Agent, Task, PraisonAIAgents
-
-# Create an agent
-researcher = Agent(
-    name="Researcher",
-    role="Senior Research Analyst",
-    goal="Uncover cutting-edge developments in AI",
-    backstory="You are an expert at a technology research group",
-    verbose=True,
-    llm="gpt-4o"
-)
-
-# Define a task
-task = Task(
-    name="research_task",
-    description="Analyze 2024's AI advancements",
-    expected_output="A detailed report",
-    agent=researcher
-)
-
-# Run the agents
-agents = PraisonAIAgents(
-    agents=[researcher],
-    tasks=[task],
-    verbose=False
-)
-
-result = agents.start()
-```
-
-## Next Steps
-
-<CardGroup cols={2}>
-  <Card
-    title="Installation"
-    icon="download"
-    href="/code/installation"
-  >
-    Complete installation guide and setup instructions
-  </Card>
-  <Card
-    title="Quick Start"
-    icon="play"
-    href="/code/quickstart"
-  >
-    Build your first AI agent in minutes
-  </Card>
-</CardGroup>
-
-<Tip>
-  Join our community on [Discord](https://www.youtube.com/redirect?event=channel_description&redir_token=QUFFLUhqbUpiZE00YlF1MjB1LVNIeTFxTnV6MWRRc18wZ3xBQ3Jtc0ttQVZ0aFJ4RXRDanlBQU1Vd3lHU3BBcml3bzhoek1pTmlkZkFkWjlNVDBpRkxZd1dTOWhPc20xbHJOb1NibmNYeTEydklJT0pZOVJFQW93MmJOQXU0WkJNVzNsd29SZ3FBNFVwMTFGNThNSHBWVUhjSQ&q=https%3A%2F%2Fdiscord.gg%2FnNZu5gGT59) to connect with other developers and get help!
-</Tip> 

docs/code/quickstart.mdx

@@ -1,195 +0,0 @@
----
-title: Quick Start
-description: Build your first AI agent with PraisonAI
-icon: bolt
----
-
-<Steps>
-
-  <Step title="Install PraisonAI">
-    Install the core package:
-    ```bash Terminal
-    pip install praisonaiagents
-    ```
-  </Step>
-
-  <Step title="Configure Environment">
-    ```bash Terminal
-    export OPENAI_API_KEY=your_openai_key
-    ```
-    Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
-    You can also use other LLM providers like Anthropic, Google, etc. Please refer to the [Models](/models) for more information.
-  </Step>
-
-  <Step title="Create Agent">
-    Create `app.py`:
-## Code Example
-
-<CodeGroup>
-  ```python Basic
-  from praisonaiagents import Agent, Task, PraisonAIAgents
-
-  # Create an agent
-  researcher = Agent(
-      name="Researcher",
-      role="Senior Research Analyst",
-      goal="Uncover cutting-edge developments in AI",
-      backstory="You are an expert at a technology research group",
-      verbose=True,
-      llm="gpt-4o"
-  )
-
-  # Define a task
-  task = Task(
-      name="research_task",
-      description="Analyze 2024's AI advancements",
-      expected_output="A detailed report",
-      agent=researcher
-  )
-
-  # Run the agents
-  agents = PraisonAIAgents(
-      agents=[researcher],
-      tasks=[task],
-      verbose=False
-  )
-
-  result = agents.start()
-  ```
-
-  ```python Advanced
-  from praisonaiagents import Agent, Task, PraisonAIAgents
-
-  # Create multiple agents
-  researcher = Agent(
-      name="Researcher",
-      role="Senior Research Analyst",
-      goal="Uncover cutting-edge developments in AI",
-      backstory="You are an expert at a technology research group",
-      verbose=True,
-      llm="gpt-4o",
-      markdown=True
-  )
-
-  writer = Agent(
-      name="Writer",
-      role="Tech Content Strategist",
-      goal="Craft compelling content on tech advancements",
-      backstory="You are a content strategist",
-      llm="gpt-4o",
-      markdown=True
-  )
-
-  # Define multiple tasks
-  task1 = Task(
-      name="research_task",
-      description="Analyze 2024's AI advancements",
-      expected_output="A detailed report",
-      agent=researcher
-  )
-
-  task2 = Task(
-      name="writing_task",
-      description="Create a blog post about AI advancements",
-      expected_output="A blog post",
-      agent=writer
-  )
-
-  # Run with hierarchical process
-  agents = PraisonAIAgents(
-      agents=[researcher, writer],
-      tasks=[task1, task2],
-      verbose=False,
-      process="hierarchical",
-      manager_llm="gpt-4o"
-  )
-
-  result = agents.start()
-  ```
-</CodeGroup>
-  </Step>
-
-  <Step title="Run the Program">
-    Execute your script:
-    ```bash Terminal
-    python app.py
-    ```
-
-    You should see:
-    - Agent initialization
-    - Agents progress
-    - Final results
-    - Generated report
-  </Step>
-</Steps>
-
-## Advanced Usage
-
-### Creating Custom Tool
-
-```python
-from praisonaiagents import Agent, Task, PraisonAIAgents
-from duckduckgo_search import DDGS
-from typing import List, Dict
-
-# 1. Tool
-def internet_search_tool(query: str) -> List[Dict]:
-    """
-    Perform Internet Search
-    """
-    results = []
-    ddgs = DDGS()
-    for result in ddgs.text(keywords=query, max_results=5):
-        results.append({
-            "title": result.get("title", ""),
-            "url": result.get("href", ""),
-            "snippet": result.get("body", "")
-        })
-    return results
-
-# 2. Agent
-data_agent = Agent(
-    name="DataCollector",
-    role="Search Specialist",
-    goal="Perform internet searches to collect relevant information.",
-    backstory="Expert in finding and organising internet data.",
-    tools=[internet_search_tool],
-    self_reflect=False
-)
-
-# 3. Tasks
-collect_task = Task(
-    description="Perform an internet search using the query: 'AI job trends in 2024'. Return results as a list of title, URL, and snippet.",
-    expected_output="List of search results with titles, URLs, and snippets.",
-    agent=data_agent,
-    name="collect_data",
-)
-
-# 4. Start Agents
-agents = PraisonAIAgents(
-    agents=[data_agent],
-    tasks=[collect_task],
-    process="sequential"
-)
-
-agents.start()
-```
-
-## Next Steps
-
-<CardGroup cols={2}>
-  <Card
-    title="Core Concepts"
-    icon="book"
-    href="/concepts/agents"
-  >
-    Learn about agents, tasks, and processes
-  </Card>
-  <Card
-    title="API Reference"
-    icon="code"
-    href="/api/praisonaiagents/index"
-  >
-    Explore detailed API documentation
-  </Card>
-</CardGroup> 

docs/concepts/agents.mdx

@@ -105,43 +105,254 @@ graph LR
   ```
 </CodeGroup>
 
-## Agent Types
 
 <Steps>
-  <Step title="Basic Agent">
-    - Single-purpose focus
-    - Direct user interaction
-    - Limited tool set
+
+  <Step title="Install PraisonAI">
+    Install the core package:
+    ```bash Terminal
+    pip install praisonaiagents
+    ```
   </Step>
-  <Step title="Specialized Agent">
-    - Domain expertise
-    - Advanced capabilities
-    - Custom tools
+
+  <Step title="Configure Environment">
+    ```bash Terminal
+    export OPENAI_API_KEY=your_openai_key
+    ```
+    Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
+    Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
   </Step>
-  <Step title="Collaborative Agent">
-    - Team interaction
-    - Task delegation
-    - Shared context
+
+  <Step title="Create Agent">
+    Create `app.py`:
+<CodeGroup>
+  ```python Single Agent
+  from praisonaiagents import Agent, Task, PraisonAIAgents
+
+  # Create an agent
+  researcher = Agent(
+      name="Researcher",
+      role="Senior Research Analyst",
+      goal="Uncover cutting-edge developments in AI",
+      backstory="You are an expert at a technology research group",
+      verbose=True,
+      llm="gpt-4o"
+  )
+
+  # Define a task
+  task = Task(
+      name="research_task",
+      description="Analyze 2024's AI advancements",
+      expected_output="A detailed report",
+      agent=researcher
+  )
+
+  # Run the agents
+  agents = PraisonAIAgents(
+      agents=[researcher],
+      tasks=[task],
+      verbose=False
+  )
+
+  result = agents.start()
+  ```
+
+  ```python Multiple Agents
+  from praisonaiagents import Agent, Task, PraisonAIAgents
+
+  # Create multiple agents
+  researcher = Agent(
+      name="Researcher",
+      role="Senior Research Analyst",
+      goal="Uncover cutting-edge developments in AI",
+      backstory="You are an expert at a technology research group",
+      verbose=True,
+      llm="gpt-4o",
+      markdown=True
+  )
+
+  writer = Agent(
+      name="Writer",
+      role="Tech Content Strategist",
+      goal="Craft compelling content on tech advancements",
+      backstory="You are a content strategist",
+      llm="gpt-4o",
+      markdown=True
+  )
+
+  # Define multiple tasks
+  task1 = Task(
+      name="research_task",
+      description="Analyze 2024's AI advancements",
+      expected_output="A detailed report",
+      agent=researcher
+  )
+
+  task2 = Task(
+      name="writing_task",
+      description="Create a blog post about AI advancements",
+      expected_output="A blog post",
+      agent=writer
+  )
+
+  # Run with hierarchical process
+  agents = PraisonAIAgents(
+      agents=[researcher, writer],
+      tasks=[task1, task2],
+      verbose=False,
+      process="hierarchical",
+      manager_llm="gpt-4o"
+  )
+
+  result = agents.start()
+  ```
+</CodeGroup>
+  </Step>
+
+  <Step title="Start Agents">
+    Execute your script:
+    ```bash Terminal
+    python app.py
+    ```
+
+    You should see:
+    - Agent initialization
+    - Agents progress
+    - Final results
+    - Generated report
   </Step>
 </Steps>
 
+## Agent Types
+
+<CardGroup cols={3}>
+  <Card title="Basic Agent" icon="user" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Overview">
+        Perfect for straightforward tasks and direct interactions
+      </Accordion>
+      <Accordion title="Features">
+        - Single-purpose focus
+        - Direct user interaction
+        - Limited tool set
+        - Ideal for simple tasks
+      </Accordion>
+    </AccordionGroup>
+  </Card>
+
+  <Card title="Specialized Agent" icon="user-gear" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Overview">
+        Experts in specific domains with advanced capabilities
+      </Accordion>
+      <Accordion title="Features">
+        - Domain expertise
+        - Advanced capabilities
+        - Custom tools
+        - Deep knowledge base
+      </Accordion>
+    </AccordionGroup>
+  </Card>
+
+  <Card title="Collaborative Agent" icon="users" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Overview">
+        Designed for team-based operations and complex workflows
+      </Accordion>
+      <Accordion title="Features">
+        - Team interaction
+        - Task delegation
+        - Shared context
+        - Coordinated actions
+      </Accordion>
+    </AccordionGroup>
+  </Card>
+</CardGroup>
+
 ## Best Practices
 
-<Warning>
-  Always implement proper error handling and resource management in your agent configurations.
-</Warning>
+<Note>
+Always implement proper error handling and resource management in your agent configurations.
+</Note>
 
-### Agent Design
-1. Clear role definition
-2. Specific, measurable goals
-3. Relevant tool selection
-4. Appropriate memory configuration
+<CardGroup cols={2}>
+  <Card title="Agent Design" icon="compass-drafting" iconType="solid">
+    <Steps>
+      <Step title="Role Definition">
+        Define clear, specific roles for each agent
+      </Step>
+      <Step title="Goal Setting">
+        Set specific, measurable goals
+      </Step>
+      <Step title="Tool Selection">
+        Choose relevant tools for the task
+      </Step>
+      <Step title="Memory Setup">
+        Configure appropriate memory settings
+      </Step>
+    </Steps>
+  </Card>
 
-### Agent Interaction
-1. Clear communication protocols
-2. Defined delegation rules
-3. Error handling mechanisms
-4. Resource management
+  <Card title="Agent Interaction" icon="network-wired" iconType="solid">
+    <Steps>
+      <Step title="Communication">
+        Establish clear communication protocols
+      </Step>
+      <Step title="Delegation">
+        Define explicit delegation rules
+      </Step>
+      <Step title="Error Handling">
+        Implement robust error handling
+      </Step>
+      <Step title="Resource Management">
+        Set up efficient resource allocation
+      </Step>
+    </Steps>
+  </Card>
+</CardGroup>
+
+## Async Capabilities
+
+<CardGroup cols={1}>
+  <Card title="Key Features" icon="bolt" iconType="solid">
+    <Tabs>
+      <Tab title="Async Support">
+        ```python
+        async def main():
+            agent = Agent(name="AsyncAgent")
+            result = await agent.aprocess_task()
+        ```
+        - Full async/await support
+        - Non-blocking operations
+        - Enhanced performance
+      </Tab>
+      
+      <Tab title="Parallel Execution">
+        ```python
+        async def parallel_tasks():
+            tasks = [agent1.task(), agent2.task()]
+            results = await asyncio.gather(*tasks)
+        ```
+        - Parallel task execution
+        - Efficient resource usage
+        - Improved throughput
+      </Tab>
+      
+      <Tab title="Integration">
+        ```python
+        @agent.async_tool
+        async def custom_tool():
+            async with aiohttp.ClientSession() as session:
+                # Async operations
+                pass
+        ```
+        - Async tool integration
+        - Callback support
+        - Mixed sync/async operations
+      </Tab>
+    </Tabs>
+  </Card>
+</CardGroup>
 
 ## Advanced Features
 

docs/concepts/memory.mdx

@@ -0,0 +1,441 @@
+---
+title: "AI Agents with Memory"
+sidebarTitle: "Memory"
+description: "Learn how to create AI agents with memory capabilities for maintaining context and information across tasks."
+icon: "brain"
+---
+
+## Quick Start
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install "praisonaiagents[memory]" duckduckgo_search 
+            ```
+            duckduckgo_search is a tool that allows agents to search the web.
+            It is required for the multiple agents example shown below.
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+<CodeGroup>
+  ```python Single Agent
+  from praisonaiagents.agents.agents import Agent, Task, PraisonAIAgents
+
+  # Create blog writer agent
+  blog_agent = Agent(
+      role="Blog Writer",
+      goal="Write a blog post about AI",
+      backstory="Expert at writing blog posts",
+      llm="gpt-4o-mini"
+  )
+
+  # Create blog writing task
+  blog_task = Task(
+      description="Write a blog post about AI trends",
+      expected_output="Well-written blog post about AI trends",
+      agent=blog_agent
+  )
+
+  # Create and start the agents with memory enabled
+  agents = PraisonAIAgents(
+      agents=[blog_agent],
+      tasks=[blog_task],
+      memory=True
+  )   
+
+  # Start execution
+  result = agents.start()
+  print(result)
+  ```
+
+  ```python Multiple Agents
+  from praisonaiagents.agents.agents import Agent, Task, PraisonAIAgents
+  from praisonaiagents.tools import duckduckgo
+
+  # Create research agent with memory
+  research_agent = Agent(
+      role="Research Analyst",
+      goal="Research and document key information about topics",
+      backstory="Expert at analyzing and storing information in memory",
+      llm="gpt-4o-mini",
+      tools=[duckduckgo]
+  )
+
+  # Create blog writer agent
+  blog_agent = Agent(
+      role="Blog Writer",
+      goal="Write a blog post about the research",
+      backstory="Expert at writing blog posts",
+      llm="gpt-4o-mini"
+  )
+
+  # Create research task
+  research_task = Task(
+      description="Research and document key information about AI trends",
+      expected_output="Detailed research findings about AI trends",
+      agent=research_agent
+  )
+
+  # Create blog writing task
+  blog_task = Task(
+      description="Write a blog post about the research findings",
+      expected_output="Well-written blog post based on research",
+      agent=blog_agent
+  )
+
+  # Create and start the agents with advanced memory configuration
+  agents = PraisonAIAgents(
+      agents=[research_agent, blog_agent],
+      tasks=[research_task, blog_task],
+      memory=True
+  )   
+
+  # Start execution
+  result = agents.start()
+  print(result)
+  ```
+</CodeGroup>
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+memory: true
+roles:
+  researcher:
+    backstory: Expert at analyzing and storing information in memory.
+    goal: Research and document key information about topics
+    role: Research Analyst
+    llm: gpt-4o-mini
+    tools:
+      - duckduckgo
+    tasks:
+      research_task:
+        description: Research and document key information about topics.
+        expected_output: Detailed research findings.
+
+  writer:
+    backstory: Expert at writing blog posts.
+    goal: Write a blog post about the research
+    role: Blog Writer
+    llm: gpt-4o-mini
+    tasks:
+      blog_task:
+        description: Write a blog post about the research.
+        expected_output: Well-written blog post based on research.
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+  - Basic understanding of Python
+</Note>
+
+## Understanding Memory
+
+<Card title="What is Agent Memory?" icon="question">
+  Memory in AI agents enables them to:
+  - Maintain context across multiple tasks
+  - Remember previous interactions and findings
+  - Build upon past knowledge
+  - Share information between agents
+  - Create more coherent and contextual responses
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Context Retention" icon="brain">
+    Maintain information across multiple interactions.
+  </Card>
+  <Card title="Information Sharing" icon="share-nodes">
+    Share knowledge between multiple agents.
+  </Card>
+  <Card title="Long-term Storage" icon="database">
+    Store and retrieve information over extended periods.
+  </Card>
+  <Card title="Memory Types" icon="layer-group">
+    Support for different memory types (short-term, long-term).
+  </Card>
+</CardGroup>
+
+## Multi-Agent Memory
+
+<Tabs>
+  <Tab title="Code">
+    ```python
+    from praisonaiagents import Agent, Task, PraisonAIAgents
+    from praisonaiagents.tools import duckduckgo
+
+    # Create first agent for research
+    researcher = Agent(
+        role="Research Analyst",
+        goal="Research and analyze market trends",
+        backstory="Expert in market research and data analysis",
+        tools=[duckduckgo],
+        verbose=True
+    )
+
+    # Create second agent for report writing
+    writer = Agent(
+        role="Report Writer",
+        goal="Create comprehensive market reports",
+        backstory="Expert in technical writing and report creation",
+        verbose=True
+    )
+
+    # Create research task
+    research_task = Task(
+        description="Research current market trends",
+        expected_output="Detailed market analysis",
+        agent=researcher
+    )
+
+    # Create writing task
+    report_task = Task(
+        description="Create a market report based on research",
+        expected_output="Comprehensive market report",
+        agent=writer
+    )
+
+    # Create and start the agents with memory
+    agents = PraisonAIAgents(
+        agents=[researcher, writer],
+        tasks=[research_task, report_task],
+        memory=True,
+        process="sequential"
+    )
+
+    # Start execution
+    result = agents.start()
+    ```
+  </Tab>
+  <Tab title="No Code">
+```yaml
+framework: praisonai
+process: sequential
+memory: true
+roles:
+  researcher:
+    backstory: Expert in market research and data analysis.
+    goal: Research and analyze market trends
+    role: Research Analyst
+    tools:
+      - duckduckgo
+    tasks:
+      research_task:
+        description: Research current market trends.
+        expected_output: Detailed market analysis.
+
+  writer:
+    backstory: Expert in technical writing and report creation.
+    goal: Create comprehensive market reports
+    role: Report Writer
+    tasks:
+      report_task:
+        description: Create a market report based on research.
+        expected_output: Comprehensive market report.
+```
+  </Tab>
+</Tabs>
+
+### Configuration Options
+
+```python
+# Create an agent with memory configuration
+agent = Agent(
+    role="Research Analyst",
+    goal="Research and retain information",
+    backstory="Expert in research and analysis",
+    tools=[duckduckgo],
+    verbose=True,  # Enable detailed logging
+    llm="gpt-4o"  # Language model to use
+)
+
+# Create agents with memory options
+agents = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task],
+    memory=True,  # Enable memory
+    memory_config={
+        "provider": "rag",  # Use RAG for semantic search
+        "use_embedding": True,  # Enable embeddings for better search
+        "short_db": ".praison/short_term.db",  # Path for short-term memory
+        "long_db": ".praison/long_term.db",    # Path for long-term memory
+        "rag_db_path": ".praison/chroma_db"    # Path for vector database
+    }
+)
+```
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Memory Issues" icon="triangle-exclamation">
+    If memory isn't working as expected:
+    - Check memory configuration
+    - Enable verbose mode for debugging
+    - Verify memory provider settings
+  </Card>
+
+  <Card title="Context Flow" icon="code">
+    If context isn't being maintained:
+    - Review task dependencies
+    - Check memory configuration
+    - Verify agent communication
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="AutoAgents" icon="robot" href="../features/autoagents">
+    Learn about automatically created and managed AI agents
+  </Card>
+  <Card title="Mini Agents" icon="microchip" href="../features/mini">
+    Explore lightweight, focused AI agents
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal results, configure memory settings based on your specific use case requirements and expected interaction patterns.
+</Note>
+
+### Memory Configuration Options
+
+The memory system in PraisonAI supports various configuration options to customize how agents store and retrieve information:
+
+```python
+memory_config = {
+    # Memory Provider
+    "provider": "rag",        # Options: "rag", "mem0", "none"
+    "use_embedding": True,    # Enable semantic search with embeddings
+    
+    # Storage Paths
+    "short_db": ".praison/short_term.db",  # Short-term memory SQLite DB
+    "long_db": ".praison/long_term.db",    # Long-term memory SQLite DB
+    "rag_db_path": ".praison/chroma_db",   # Vector database path
+    
+    # Memory Settings
+    "ttl": 3600,             # Time to live for memory items (in seconds)
+    
+    # Optional Mem0 Config (if using mem0 provider)
+    "config": {
+        "api_key": "...",    # Mem0 API key
+        "org_id": "...",     # Organization ID
+        "project_id": "..."  # Project ID
+    }
+}
+
+# Create agents with memory configuration
+agents = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task],
+    memory=True,
+    memory_config=memory_config
+)
+```
+
+### Memory Types
+
+PraisonAI's memory system includes several types of memory:
+
+<CardGroup cols={2}>
+  <Card title="Short-term Memory" icon="bolt">
+    - Temporary storage for current context
+    - Automatically cleared between sessions
+    - Fast access for immediate task context
+  </Card>
+  <Card title="Long-term Memory" icon="database">
+    - Persistent storage for important information
+    - Semantic search capabilities with RAG
+    - Quality-based storage decisions
+  </Card>
+  <Card title="Entity Memory" icon="diagram-project">
+    - Store information about specific entities
+    - Track relationships and attributes
+    - Specialized search for entity information
+  </Card>
+  <Card title="User Memory" icon="user">
+    - Store user-specific information
+    - Personalized context for each user
+    - Persistent across sessions
+  </Card>
+</CardGroup>
+
+### Memory Quality Control
+
+PraisonAI includes built-in quality control for memory storage:
+
+```python
+# Example of storing with quality metrics
+agents.memory.store_long_term(
+    text="Important information to remember",
+    metadata={
+        "task_id": "task_123",
+        "agent": "research_agent"
+    },
+    completeness=0.9,    # How complete is the information
+    relevance=0.85,      # How relevant to the task
+    clarity=0.95,        # How clear and well-structured
+    accuracy=0.9,        # How accurate is the information
+    weights={            # Custom weights for quality score
+        "completeness": 0.3,
+        "relevance": 0.3,
+        "clarity": 0.2,
+        "accuracy": 0.2
+    }
+)
+
+# Search with quality filter
+results = agents.memory.search_long_term(
+    query="search query",
+    min_quality=0.8,     # Only return high-quality matches
+    limit=5              # Maximum number of results
+)
+```

docs/concepts/process.mdx

@@ -10,96 +10,209 @@ Process types in PraisonAI define how tasks are executed and how agents collabor
 
 ## Process Types Overview
 
-Three types of processes are implemented in PraisonAI:
+<CardGroup cols={3}>
+  <Card
+    title="Sequential Process"
+    icon="arrow-right"
+    href="/sequential-process"
+  >
+    Linear task execution in a predefined order
+  </Card>
+  <Card
+    title="Hierarchical Process"
+    icon="sitemap"
+    href="/hierarchical-process"
+  >
+    Manager-coordinated task execution with dynamic assignment
+  </Card>
+  <Card
+    title="Workflow Process"
+    icon="diagram-project"
+    href="/workflow-process"
+  >
+    Complex task flows with conditional execution and state management
+  </Card>
+</CardGroup>
 
-<Frame>
-  <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
-    <div className="p-4 border rounded-lg bg-white dark:bg-gray-800">
-      <div className="flex items-center mb-4">
-        <div className="p-2 bg-blue-100 dark:bg-blue-900 rounded-lg">
-          <svg className="w-6 h-6 text-blue-600 dark:text-blue-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 6h16M4 12h16m-7 6h7" />
-          </svg>
-        </div>
-        <h3 className="ml-3 text-lg font-semibold">Sequential Process</h3>
-      </div>
-      <p>Linear task execution in a predefined order</p>
-    </div>
+## Sequential Process
 
-    <div className="p-4 border rounded-lg bg-white dark:bg-gray-800">
-      <div className="flex items-center mb-4">
-        <div className="p-2 bg-green-100 dark:bg-green-900 rounded-lg">
-          <svg className="w-6 h-6 text-green-600 dark:text-green-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 6V4m0 2a2 2 0 100 4m0-4a2 2 0 110 4m-6 8a2 2 0 100-4m0 4a2 2 0 110-4m0 4v2m0-6V4m6 6v10m6-2a2 2 0 100-4m0 4a2 2 0 110-4m0 4v2m0-6V4" />
-          </svg>
-        </div>
-        <h3 className="ml-3 text-lg font-semibold">Hierarchical Process</h3>
-      </div>
-      <p>Manager-coordinated task execution with dynamic assignment</p>
-    </div>
-
-    <div className="p-4 border rounded-lg bg-white dark:bg-gray-800">
-      <div className="flex items-center mb-4">
-        <div className="p-2 bg-purple-100 dark:bg-purple-900 rounded-lg">
-          <svg className="w-6 h-6 text-purple-600 dark:text-purple-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6a2 2 0 002 2h2a2 2 0 002-2zm0 0V9a2 2 0 012-2h2a2 2 0 012 2v10m-6 0a2 2 0 002 2h2a2 2 0 002-2m0 0V5a2 2 0 012-2h2a2 2 0 012 2v14a2 2 0 01-2 2h-2a2 2 0 01-2-2z" />
-          </svg>
-        </div>
-        <h3 className="ml-3 text-lg font-semibold">Workflow Process</h3>
-      </div>
-      <p>Complex task flows with conditional execution and state management</p>
-    </div>
-  </div>
-</Frame>
-
-### Sequential Process
 The simplest form of task execution where tasks are performed one after another.
 
-<Frame>
-  <div className="p-4 bg-white dark:bg-gray-800 rounded-lg">
-    #### Characteristics
-    - Linear execution flow
-    - Predictable order
-    - Simple dependency management
-    - Direct task progression
+<Card>
+  ### Characteristics
+  - Linear execution flow
+  - Predictable order
+  - Simple dependency management
+  - Direct task progression
 
-    #### Usage
-    ```python
-    agents = PraisonAIAgents(
-        agents=[agent1, agent2],
-        tasks=[task1, task2, task3],
-        process="sequential"
-    )
-    ```
-  </div>
-</Frame>
+  ### Usage
+  ```python
+  agents = PraisonAIAgents(
+      agents=[agent1, agent2],
+      tasks=[task1, task2, task3],
+      process="sequential"
+  )
+  ```
+</Card>
+
+## Hierarchical Process
 
-### Hierarchical Process
 Uses a manager agent to coordinate task execution and agent assignments.
 
-<Frame>
-  <div className="p-4 bg-white dark:bg-gray-800 rounded-lg">
-    #### Characteristics
-    - Manager-driven coordination
-    - Dynamic task assignment
-    - Flexible execution order
-    - Intelligent resource allocation
+<Card>
+  ### Characteristics
+  - Manager-driven coordination
+  - Dynamic task assignment
+  - Flexible execution order
+  - Intelligent resource allocation
 
-    #### Configuration
-    ```python
-    agents = PraisonAIAgents(
-        agents=[manager_agent, worker_agent1, worker_agent2],
-        tasks=[task1, task2],
-        process="hierarchical",
-        manager_llm="gpt-4o"
-    )
-    ```
-  </div>
-</Frame>
+  ### Configuration
+  ```python
+  agents = PraisonAIAgents(
+      agents=[manager_agent, worker_agent1, worker_agent2],
+      tasks=[task1, task2],
+      process="hierarchical",
+      manager_llm="gpt-4o"
+  )
+  ```
+</Card>
+
+## Workflow Process
 
-### Workflow Process
 Advanced process type supporting complex task relationships and conditional execution.
 
+<Card>
+  ### Features
+  - Task dependencies
+  - Conditional branching
+  - Loop handling
+  - Context sharing
+  - State management
+
+  ### Implementation
+  ```python
+  task_workflow = {
+      "start_task": {
+          "next": ["decision_task"],
+          "type": "task"
+      },
+      "decision_task": {
+          "type": "decision",
+          "conditions": {
+              "success": ["process_task"],
+              "failure": ["error_task"]
+          }
+      }
+  }
+  ```
+</Card>
+
+## Getting Started
+
+<Steps>
+  <Step title="Install PraisonAI">
+    Install the core package:
+    ```bash Terminal
+    pip install praisonaiagents
+    ```
+  </Step>
+
+  <Step title="Configure Environment">
+    ```bash Terminal
+    export OPENAI_API_KEY=your_openai_key
+    ```
+    Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
+    Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
+  </Step>
+
+  <Step title="Create Agent">
+    Create `app.py`:
+<CodeGroup>
+  ```python Single Agent Sequential Process
+  from praisonaiagents import Agent, Task, PraisonAIAgents
+
+  # Create an agent
+  researcher = Agent(
+      name="Researcher",
+      role="Senior Research Analyst",
+      goal="Uncover cutting-edge developments in AI",
+      backstory="You are an expert at a technology research group",
+      verbose=True,
+      llm="gpt-4o"
+  )
+
+  # Define a task
+  task = Task(
+      name="research_task",
+      description="Analyze 2024's AI advancements",
+      expected_output="A detailed report",
+      agent=researcher
+  )
+
+  # Run the agents
+  agents = PraisonAIAgents(
+      agents=[researcher],
+      tasks=[task],
+      verbose=False,
+      process="sequential"
+  )
+
+  result = agents.start()
+  ```
+
+  ```python Multiple Agents Hierarchical Process
+  from praisonaiagents import Agent, Task, PraisonAIAgents
+
+  # Create multiple agents 
+  researcher = Agent(
+      name="Researcher",
+      role="Senior Research Analyst",
+      goal="Uncover cutting-edge developments in AI",
+      backstory="You are an expert at a technology research group",
+      verbose=True,
+      llm="gpt-4o",
+      markdown=True
+  )
+
+  writer = Agent(
+      name="Writer",
+      role="Tech Content Strategist",
+      goal="Craft compelling content on tech advancements",
+      backstory="You are a content strategist",
+      llm="gpt-4o",
+      markdown=True
+  )
+
+  # Define multiple tasks
+  task1 = Task(
+      name="research_task",
+      description="Analyze 2024's AI advancements",
+      expected_output="A detailed report",
+      agent=researcher
+  )
+
+  task2 = Task(
+      name="writing_task",
+      description="Create a blog post about AI advancements",
+      expected_output="A blog post",
+      agent=writer
+  )
+
+  # Run with hierarchical process
+  agents = PraisonAIAgents(
+      agents=[researcher, writer],
+      tasks=[task1, task2],
+      verbose=False,
+      process="hierarchical",
+      manager_llm="gpt-4o"
+  )
+
+  result = agents.start()
+  ```
+</CodeGroup>
+  </Step>
+</Steps>
+<br /><br />
 <div className="relative w-full aspect-video">
   <iframe
     className="absolute top-0 left-0 w-full h-full"
@@ -111,110 +224,152 @@ Advanced process type supporting complex task relationships and conditional exec
 </div>
 <br />
 
-
-<Frame>
-  <div className="p-4 bg-white dark:bg-gray-800 rounded-lg">
-    #### Features
-    - Task dependencies
-    - Conditional branching
-    - Loop handling
-    - Context sharing
-    - State management
-
-    #### Implementation
-    ```python
-    task_workflow = {
-        "start_task": {
-            "next": ["decision_task"],
-            "type": "task"
-        },
-        "decision_task": {
-            "type": "decision",
-            "conditions": {
-                "success": ["process_task"],
-                "failure": ["error_task"]
-            }
-        }
-    }
-    ```
-  </div>
-</Frame>
-
 ## Advanced Features
 
-### State Management
-- Task state tracking
-- Context preservation
-- Data flow control
+<CardGroup cols={2}>
+  <Card title="State Management" icon="database" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Task State Tracking">
+        Monitor and manage the progress of each task in real-time
+      </Accordion>
+      <Accordion title="Context Preservation">
+        Maintain important information across different stages of execution
+      </Accordion>
+      <Accordion title="Data Flow Control">
+        Manage how data moves between tasks and agents efficiently
+      </Accordion>
+    </AccordionGroup>
+  </Card>
 
-### Error Handling
-- Graceful failure recovery
-- Alternative path execution
-- Error reporting
+  <Card title="Error Handling" icon="shield-check" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Graceful Recovery">
+        Automatically handle failures and continue execution
+      </Accordion>
+      <Accordion title="Alternative Paths">
+        Switch to backup plans when primary execution fails
+      </Accordion>
+      <Accordion title="Error Reporting">
+        Detailed error logs and diagnostic information
+      </Accordion>
+    </AccordionGroup>
+  </Card>
 
-### Monitoring
-- Progress tracking
-- Performance metrics
-- Resource utilization
+  <Card title="Monitoring" icon="chart-line" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Progress Tracking">
+        Real-time visibility into task completion status
+      </Accordion>
+      <Accordion title="Performance Metrics">
+        Measure execution time and resource efficiency
+      </Accordion>
+      <Accordion title="Resource Usage">
+        Monitor system resource utilization
+      </Accordion>
+    </AccordionGroup>
+  </Card>
 
-### Integration
-- External system coordination
-- API synchronization
-- Event handling 
+  <Card title="Integration" icon="plug" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="External Systems">
+        Connect with other services and platforms
+      </Accordion>
+      <Accordion title="API Sync">
+        Maintain data consistency across systems
+      </Accordion>
+      <Accordion title="Event Handling">
+        React to system and external events
+      </Accordion>
+    </AccordionGroup>
+  </Card>
+</CardGroup>
 
-## Async Process Execution
-All process types (sequential, workflow, hierarchical) support async execution through async generators. This enables efficient handling of async tasks and parallel processing.
+## Async Processing
 
-### Async Process Methods
-- `asequential`: Async version of sequential process
-- `aworkflow`: Async version of workflow process
-- `ahierarchical`: Async version of hierarchical process
+<Note>
+All process types support asynchronous execution through async generators, enabling efficient parallel processing and non-blocking operations.
+</Note>
 
-### Example Usage:
+### Core Async Methods
 
-```python
-import asyncio
-from praisonaiagents import Agent, Task, PraisonAIAgents
+<CardGroup cols={3}>
+  <Card title="asequential" icon="arrow-right">
+    Async version of sequential process for non-blocking linear execution
+  </Card>
+  <Card title="aworkflow" icon="diagram-project">
+    Async workflow process for complex parallel task execution
+  </Card>
+  <Card title="ahierarchical" icon="sitemap">
+    Async hierarchical process for distributed task management
+  </Card>
+</CardGroup>
 
-async def main():
-    # Create agents and tasks
-    agents = [async_agent1, async_agent2]
-    tasks = [async_task1, async_task2]
+### Process-Specific Features
 
-    # Initialize PraisonAIAgents with async workflow
-    agents = PraisonAIAgents(
-        agents=agents,
-        tasks=tasks,
-        process="workflow"  # or "sequential" or "hierarchical"
-    )
+<Tabs>
+  <Tab title="Sequential Process">
+    <Card>
+      - Tasks execute in order but don't block
+      - Maintains sequence while allowing async operations
+      - Perfect for I/O-heavy tasks
+      ```python
+      async def main():
+          agents = PraisonAIAgents(
+              process="sequential",
+              async_mode=True
+          )
+          await agents.astart()
+      ```
+    </Card>
+  </Tab>
+  
+  <Tab title="Workflow Process">
+    <Card>
+      - Parallel execution of independent tasks
+      - Async branching and merging
+      - Dynamic task scheduling based on conditions
+      ```python
+      async def main():
+          agents = PraisonAIAgents(
+              process="workflow",
+              async_mode=True,
+              parallel_tasks=True
+          )
+          await agents.astart()
+      ```
+    </Card>
+  </Tab>
+  
+  <Tab title="Hierarchical Process">
+    <Card>
+      - Async manager delegation
+      - Parallel subtask execution
+      - Dynamic worker assignment
+      ```python
+      async def main():
+          agents = PraisonAIAgents(
+              process="hierarchical",
+              async_mode=True,
+              dynamic_assignment=True
+          )
+          await agents.astart()
+      ```
+    </Card>
+  </Tab>
+</Tabs>
 
-    # Start async execution
-    result = await agents.astart()
-    print(result)
+### Key Benefits
 
-# Run the async workflow
-asyncio.run(main())
-```
-
-### Async Process Features:
-- Parallel task execution in workflow
-- Async task delegation in hierarchical process
-- Non-blocking task execution
-- Efficient resource utilization
-- Mixed sync/async task support
-
-### Process-Specific Async Behavior:
-1. **Sequential Process**:
-   - Tasks are executed in order
-   - Async tasks don't block other tasks
-   - Maintains sequential order while allowing async execution
-
-2. **Workflow Process**:
-   - Parallel execution of independent tasks
-   - Async branching and merging
-   - Dynamic task scheduling
-
-3. **Hierarchical Process**:
-   - Async manager delegation
-   - Parallel subtask execution
-   - Dynamic task assignment 
+<CardGroup cols={2}>
+  <Card title="Performance" icon="bolt">
+    - Efficient resource utilization
+    - Reduced waiting time
+    - Better throughput
+  </Card>
+  
+  <Card title="Flexibility" icon="puzzle-piece">
+    - Mix sync and async tasks
+    - Adaptable execution patterns
+    - Easy scaling
+  </Card>
+</CardGroup>

docs/concepts/tasks.mdx

@@ -8,114 +8,6 @@ icon: "list-check"
   Tasks are the fundamental units of work in PraisonAI, defining what needs to be done, how it should be done, and who should do it.
 </Note>
 
-# Understanding Tasks
-
-<Frame>
-  <div className="p-6 bg-white dark:bg-gray-800 rounded-lg">
-    <div className="grid grid-cols-1 gap-6">
-      {/* Task Flow Steps */}
-      <div className="flex justify-between items-center">
-        {/* Task Definition */}
-        <div className="flex-1 p-4 border-2 border-blue-500 rounded-lg text-center">
-          <div className="flex items-center justify-center mb-2">
-            <div className="p-2 bg-blue-100 dark:bg-blue-900 rounded-full">
-              <svg className="w-6 h-6 text-blue-600 dark:text-blue-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2" />
-              </svg>
-            </div>
-          </div>
-          <h4 className="font-semibold">Task Definition</h4>
-          <p className="text-sm mt-1">Description & Requirements</p>
-        </div>
-
-        {/* Arrow 1 */}
-        <div className="flex-none px-4">
-          <svg className="w-6 h-6 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M17 8l4 4m0 0l-4 4m4-4H3" />
-          </svg>
-        </div>
-
-        {/* Agent Assignment */}
-        <div className="flex-1 p-4 border-2 border-green-500 rounded-lg text-center">
-          <div className="flex items-center justify-center mb-2">
-            <div className="p-2 bg-green-100 dark:bg-green-900 rounded-full">
-              <svg className="w-6 h-6 text-green-600 dark:text-green-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z" />
-              </svg>
-            </div>
-          </div>
-          <h4 className="font-semibold">Agent Assignment</h4>
-          <p className="text-sm mt-1">Matching & Delegation</p>
-        </div>
-
-        {/* Arrow 2 */}
-        <div className="flex-none px-4">
-          <svg className="w-6 h-6 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M17 8l4 4m0 0l-4 4m4-4H3" />
-          </svg>
-        </div>
-
-        {/* Execution */}
-        <div className="flex-1 p-4 border-2 border-purple-500 rounded-lg text-center">
-          <div className="flex items-center justify-center mb-2">
-            <div className="p-2 bg-purple-100 dark:bg-purple-900 rounded-full">
-              <svg className="w-6 h-6 text-purple-600 dark:text-purple-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M13 10V3L4 14h7v7l9-11h-7z" />
-              </svg>
-            </div>
-          </div>
-          <h4 className="font-semibold">Execution</h4>
-          <p className="text-sm mt-1">Processing & Tools</p>
-        </div>
-
-        {/* Arrow 3 */}
-        <div className="flex-none px-4">
-          <svg className="w-6 h-6 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M17 8l4 4m0 0l-4 4m4-4H3" />
-          </svg>
-        </div>
-
-        {/* Output */}
-        <div className="flex-1 p-4 border-2 border-yellow-500 rounded-lg text-center">
-          <div className="flex items-center justify-center mb-2">
-            <div className="p-2 bg-yellow-100 dark:bg-yellow-900 rounded-full">
-              <svg className="w-6 h-6 text-yellow-600 dark:text-yellow-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 9l3 3-3 3m5 0h3M5 20h14a2 2 0 002-2V6a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z" />
-              </svg>
-            </div>
-          </div>
-          <h4 className="font-semibold">Output</h4>
-          <p className="text-sm mt-1">Results & Validation</p>
-        </div>
-      </div>
-
-      {/* Task States */}
-      <div className="grid grid-cols-4 gap-4 mt-4">
-        <div className="p-3 border border-gray-200 rounded-lg bg-blue-50 dark:bg-blue-900">
-          <div className="flex items-center justify-center">
-            <span className="font-semibold">Pending</span>
-          </div>
-        </div>
-        <div className="p-3 border border-gray-200 rounded-lg bg-yellow-50 dark:bg-yellow-900">
-          <div className="flex items-center justify-center">
-            <span className="font-semibold">In Progress</span>
-          </div>
-        </div>
-        <div className="p-3 border border-gray-200 rounded-lg bg-green-50 dark:bg-green-900">
-          <div className="flex items-center justify-center">
-            <span className="font-semibold">Completed</span>
-          </div>
-        </div>
-        <div className="p-3 border border-gray-200 rounded-lg bg-red-50 dark:bg-red-900">
-          <div className="flex items-center justify-center">
-            <span className="font-semibold">Failed</span>
-          </div>
-        </div>
-      </div>
-    </div>
-  </div>
-</Frame>
-
 ## Core Components
 
 <CardGroup cols={2}>
@@ -155,6 +47,79 @@ icon: "list-check"
   ```
 </CodeGroup>
 
+# Understanding Tasks
+<br />
+```mermaid
+graph LR
+    %% Task Flow Steps
+    Start([▶ Start]) --> TaskDef
+    TaskDef --> AgentAssign
+    AgentAssign --> Exec
+    Exec --> Output([✓ Output])
+    
+    %% Define subgraphs for each step
+    subgraph TaskDef[" "]
+        TD_Icon[📋 Task Definition]
+        TD_Desc[Description & Requirements]
+        
+        TD_Icon --- TD_Desc
+        
+        style TD_Icon fill:#2D3047,stroke:#7C90A0,color:#fff
+        style TD_Desc fill:#5C80BC,stroke:#7C90A0,color:#fff
+    end
+    
+    subgraph AgentAssign[" "]
+        AA_Icon[🤖 Agent Assignment]
+        AA_Desc[Matching & Delegation]
+        
+        AA_Icon --- AA_Desc
+        
+        style AA_Icon fill:#2D3047,stroke:#7C90A0,color:#fff
+        style AA_Desc fill:#5C80BC,stroke:#7C90A0,color:#fff
+    end
+    
+    subgraph Exec[" "]
+        E_Icon[⚙️ Execution]
+        E_Desc[Processing & Tools]
+        
+        E_Icon --- E_Desc
+        
+        style E_Icon fill:#2D3047,stroke:#7C90A0,color:#fff
+        style E_Desc fill:#5C80BC,stroke:#7C90A0,color:#fff
+    end
+    
+    %% Styling for main elements
+    style Start fill:#2D3047,stroke:#7C90A0,color:#fff
+    style Output fill:#2D3047,stroke:#7C90A0,color:#fff
+    
+    %% Style for containers
+    style TaskDef fill:#1B1F3B,stroke:#7C90A0,color:#fff
+    style AgentAssign fill:#1B1F3B,stroke:#7C90A0,color:#fff
+    style Exec fill:#1B1F3B,stroke:#7C90A0,color:#fff
+    
+    %% Global styles
+    classDef default fill:#2D3047,stroke:#7C90A0,color:#fff
+    linkStyle default stroke:#7C90A0,stroke-width:2px
+```
+<br /><br />
+```mermaid
+graph LR
+    %% Task States
+    Pending([📥 Pending]) --> InProgress([⚡ In Progress])
+    InProgress --> Completed([✅ Completed])
+    InProgress --> Failed([❌ Failed])
+    
+    %% Styling
+    style Pending fill:#2D3047,stroke:#7C90A0,color:#fff
+    style InProgress fill:#5C80BC,stroke:#7C90A0,color:#fff
+    style Completed fill:#2D3047,stroke:#7C90A0,color:#fff
+    style Failed fill:#2D3047,stroke:#7C90A0,color:#fff
+    
+    %% Global styles
+    classDef default fill:#2D3047,stroke:#7C90A0,color:#fff
+    linkStyle default stroke:#7C90A0,stroke-width:2px
+```
+
 ## Task Types
 
 <Steps>
@@ -223,17 +188,300 @@ task_b = Task(
   </Card>
 </CardGroup>
 
+## Getting Started
+
+<Steps>
+
+  <Step title="Install PraisonAI">
+    Install the core package:
+    ```bash Terminal
+    pip install praisonaiagents
+    ```
+  </Step>
+
+  <Step title="Configure Environment">
+    ```bash Terminal
+    export OPENAI_API_KEY=your_openai_key
+    ```
+    Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
+    Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
+  </Step>
+
+  <Step title="Create Agent">
+    Create `app.py`:
+<CodeGroup>
+  ```python Single Agent
+  from praisonaiagents import Agent, Task, PraisonAIAgents
+
+  # Create an agent
+  researcher = Agent(
+      name="Researcher",
+      role="Senior Research Analyst",
+      goal="Uncover cutting-edge developments in AI",
+      backstory="You are an expert at a technology research group",
+      verbose=True,
+      llm="gpt-4o"
+  )
+
+  # Define a task
+  task = Task(
+      name="research_task",
+      description="Analyze 2024's AI advancements",
+      expected_output="A detailed report",
+      agent=researcher
+  )
+
+  # Run the agents
+  agents = PraisonAIAgents(
+      agents=[researcher],
+      tasks=[task],
+      verbose=False
+  )
+
+  result = agents.start()
+  ```
+
+  ```python Multiple Agents
+  from praisonaiagents import Agent, Task, PraisonAIAgents
+
+  # Create multiple agents
+  researcher = Agent(
+      name="Researcher",
+      role="Senior Research Analyst",
+      goal="Uncover cutting-edge developments in AI",
+      backstory="You are an expert at a technology research group",
+      verbose=True,
+      llm="gpt-4o",
+      markdown=True
+  )
+
+  writer = Agent(
+      name="Writer",
+      role="Tech Content Strategist",
+      goal="Craft compelling content on tech advancements",
+      backstory="You are a content strategist",
+      llm="gpt-4o",
+      markdown=True
+  )
+
+  # Define multiple tasks
+  task1 = Task(
+      name="research_task",
+      description="Analyze 2024's AI advancements",
+      expected_output="A detailed report",
+      agent=researcher
+  )
+
+  task2 = Task(
+      name="writing_task",
+      description="Create a blog post about AI advancements",
+      expected_output="A blog post",
+      agent=writer
+  )
+
+  # Run with hierarchical process
+  agents = PraisonAIAgents(
+      agents=[researcher, writer],
+      tasks=[task1, task2],
+      verbose=False,
+      process="hierarchical",
+      manager_llm="gpt-4o"
+  )
+
+  result = agents.start()
+  ```
+</CodeGroup>
+  </Step>
+</Steps>
+
 ## Best Practices
 
-<Tip>
-  Design tasks to be atomic and focused. Each task should have a single, clear responsibility.
-</Tip>
+<Note>
+Design tasks to be atomic and focused. Each task should have a single, clear responsibility.
+</Note>
 
-1. Clear task descriptions
-2. Well-defined success criteria
-3. Appropriate tool selection
-4. Error handling consideration
-5. Resource management
+<CardGroup cols={2}>
+  <Card title="Task Design Principles" icon="compass-drafting" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Clear Task Descriptions">
+        Write precise, unambiguous task descriptions that clearly state the task's purpose and requirements.
+        ```python
+        task = Task(
+            description=(
+                "Analyze Q4 2024 sales data "
+                "and generate growth metrics"
+            ),
+            expected_output="Sales growth report"
+        )
+        ```
+      </Accordion>
+
+      <Accordion title="Success Criteria">
+        Define measurable success criteria to ensure task completion can be properly evaluated.
+        ```python
+        task = Task(
+            success_criteria={
+                "format": "markdown",
+                "metrics": [
+                    "growth_rate",
+                    "revenue_change"
+                ],
+                "min_confidence": 0.95
+            }
+        )
+        ```
+      </Accordion>
+
+      <Accordion title="Task Dependencies">
+        Specify any dependencies or prerequisites for the task.
+        ```python
+        task = Task(
+            description="Generate final report",
+            dependencies=[
+                data_collection_task,
+                analysis_task
+            ],
+            wait_for_dependencies=True
+        )
+        ```
+      </Accordion>
+    </AccordionGroup>
+  </Card>
+
+  <Card title="Resource Management" icon="server" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Tool Selection">
+        Choose appropriate tools that match your task's requirements.
+        ```python
+        task = Task(
+            tools=[
+                DataAnalyzer(),
+                ReportGenerator(),
+                MetricsCalculator()
+            ],
+            tool_config={
+                "timeout": 30,
+                "retry": True
+            }
+        )
+        ```
+      </Accordion>
+
+      <Accordion title="Error Handling">
+        Implement comprehensive error management strategies.
+        ```python
+        task = Task(
+            error_strategy="retry",
+            max_retries=3,
+            fallback_handler=handler,
+            error_callbacks=[
+                log_error,
+                notify_admin
+            ]
+        )
+        ```
+      </Accordion>
+
+      <Accordion title="Resource Limits">
+        Set appropriate resource constraints for optimal performance.
+        ```python
+        task = Task(
+            memory_limit="2GB",
+            timeout=300,
+            max_concurrent=5,
+            cpu_priority="high",
+            auto_scale=True
+        )
+        ```
+      </Accordion>
+
+      <Accordion title="Performance Monitoring">
+        Configure monitoring and logging for task execution.
+        ```python
+        task = Task(
+            monitoring={
+                "metrics": ["duration", "memory", "cpu"],
+                "log_level": "INFO",
+                "trace_enabled": True,
+                "alert_threshold": 0.85
+            }
+        )
+        ```
+      </Accordion>
+    </AccordionGroup>
+  </Card>
+</CardGroup>
+
+## Async Task Execution
+
+<CardGroup cols={1}>
+  <Card title="Async Task Features" icon="bolt" iconType="solid">
+    <Tabs>
+      <Tab title="Basic Configuration">
+        ```python
+        async_task = Task(
+            description="Perform async operation",
+            expected_output="Async result",
+            agent=async_agent,
+            async_execution=True,  # Enable async execution
+            callback=async_callback  # Optional async callback
+        )
+        ```
+        - Enable async execution with `async_execution=True`
+        - Perfect for I/O-heavy operations
+        - Supports parallel task execution
+      </Tab>
+      
+      <Tab title="Async Callbacks">
+        ```python
+        async def async_callback(output: TaskOutput):
+            await asyncio.sleep(1)  # Simulate async operation
+            print(f"Processed output: {output.raw}")
+
+        task = Task(
+            description="Task with async callback",
+            expected_output="Result",
+            agent=agent,
+            async_execution=True,
+            callback=async_callback
+        )
+        ```
+        - Support for async callbacks
+        - Process results asynchronously
+        - Handle task completion events
+      </Tab>
+      
+      <Tab title="Mixed Execution">
+        ```python
+        # Create mixed task types
+        sync_task = Task(
+            description="Synchronous operation",
+            async_execution=False
+        )
+
+        async_task = Task(
+            description="Asynchronous operation",
+            async_execution=True
+        )
+
+        # Run with mixed execution
+        agents = PraisonAIAgents(
+            agents=[sync_agent, async_agent],
+            tasks=[sync_task, async_task]
+        )
+        result = await agents.astart()
+        ```
+        - Mix sync and async tasks
+        - Flexible execution patterns
+        - Optimal resource utilization
+      </Tab>
+    </Tabs>
+  </Card>
+</CardGroup>
+
+<Tip>
+**Pro Tip**: Use async execution for tasks that involve I/O operations (like API calls or file operations) to improve overall performance. Keep CPU-intensive tasks synchronous.
+</Tip>
 
 ## Next Steps
 
@@ -252,66 +500,4 @@ task_b = Task(
   >
     Explore the complete Task API documentation
   </Card>
-</CardGroup>
-
-## Async Task Execution
-Tasks can be executed asynchronously by setting `async_execution=True`. This is particularly useful for tasks that involve I/O operations or when you want to run multiple tasks in parallel.
-
-### Async Task Configuration
-```python
-async_task = Task(
-    description="Perform async operation",
-    expected_output="Async result",
-    agent=async_agent,
-    async_execution=True,  # Enable async execution
-    callback=async_callback  # Optional async callback
-)
-```
-
-### Async Callbacks
-Tasks support both synchronous and asynchronous callbacks:
-
-```python
-async def async_callback(output: TaskOutput):
-    await asyncio.sleep(1)  # Simulate async operation
-    print(f"Processed output: {output.raw}")
-
-# Task with async callback
-task = Task(
-    description="Task with async callback",
-    expected_output="Result",
-    agent=agent,
-    async_execution=True,
-    callback=async_callback
-)
-```
-
-### Mixing Sync and Async Tasks
-You can mix synchronous and asynchronous tasks in the same workflow:
-
-```python
-# Sync task
-sync_task = Task(
-    description="Synchronous operation",
-    expected_output="Sync result",
-    agent=sync_agent,
-    async_execution=False
-)
-
-# Async task
-async_task = Task(
-    description="Asynchronous operation",
-    expected_output="Async result",
-    agent=async_agent,
-    async_execution=True
-)
-
-# Create agents with mixed tasks
-agents = PraisonAIAgents(
-    agents=[sync_agent, async_agent],
-    tasks=[sync_task, async_task]
-)
-
-# Run asynchronously
-result = await agents.astart()
-``` 
+</CardGroup>

docs/concepts/tools.mdx

@@ -8,48 +8,6 @@ icon: "screwdriver-wrench"
 
 Tools in PraisonAI are functions that agents can use to interact with external systems, perform computations, or access data. They extend the capabilities of agents beyond just language processing.
 
-## Tools Overview
-
-<Frame>
-  <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
-    <div className="p-4 border rounded-lg bg-white dark:bg-gray-800">
-      <div className="flex items-center mb-4">
-        <div className="p-2 bg-blue-100 dark:bg-blue-900 rounded-lg">
-          <svg className="w-6 h-6 text-blue-600 dark:text-blue-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z" />
-          </svg>
-        </div>
-        <h3 className="ml-3 text-lg font-semibold">Search Tools</h3>
-      </div>
-      <p>Tools for searching and retrieving information from various sources</p>
-    </div>
-
-    <div className="p-4 border rounded-lg bg-white dark:bg-gray-800">
-      <div className="flex items-center mb-4">
-        <div className="p-2 bg-green-100 dark:bg-green-900 rounded-lg">
-          <svg className="w-6 h-6 text-green-600 dark:text-green-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 7v8a2 2 0 002 2h6M8 7V5a2 2 0 012-2h4.586a1 1 0 01.707.293l4.414 4.414a1 1 0 01.293.707V15a2 2 0 01-2 2h-2M8 7H6a2 2 0 00-2 2v10a2 2 0 002 2h8a2 2 0 002-2v-2" />
-          </svg>
-        </div>
-        <h3 className="ml-3 text-lg font-semibold">File Tools</h3>
-      </div>
-      <p>Tools for reading, writing, and manipulating files</p>
-    </div>
-
-    <div className="p-4 border rounded-lg bg-white dark:bg-gray-800">
-      <div className="flex items-center mb-4">
-        <div className="p-2 bg-purple-100 dark:bg-purple-900 rounded-lg">
-          <svg className="w-6 h-6 text-purple-600 dark:text-purple-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M3 6l3 1m0 0l-3 9a5.002 5.002 0 006.001 0M6 7l3 9M6 7l6-2m6 2l3-1m-3 1l-3 9a5.002 5.002 0 006.001 0M18 7l3 9m-3-9l-6-2m0-2v2m0 16V5m0 16H9m3 0h3" />
-          </svg>
-        </div>
-        <h3 className="ml-3 text-lg font-semibold">API Tools</h3>
-      </div>
-      <p>Tools for interacting with external APIs and services</p>
-    </div>
-  </div>
-</Frame>
-
 ## Creating Custom Tool
 <Steps>
 <Step>
@@ -99,237 +57,554 @@ Assign the tool to an agent
 </Card>
 
 ## Implementing Tools Full Code Example
+<Tabs>
 
-Tools are implemented as Python functions with type hints and docstrings. Here's a complete example:
+<Tab title="Code">
+<Steps>
 
+  <Step title="Install PraisonAI">
+Install the core package:
+```bash Terminal
+pip install praisonaiagents duckduckgo-search
+```
+  </Step>
 
-    ```python
-    from praisonaiagents import Agent, Task, PraisonAIAgents
-    from duckduckgo_search import DDGS
-    from typing import List, Dict
+  <Step title="Configure Environment">
+  ```bash Terminal
+  export OPENAI_API_KEY=your_openai_key
+  ```
+  Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
+  Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
+  </Step>
 
-    # 1. Tool Implementation
-    def internet_search_tool(query: str) -> List[Dict]:
-        """
-        Perform Internet Search using DuckDuckGo
+  <Step title="Create Agent with Tool">
+    Create `app.py`
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from duckduckgo_search import DDGS
+from typing import List, Dict
+
+# 1. Tool Implementation
+def internet_search_tool(query: str) -> List[Dict]:
+    """
+    Perform Internet Search using DuckDuckGo
+    
+    Args:
+        query (str): The search query string
         
-        Args:
-            query (str): The search query string
-            
-        Returns:
-            List[Dict]: List of search results containing title, URL, and snippet
-        """
-        results = []
-        ddgs = DDGS()
-        for result in ddgs.text(keywords=query, max_results=5):
-            results.append({
-                "title": result.get("title", ""),
-                "url": result.get("href", ""),
-                "snippet": result.get("body", "")
-            })
-        return results
+    Returns:
+        List[Dict]: List of search results containing title, URL, and snippet
+    """
+    results = []
+    ddgs = DDGS()
+    for result in ddgs.text(keywords=query, max_results=5):
+        results.append({
+            "title": result.get("title", ""),
+            "url": result.get("href", ""),
+            "snippet": result.get("body", "")
+        })
+    return results
 
-    # 2. Assign the tool to an agent
-    data_agent = Agent(
-        name="DataCollector",
-        role="Search Specialist",
-        goal="Perform internet searches to collect relevant information.",
-        backstory="Expert in finding and organising internet data.",
-        tools=[internet_search_tool],
-        self_reflect=False
-    )
+# 2. Assign the tool to an agent
+data_agent = Agent(
+    name="DataCollector",
+    role="Search Specialist",
+    goal="Perform internet searches to collect relevant information.",
+    backstory="Expert in finding and organising internet data.",
+    tools=[internet_search_tool],
+    self_reflect=False
+)
 
-    # 3. Task Definition
-    collect_task = Task(
-        description="Perform an internet search using the query: 'AI job trends in 2024'. Return results as a list of title, URL, and snippet.",
-        expected_output="List of search results with titles, URLs, and snippets.",
-        agent=data_agent,
-        name="collect_data",
-    )
+# 3. Task Definition
+collect_task = Task(
+    description="Perform an internet search using the query: 'AI job trends in 2024'. Return results as a list of title, URL, and snippet.",
+    expected_output="List of search results with titles, URLs, and snippets.",
+    agent=data_agent,
+    name="collect_data",
+)
 
-    # 4. Start Agents
-    agents = PraisonAIAgents(
-        agents=[data_agent],
-        tasks=[collect_task],
-        process="sequential"
-    )
+# 4. Start Agents
+agents = PraisonAIAgents(
+    agents=[data_agent],
+    tasks=[collect_task],
+    process="sequential"
+)
 
-    agents.start()
-    ```
+agents.start()
+```
+  </Step>
 
+  <Step title="Start Agents">
+    Execute your script:
+```bash Terminal
+python app.py
+```
+  </Step>
+</Steps>
 
+</Tab>
+<Tab title="No Code">
+<Steps>
+<Step title="Install PraisonAI">
+Install the core package and duckduckgo_search package:
+```bash Terminal
+pip install praisonai duckduckgo_search
+```
+</Step>
+<Step title="Create Custom Tool">
+<Info>
+To add additional tools/features you need some coding which can be generated using ChatGPT or any LLM
+</Info>
+Create a new file `tools.py` with the following content:
+```python
+from duckduckgo_search import DDGS
+from typing import List, Dict
 
+# 1. Tool
+def internet_search_tool(query: str) -> List[Dict]:
+    """
+    Perform Internet Search
+    """
+    results = []
+    ddgs = DDGS()
+    for result in ddgs.text(keywords=query, max_results=5):
+        results.append({
+            "title": result.get("title", ""),
+            "url": result.get("href", ""),
+            "snippet": result.get("body", "")
+        })
+    return results  
+```
+</Step>
+<Step title="Create Agent">
+
+Create a new file `agents.yaml` with the following content:
+```yaml
+framework: praisonai
+topic: create movie script about cat in mars
+roles:
+  scriptwriter:
+    backstory: Expert in dialogue and script structure, translating concepts into
+      scripts.
+    goal: Write a movie script about a cat in Mars
+    role: Scriptwriter
+    tools:
+      - internet_search_tool # <-- Tool assigned to Agent here
+    tasks:
+      scriptwriting_task:
+        description: Turn the story concept into a production-ready movie script,
+          including dialogue and scene details.
+        expected_output: Final movie script with dialogue and scene details.
+```
+</Step>
+
+<Step title="Start Agents">
+
+Execute your script:
+```bash Terminal
+praisonai agents.yaml
+```
+</Step>
+</Steps>
+</Tab>
+</Tabs>
+
+## In-build Tools in PraisonAI
+
+<CardGroup cols={2}>
+  <Card title="Search Tools" icon="magnifying-glass" href="/tools/search">
+    Tools for searching and retrieving information from various sources
+  </Card>
+  <Card title="Python Tools" icon="python" href="/tools/python_tools">
+    Essential Python utilities for data manipulation and scripting
+  </Card>
+  <Card title="Spider Tools" icon="spider" href="/tools/spider_tools">
+    Web crawling and scraping capabilities for data extraction
+  </Card>
+  <Card title="Arxiv Tools" icon="book" href="/tools/arxiv_tools">
+    Access and search academic papers from arXiv repository
+  </Card>
+  <Card title="Newspaper Tools" icon="newspaper" href="/tools/newspaper_tools">
+    Extract and parse content from news articles and websites
+  </Card>
+  <Card title="DuckDB Tools" icon="database" href="/tools/duckdb_tools">
+    Fast analytical SQL database operations and queries
+  </Card>
+  <Card title="DuckDuckGo Tools" icon="duck" href="/tools/duckduckgo_tools">
+    Web search functionality using DuckDuckGo's API
+  </Card>
+  <Card title="Calculator Tools" icon="calculator" href="/tools/calculator_tools">
+    Perform mathematical calculations and conversions
+  </Card>
+  <Card title="YAML Tools" icon="file-code" href="/tools/yaml_tools">
+    Parse and manipulate YAML format data
+  </Card>
+  <Card title="JSON Tools" icon="brackets-curly" href="/tools/json_tools">
+    Handle JSON data structures and operations
+  </Card>
+  <Card title="Pandas Tools" icon="table" href="/tools/pandas_tools">
+    Data analysis and manipulation using Pandas
+  </Card>
+  <Card title="YFinance Tools" icon="chart-line" href="/tools/yfinance_tools">
+    Fetch financial market data from Yahoo Finance
+  </Card>
+  <Card title="Shell Tools" icon="terminal" href="/tools/shell_tools">
+    Execute shell commands and system operations
+  </Card>
+  <Card title="Wikipedia Tools" icon="book-open" href="/tools/wikipedia_tools">
+    Access and search Wikipedia articles and data
+  </Card>
+  <Card title="XML Tools" icon="code" href="/tools/xml_tools">
+    Process and manipulate XML format data
+  </Card>
+  <Card title="File Tools" icon="file" href="/tools/file_tools">
+    File system operations and management utilities
+  </Card>
+  <Card title="Excel Tools" icon="file-excel" href="/tools/excel_tools">
+    Work with Excel spreadsheets and workbooks
+  </Card>
+  <Card title="CSV Tools" icon="file-csv" href="/tools/csv_tools">
+    Handle CSV file operations and transformations
+  </Card>
+</CardGroup>
+
+## Tools Overview
+
+<CardGroup cols={3}>
+  <Card
+    title="Search Tools"
+    icon="magnifying-glass"
+    iconType="solid"
+  >
+    Tools for searching and retrieving information from various sources
+  </Card>
+
+  <Card
+    title="File Tools"
+    icon="file"
+    iconType="solid"
+  >
+    Tools for reading, writing, and manipulating files
+  </Card>
+
+  <Card
+    title="API Tools"
+    icon="code"
+    iconType="solid"
+  >
+    Tools for interacting with external APIs and services
+  </Card>
+</CardGroup>
 
 ## Advanced Tool Features
 
 ### Tool Configuration
 <Frame>
-  <div className="p-4 bg-white dark:bg-gray-800 rounded-lg">
-    ```python
-    def configured_tool(
-        query: str,
-        max_results: int = 5,
-        timeout: int = 10
-    ) -> List[Dict]:
-        """
-        Example of a configurable tool
+```python
+def configured_tool(
+    query: str,
+    max_results: int = 5,
+    timeout: int = 10
+) -> List[Dict]:
+    """
+    Example of a configurable tool
+    
+    Args:
+        query (str): Search query
+        max_results (int): Maximum number of results
+        timeout (int): Request timeout in seconds
         
-        Args:
-            query (str): Search query
-            max_results (int): Maximum number of results
-            timeout (int): Request timeout in seconds
-            
-        Returns:
-            List[Dict]: Search results
-        """
-        # Tool implementation
-        pass
-    ```
-  </div>
+    Returns:
+        List[Dict]: Search results
+    """
+    # Tool implementation
+    pass
+```
 </Frame>
 
 ### Tool Chaining
 <Frame>
-  <div className="p-4 bg-white dark:bg-gray-800 rounded-lg">
-    ```python
-    def chain_tools(input_data: str) -> Dict:
-        """
-        Example of chaining multiple tools
+```python
+def chain_tools(input_data: str) -> Dict:
+    """
+    Example of chaining multiple tools
+    
+    Args:
+        input_data (str): Input data
         
-        Args:
-            input_data (str): Input data
-            
-        Returns:
-            Dict: Processed results
-        """
-        # 1. Search for data
-        search_results = internet_search_tool(input_data)
-        
-        # 2. Process results
-        processed_data = process_tool(search_results)
-        
-        # 3. Format output
-        return format_tool(processed_data)
-    ```
-  </div>
+    Returns:
+        Dict: Processed results
+    """
+    # 1. Search for data
+    search_results = internet_search_tool(input_data)
+    
+    # 2. Process results
+    processed_data = process_tool(search_results)
+    
+    # 3. Format output
+    return format_tool(processed_data)
+```
 </Frame>
 
 ### Tool Categories
 
-1. **Data Collection Tools**
-   - Web scraping
-   - API integration
-   - Database queries
-
-2. **Processing Tools**
-   - Data transformation
-   - Text analysis
-   - Image processing
-
-3. **Output Tools**
-   - File generation
-   - Report creation
-   - Data visualization
+<CardGroup cols={3}>
+  <Card title="Data Collection Tools">
+    - Web scraping
+    - API integration
+    - Database queries
+  </Card>
+  
+  <Card title="Processing Tools">
+    - Data transformation
+    - Text analysis
+    - Image processing
+  </Card>
+  
+  <Card title="Output Tools">
+    - File generation
+    - Report creation
+    - Data visualization
+  </Card>
+</CardGroup>
 
 ## Tool Integration
 
 ### Adding Tools to Agents
 <Frame>
-  <div className="p-4 bg-white dark:bg-gray-800 rounded-lg">
-    ```python
-    # Multiple tools
-    agent = Agent(
-        name="MultiTool Agent",
-        tools=[
-            internet_search_tool,
-            file_processing_tool,
-            api_integration_tool
-        ]
-    )
-    ```
-  </div>
+```python
+# Multiple tools
+agent = Agent(
+    name="MultiTool Agent",
+    tools=[
+        internet_search_tool,
+        file_processing_tool,
+        api_integration_tool
+    ]
+)
+```
 </Frame>
 
 ### Tool Dependencies
 <Frame>
-  <div className="p-4 bg-white dark:bg-gray-800 rounded-lg">
-    ```python
-    # Tool with dependencies
-    def advanced_tool(data: Dict) -> Dict:
-        """
-        Tool that depends on external libraries
+```python
+# Tool with dependencies
+def advanced_tool(data: Dict) -> Dict:
+    """
+    Tool that depends on external libraries
+    
+    Args:
+        data (Dict): Input data
         
-        Args:
-            data (Dict): Input data
-            
-        Returns:
-            Dict: Processed data
-        """
-        try:
-            import required_library
-            # Tool implementation
-            return processed_result
-        except ImportError:
-            raise Exception("Required library not installed")
-    ```
-  </div>
+    Returns:
+        Dict: Processed data
+    """
+    try:
+        import required_library
+        # Tool implementation
+        return processed_result
+    except ImportError:
+        raise Exception("Required library not installed")
+```
 </Frame>
 
 ## Tool Guidelines
-  <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-    <div className="p-4 border rounded-lg bg-white dark:bg-gray-800">
-      <h3 className="text-lg font-semibold mb-3">Best Practices</h3>
-      1. **Type Hints**
-         - Use Python type hints
-         - Define clear input/output types
-         - Document complex types
 
-      2. **Documentation**
-         - Write clear docstrings
-         - Explain parameters
-         - Provide usage examples
+<CardGroup cols={2}>
+  <Card title="Best Practices">
+    1. **Type Hints**
+       - Use Python type hints
+       - Define clear input/output types
+       - Document complex types
 
-      3. **Error Handling**
-         - Handle exceptions gracefully
-         - Return meaningful errors
-         - Validate inputs
-    </div>
+    2. **Documentation**
+       - Write clear docstrings
+       - Explain parameters
+       - Provide usage examples
 
-    <div className="p-4 border rounded-lg bg-white dark:bg-gray-800">
-      <h3 className="text-lg font-semibold mb-3">Tool Types</h3>
-      1. **Search Tools**
-         - Web search
-         - Database queries
-         - Document search
+    3. **Error Handling**
+       - Handle exceptions gracefully
+       - Return meaningful errors
+       - Validate inputs
+  </Card>
 
-      2. **File Tools**
-         - Read/write operations
-         - File conversion
-         - Data extraction
+  <Card title="Tool Types">
+    1. **Search Tools**
+       - Web search
+       - Database queries
+       - Document search
 
-      3. **API Tools**
-         - REST API calls
-         - GraphQL queries
-         - Service integration
-    </div>
-  </div>
+    2. **File Tools**
+       - Read/write operations
+       - File conversion
+       - Data extraction
+
+    3. **API Tools**
+       - REST API calls
+       - GraphQL queries
+       - Service integration
+  </Card>
+</CardGroup>
 
 ## Best Practices Summary
 
-1. **Design Principles**
-   - Single responsibility
-   - Clear interfaces
-   - Proper documentation
-   - Error handling
+<Note>
+Following these best practices will help you create robust, efficient, and secure tools in PraisonAI.
+</Note>
 
-2. **Performance**
-   - Efficient processing
-   - Resource management
-   - Caching when appropriate
-   - Asynchronous operations
+<CardGroup cols={1}>
+  <Card title="Design Principles" icon="compass-drafting" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Single Responsibility">
+        Each tool should have one clear purpose and do it well. Avoid creating tools that try to do too many things.
+        ```python
+        # Good Example
+        def process_image(image: np.array) -> np.array:
+            return processed_image
 
-3. **Security**
-   - Input validation
-   - Rate limiting
-   - API key management
-   - Error masking
+        # Avoid
+        def process_and_save_and_upload(image):
+            # Too many responsibilities
+            pass
+        ```
+      </Accordion>
+      
+      <Accordion title="Clear Interfaces">
+        Define explicit input/output types and maintain consistent parameter naming.
+        ```python
+        def search_tool(
+            query: str,
+            max_results: int = 10
+        ) -> List[Dict[str, Any]]:
+            """
+            Search for information with clear parameters
+            """
+            pass
+        ```
+      </Accordion>
+      
+      <Accordion title="Documentation">
+        Always include detailed docstrings and type hints.
+        ```python
+        def analyze_text(
+            text: str,
+            language: str = "en"
+        ) -> Dict[str, float]:
+            """
+            Analyze text sentiment and emotions.
+            
+            Args:
+                text: Input text to analyze
+                language: ISO language code
+                
+            Returns:
+                Dict with sentiment scores
+            """
+            pass
+        ```
+      </Accordion>
+    </AccordionGroup>
+  </Card>
+</CardGroup>
+
+<br />
+
+<CardGroup cols={1}>
+  <Card title="Performance Optimization" icon="bolt" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Efficient Processing">
+        Optimize resource usage and processing time.
+        ```python
+        # Use generators for large datasets
+        def process_large_data():
+            for chunk in data_generator():
+                yield process_chunk(chunk)
+        ```
+      </Accordion>
+      
+      <Accordion title="Resource Management">
+        Properly handle resource allocation and cleanup.
+        ```python
+        async with aiohttp.ClientSession() as session:
+            # Resource automatically managed
+            await process_data(session)
+        ```
+      </Accordion>
+      
+      <Accordion title="Caching">
+        Implement caching for frequently accessed data.
+        ```python
+        @cache.memoize(timeout=300)
+        def expensive_operation(data: str) -> Dict:
+            return process_expensive(data)
+        ```
+      </Accordion>
+      
+      <Accordion title="Async Operations">
+        Use async/await for I/O-bound operations.
+        ```python
+        async def fetch_data(urls: List[str]):
+            async with aiohttp.ClientSession() as session:
+                tasks = [fetch_url(session, url) for url in urls]
+                return await asyncio.gather(*tasks)
+        ```
+      </Accordion>
+    </AccordionGroup>
+  </Card>
+</CardGroup>
+
+<br />
+
+<CardGroup cols={1}>
+  <Card title="Security Best Practices" icon="shield-check" iconType="solid">
+    <AccordionGroup>
+      <Accordion title="Input Validation">
+        Always validate and sanitize inputs to prevent security vulnerabilities.
+        ```python
+        def process_user_input(data: str) -> str:
+            if not isinstance(data, str):
+                raise ValueError("Input must be string")
+            return sanitize_input(data.strip())
+        ```
+      </Accordion>
+      
+      <Accordion title="Rate Limiting">
+        Implement rate limiting for API calls to prevent abuse.
+        ```python
+        @rate_limit(calls=100, period=60)
+        async def api_call():
+            return await make_request()
+        ```
+      </Accordion>
+      
+      <Accordion title="API Key Management">
+        Securely handle API keys and credentials using environment variables.
+        ```python
+        # Use environment variables
+        api_key = os.getenv('API_KEY')
+        if not api_key:
+            raise ConfigError("API key not found")
+        ```
+      </Accordion>
+      
+      <Accordion title="Error Masking">
+        Hide sensitive information in error messages to prevent information leakage.
+        ```python
+        try:
+            result = process_sensitive_data()
+        except Exception as e:
+            # Log detailed error internally
+            logger.error(f"Detailed error: {str(e)}")
+            # Return sanitized error to user
+            raise PublicError("Processing failed")
+        ```
+      </Accordion>
+    </AccordionGroup>
+  </Card>
+</CardGroup>
+
+<br />
+
+<Tip>
+**Pro Tip**: Start with these practices from the beginning of your project. It's easier to maintain good practices than to retrofit them later.
+</Tip>

docs/features/async.mdx

@@ -1,82 +1,126 @@
 ---
-title: "Async AI Agents"
+title: "Async Agents"
 description: "Async AI Agents allow you to run AI tasks asynchronously, improving performance and efficiency in your applications."
 icon: "clock"
 ---
 
-<Note>
-  **Requirements**
-  
-  - Python 3.10 or higher
-  - Basic understanding of async/await in Python
-</Note>
-
 ## Quick Start
 
-<Steps>
-  <Step title="Install Package">
-    First, install the PraisonAI Agents package:
-    ```bash
-    pip install praisonaiagents
-    ```
-  </Step>
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+      <Step title="Install Package">
+        First, install the PraisonAI Agents package:
+        ```bash
+        pip install praisonaiagents
+        ```
+      </Step>
 
-  <Step title="Set API Key">
-    Set your OpenAI API key as an environment variable:
-    ```bash
-    export OPENAI_API_KEY=your_api_key_here
-    ```
-  </Step>
+      <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+      </Step>
 
-  <Step title="Create Project">
-    Create a new file `app.py` with the basic setup:
-    ```python
-    import asyncio
-    from praisonaiagents import Agent, Task, PraisonAIAgents
+      <Step title="Create Project">
+        Create a new file `app.py` with the basic setup:
+        ```python
+        import asyncio
+        from praisonaiagents import Agent, Task, PraisonAIAgents
 
-    # Create an agent
-    agent = Agent(
-        name="AsyncAgent",
-        role="Assistant",
-        goal="Help with tasks",
-        backstory="Expert in async operations"
-    )
+        # Create an agent
+        agent = Agent(
+            name="AsyncAgent",
+            role="Assistant",
+            goal="Help with tasks",
+            backstory="Expert in async operations"
+        )
 
-    # Create a task
-    task = Task(
-        name="hello_task",
-        description="Say hello and introduce yourself",
-        agent=agent,
-        async_execution=True,
-        expected_output="Answer to the question"
-    )
+        # Create a task
+        task = Task(
+            name="hello_task",
+            description="Say hello and introduce yourself",
+            agent=agent,
+            async_execution=True,
+            expected_output="Answer to the question"
+        )
 
-    # Create agents manager
-    agents = PraisonAIAgents(
-        agents=[agent],
-        tasks=[task],
-        process="sequential"
-    )
+        # Create agents manager
+        agents = PraisonAIAgents(
+            agents=[agent],
+            tasks=[task],
+            process="sequential"
+        )
 
-    # Main async function
-    async def main():
-        result = await agents.astart()
-        print(result)
+        # Main async function
+        async def main():
+            result = await agents.astart()
+            print(result)
 
-    # Run the program
-    if __name__ == "__main__":
-        asyncio.run(main())
+        # Run the program
+        if __name__ == "__main__":
+            asyncio.run(main())
+        ```
+      </Step>
 
-    ```
-  </Step>
+      <Step title="Run the Program">
+        Run your async AI agent:
+        ```bash
+        python app.py
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+      <Step title="Install Package">
+        Install the PraisonAI package:
+        ```bash
+        pip install praisonai
+        ```
+      </Step>
+      <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+      </Step>
+      <Step title="Create Project">
+        Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: async operations
+roles:
+  assistant:
+    name: AsyncAgent
+    role: Assistant
+    goal: Help with tasks
+    backstory: Expert in async operations
+    tasks:
+      hello_task:
+        description: Say hello and introduce yourself
+        expected_output: Answer to the question
+        async_execution: true
+```
+      </Step>
+      <Step title="Run the Program">
+        Run your async AI agent:
+        ```bash
+        praisonai agents.yaml
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+</Tabs>
 
-  <Step title="Run the Program">
-    Run your async AI agent:
-    ```bash
-    python app.py
-    ```
-  </Step>
-</Steps>
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+  - Basic understanding of async/await in Python
+</Note>
 
 <div className="relative w-full aspect-video">
   <iframe
@@ -129,7 +173,9 @@ icon: "clock"
 
 ## Advanced Usage
 
-### Async Tasks with Callbacks and Tools Example Code
+<Tabs>
+  <Tab title="Code">
+    ### Async Tasks with Callbacks and Tools Example Code
 
 ```python
 import asyncio
@@ -357,7 +403,6 @@ async def main():
 if __name__ == "__main__":
     # Run the main function
     asyncio.run(main())
-
 ```
 
 ### 1. Async Tasks with Callbacks
@@ -402,6 +447,28 @@ async def process_multiple_tasks():
     )
     return results
 ```
+  </Tab>
+  <Tab title="No Code">
+    ```yaml
+    framework: praisonai
+    process: sequential
+    topic: async operations
+    roles:
+      async_agent:
+        name: AsyncSearchAgent
+        role: Asynchronous Search Specialist
+        goal: Perform fast and efficient asynchronous searches
+        backstory: Expert in parallel search operations
+        tools:
+          - async_search_tool
+        tasks:
+          search_task:
+            description: Perform async search operations
+            expected_output: Structured search results
+            async_execution: true
+    ```
+  </Tab>
+</Tabs>
 
 ## Best Practices
 
@@ -481,11 +548,11 @@ async def process_multiple_tasks():
 ## Next Steps
 
 <CardGroup cols={2}>
-  <Card title="Examples" icon="code" href="./examples">
-    Check out more examples in our examples directory
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
   </Card>
-  <Card title="Advanced Topics" icon="book" href="./advanced">
-    Learn about advanced async patterns and optimizations
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
   </Card>
 </CardGroup>
 

docs/features/autoagents.mdx

@@ -0,0 +1,308 @@
+---
+title: "AutoAgents"
+description: "AutoAgents automatically creates and manages AI agents and tasks based on high-level instructions."
+icon: "robot"
+---
+
+## Quick Start
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install praisonaiagents duckduckgo_search
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import AutoAgents
+            from praisonaiagents.tools import duckduckgo
+
+            # Create AutoAgents instance
+            agents = AutoAgents(
+                instructions="Search for information about AI Agents",
+                tools=[duckduckgo],
+                process="sequential",
+                verbose=True,
+                max_agents=3  # Maximum number of agents to create
+            )
+
+            # Start the agents
+            result = agents.start()
+            print(result)
+            ```
+        </Step>
+
+        <Step title="Start AutoAgents">
+            Run your AutoAgents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+
+    <Note>
+    **Requirements**
+    
+    - Python 3.10 or higher
+    - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+    </Note>
+    
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Start AutoAgents">
+            Run your AutoAgents:
+            ```bash
+            praisonai --auto "Create a movie script about a robot in Mars"
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+## Understanding AutoAgents
+
+<Card title="What are AutoAgents?" icon="question">
+  AutoAgents automatically:
+  - Creates appropriate AI agents based on your instructions
+  - Assigns relevant tools to each agent
+  - Breaks down tasks into manageable steps
+  - Manages execution flow between agents
+  - Handles agent coordination and task delegation
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Automatic Agent Creation" icon="wand-magic-sparkles">
+    Creates specialized agents based on task requirements.
+  </Card>
+  <Card title="Smart Tool Assignment" icon="toolbox">
+    Automatically assigns relevant tools to each agent.
+  </Card>
+  <Card title="Task Management" icon="list-check">
+    Breaks down complex tasks into manageable steps.
+  </Card>
+  <Card title="Process Optimization" icon="gauge-high">
+    Chooses optimal execution process (sequential/hierarchical).
+  </Card>
+</CardGroup>
+
+<CodeGroup>
+  ```python Basic
+  # Basic usage with default settings
+  agents = AutoAgents(
+      instructions="Your high-level task description",
+      tools=[tool1, tool2]
+  )
+  ```
+
+  ```python Advanced
+  # Advanced usage with custom settings
+  agents = AutoAgents(
+      instructions="Your task description",
+      tools=[tool1, tool2],
+      max_agents=3,
+      process="hierarchical",
+      verbose=True,
+      memory=True,
+      allow_delegation=True
+  )
+  ```
+</CodeGroup>
+
+## Advanced Usage
+
+### Configuration Options
+
+```python
+
+# Create AutoAgents with advanced configuration
+agents = AutoAgents(
+    instructions="Research and summarize recent AI developments",
+    tools=[SerperDevTool, WikipediaTools],
+    max_agents=3,  # Maximum number of agents to create
+    verbose=True,  # Enable detailed logging
+    process="hierarchical",  # Use hierarchical process
+    memory=True,  # Enable memory for agents
+    allow_delegation=True,  # Allow task delegation
+    max_rpm=60,  # Maximum requests per minute
+    max_execution_time=300,  # Maximum execution time in seconds
+    allow_code_execution=True,  # Allow code execution
+    code_execution_mode="safe",  # Use safe mode for code execution
+    self_reflect=True,  # Enable agent self-reflection
+    markdown=True  # Enable markdown formatting
+)
+```
+
+### Process Types
+
+<AccordionGroup>
+  <Accordion title="Sequential Process">
+    ```python
+    # Tasks are executed in sequence
+    agents = AutoAgents(
+        instructions="Your task",
+        process="sequential"
+    )
+    ```
+  </Accordion>
+
+  <Accordion title="Hierarchical Process">
+    ```python
+    # Manager agent coordinates other agents
+    agents = AutoAgents(
+        instructions="Your task",
+        process="hierarchical",
+        manager_llm="gpt-4o"  # Specify LLM for manager
+    )
+    ```
+  </Accordion>
+</AccordionGroup>
+
+## Best Practices
+
+<AccordionGroup>
+  <Accordion title="Clear Instructions">
+    ```python
+    # Good instruction example
+    agents = AutoAgents(
+        instructions="""
+        Research the latest developments in AI for 2024:
+        1. Focus on breakthrough technologies
+        2. Include real-world applications
+        3. Consider future implications
+        """
+    )
+    ```
+  </Accordion>
+
+  <Accordion title="Tool Selection">
+    ```python
+    # Provide relevant tools for the task
+    
+    agents = AutoAgents(
+        instructions="Research task",
+        tools=[
+            SerperDevTool,  # For web search
+            WikipediaTools,  # For background info
+            CustomTool  # Your custom tool
+        ]
+    )
+    ```
+  </Accordion>
+
+  <Accordion title="Resource Management">
+
+    ```python
+    # Configure resource limits
+    agents = AutoAgents(
+        instructions="Your task",
+        max_rpm=60,  # Rate limiting
+        max_execution_time=300,  # Timeout
+        max_agents=3  # Agent limit
+    )
+    ```
+  </Accordion>
+</AccordionGroup>
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Tool Assignment Issues" icon="triangle-exclamation">
+    If tools aren't being assigned correctly:
+    - Check tool compatibility
+    - Verify tool names
+    - Enable verbose mode for debugging
+  </Card>
+
+  <Card title="Performance Issues" icon="gauge">
+    If execution is slow:
+    - Reduce max_agents
+    - Adjust max_rpm
+    - Consider process type
+  </Card>
+</CardGroup>
+
+## API Reference
+
+### Main Parameters
+
+<ResponseField name="instructions" type="str" required>
+  High-level task description for the agents
+</ResponseField>
+
+<ResponseField name="tools" type="List[Any]">
+  List of tools available to the agents
+</ResponseField>
+
+<ResponseField name="max_agents" type="int" default="3">
+  Maximum number of agents to create
+</ResponseField>
+
+<ResponseField name="process" type="str" default="sequential">
+  Process type: "sequential" or "hierarchical"
+</ResponseField>
+
+### Optional Parameters
+
+<ResponseField name="verbose" type="bool" default="False">
+  Enable detailed logging
+</ResponseField>
+
+<ResponseField name="memory" type="bool" default="True">
+  Enable agent memory
+</ResponseField>
+
+<ResponseField name="allow_delegation" type="bool" default="False">
+  Allow agents to delegate tasks
+</ResponseField>
+
+### Methods
+
+<ResponseField name="start()" type="method">
+  Start the agents synchronously
+</ResponseField>
+
+<ResponseField name="astart()" type="method">
+  Start the agents asynchronously
+</ResponseField>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Examples" icon="code" href="./examples">
+    Explore more examples in our examples directory
+  </Card>
+  <Card title="Custom Tools" icon="screwdriver-wrench" href="./tools">
+    Learn how to create custom tools for your agents
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal results, provide clear instructions and appropriate tools for your use case.
+</Note>

docs/features/codeagent.mdx

@@ -1,77 +1,138 @@
 ---
-title: "Code Execution Agent"
+title: "Code Execution AI Agent"
 sidebarTitle: "Code Agent"
 description: "Learn how to create AI agents that can write and execute Python code safely using e2b code interpreter."
 icon: "code"
 ---
 
-<Note>
-  **Prerequisites**
-  - Python 3.10 or higher
-  - PraisonAI Agents package installed
-  - e2b_code_interpreter package installed
-  - Basic understanding of Python
-</Note>
-
 ## Quick Start
 
-Create AI agents that can write and execute Python code in a sandboxed environment!
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the required packages:
+            ```bash
+            pip install praisonaiagents e2b_code_interpreter
+            ```
+        </Step>
 
-<Steps>
-  <Step title="Install Packages">
-    First, install the required packages:
-    ```bash
-    pip install praisonaiagents e2b_code_interpreter
-    ```
-  </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key and E2B API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            export E2B_API_KEY=your_e2b_api_key_here
+            ```
+        </Step>
 
-  <Step title="Import Required Components">
-    Import the necessary components:
-    ```python
-    from praisonaiagents import Agent, Task, PraisonAIAgents
-    from e2b_code_interpreter import Sandbox
-    ```
-  </Step>
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents
+            from e2b_code_interpreter import Sandbox
 
-  <Step title="Define Code Interpreter">
-    Create a code interpreter function:
-    ```python
-    def code_interpreter(code: str):
-        print(f"\n{'='*50}\n> Running following AI-generated code:\n{code}\n{'='*50}")
-        exec_result = Sandbox().run_code(code)
-        if exec_result.error:
-            print("[Code Interpreter error]", exec_result.error)
-            return {"error": str(exec_result.error)}
-        else:
-            results = []
-            for result in exec_result.results:
-                if hasattr(result, '__iter__'):
-                    results.extend(list(result))
+            def code_interpreter(code: str):
+                print(f"\n{'='*50}\n> Running following AI-generated code:\n{code}\n{'='*50}")
+                exec_result = Sandbox().run_code(code)
+                if exec_result.error:
+                    print("[Code Interpreter error]", exec_result.error)
+                    return {"error": str(exec_result.error)}
                 else:
-                    results.append(str(result))
-            logs = {"stdout": list(exec_result.logs.stdout), "stderr": list(exec_result.logs.stderr)}
-            return json.dumps({"results": results, "logs": logs})
-    ```
-  </Step>
+                    results = []
+                    for result in exec_result.results:
+                        if hasattr(result, '__iter__'):
+                            results.extend(list(result))
+                        else:
+                            results.append(str(result))
+                    logs = {"stdout": list(exec_result.logs.stdout), "stderr": list(exec_result.logs.stderr)}
+                    return json.dumps({"results": results, "logs": logs})
 
-  <Step title="Create Code Agents">
-    Set up your code writing and execution agents:
-    ```python
-    code_agent = Agent(
-        name="code_agent",
-        backstory="Expert in writing Python scripts",
-        self_reflect=False
-    )
+            # Create code agent
+            code_agent = Agent(
+                role="Code Developer",
+                goal="Write and execute Python code",
+                backstory="Expert Python developer with strong coding skills",
+                tools=[code_interpreter],
+                verbose=True
+            )
 
-    execution_agent = Agent(
-        name="execution_agent",
-        backstory="Expert in executing Python scripts",
-        self_reflect=False,
-        tools=[code_interpreter]
-    )
-    ```
-  </Step>
-</Steps>
+            # Create a task
+            task = Task(
+                description="Write and execute a Python script to analyze data",
+                expected_output="Working Python script with execution results",
+                agent=code_agent
+            )
+
+            # Create and start the agents
+            agents = PraisonAIAgents(
+                agents=[code_agent],
+                tasks=[task],
+                process="sequential",
+                verbose=2
+            )
+
+            # Start execution
+            agents.start()
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai e2b_code_interpreter
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: write and execute Python code
+roles:
+  developer:
+    backstory: Expert Python developer with strong coding skills.
+    goal: Write and execute Python code safely
+    role: Code Developer
+    tools:
+      - code_interpreter
+    tasks:
+      coding_task:
+        description: Write and execute a Python script to analyze data.
+        expected_output: Working Python script with execution results.
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+  - e2b_code_interpreter package installed
+</Note>
 
 ## Understanding Code Agents
 
@@ -83,205 +144,210 @@ Create AI agents that can write and execute Python code in a sandboxed environme
   - Work together in a pipeline (writer → executor)
 </Card>
 
-## Key Components
+## Features
 
 <CardGroup cols={2}>
-  <Card title="Code Writer Agent" icon="pencil">
-    Specialized in writing Python code
-    ```python
-    Agent(
-        name="code_agent",
-        backstory="Expert in writing Python scripts"
-    )
-    ```
+  <Card title="Code Writer" icon="pencil">
+    Writes Python code based on requirements.
   </Card>
-  <Card title="Code Executor Agent" icon="play">
-    Executes code using sandbox
-    ```python
-    Agent(
-        name="execution_agent",
-        tools=[code_interpreter]
-    )
-    ```
+  <Card title="Safe Execution" icon="shield">
+    Executes code in a sandboxed environment.
   </Card>
-  <Card title="Sandbox Environment" icon="box">
-    Safe code execution environment using e2b
+  <Card title="Error Handling" icon="bug">
+    Manages code execution errors and debugging.
   </Card>
-  <Card title="Execution Results" icon="output">
-    Structured output with results and logs
+  <Card title="Results Processing" icon="output">
+    Processes and formats execution results.
   </Card>
 </CardGroup>
 
-## Examples
+## Multi-Agent Code Development
 
-### Simple Hello World Example
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the required packages:
+            ```bash
+            pip install praisonaiagents e2b_code_interpreter
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents
+            from e2b_code_interpreter import Sandbox
+
+            def code_interpreter(code: str):
+                print(f"\n{'='*50}\n> Running following AI-generated code:\n{code}\n{'='*50}")
+                exec_result = Sandbox().run_code(code)
+                if exec_result.error:
+                    print("[Code Interpreter error]", exec_result.error)
+                    return {"error": str(exec_result.error)}
+                else:
+                    results = []
+                    for result in exec_result.results:
+                        if hasattr(result, '__iter__'):
+                            results.extend(list(result))
+                        else:
+                            results.append(str(result))
+                    logs = {"stdout": list(exec_result.logs.stdout), "stderr": list(exec_result.logs.stderr)}
+                    return json.dumps({"results": results, "logs": logs})
+
+            # Create first agent for writing code
+            code_writer = Agent(
+                role="Code Writer",
+                goal="Write efficient Python code",
+                backstory="Expert Python developer specializing in code writing",
+                verbose=True
+            )
+
+            # Create second agent for code execution
+            code_executor = Agent(
+                role="Code Executor",
+                goal="Execute and validate Python code",
+                backstory="Expert in code execution and testing",
+                tools=[code_interpreter],
+                verbose=True
+            )
+
+            # Create first task
+            writing_task = Task(
+                description="Write a Python script for data analysis",
+                expected_output="Complete Python script",
+                agent=code_writer
+            )
+
+            # Create second task
+            execution_task = Task(
+                description="Execute and validate the Python script",
+                expected_output="Execution results and validation",
+                agent=code_executor
+            )
+
+            # Create and start the agents
+            agents = PraisonAIAgents(
+                agents=[code_writer, code_executor],
+                tasks=[writing_task, execution_task],
+                process="sequential"
+            )
+
+            # Start execution
+            agents.start()
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai e2b_code_interpreter
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: develop and execute Python code
+roles:
+  writer:
+    backstory: Expert Python developer specializing in code writing.
+    goal: Write efficient Python code
+    role: Code Writer
+    tasks:
+      writing_task:
+        description: Write a Python script for data analysis.
+        expected_output: Complete Python script.
+
+  executor:
+    backstory: Expert in code execution and testing.
+    goal: Execute and validate Python code
+    role: Code Executor
+    tools:
+      - code_interpreter
+    tasks:
+      execution_task:
+        description: Execute and validate the Python script.
+        expected_output: Execution results and validation.
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+### Configuration Options
 
 ```python
-from praisonaiagents import Agent, Task, PraisonAIAgents
-from e2b_code_interpreter import Sandbox
-
-# Create agents
-code_agent = Agent(
-    name="code_agent",
-    backstory="Expert in writing Python scripts",
-    self_reflect=False
-)
-
-execution_agent = Agent(
-    name="execution_agent",
-    backstory="Expert in executing Python scripts",
-    self_reflect=False,
-    tools=[code_interpreter]
-)
-
-# Define tasks
-code_task = Task(
-    description="Write a simple Python script to print 'Hello, World!'",
-    expected_output="A Python script that prints 'Hello, World!'",
-    agent=code_agent
-)
-
-execution_task = Task(
-    description="Execute the Python script",
-    expected_output="The output of the Python script",
-    agent=execution_agent
-)
-
-# Initialize and run agents
-agents = PraisonAIAgents(
-    agents=[code_agent, execution_agent],
-    tasks=[code_task, execution_task]
-)
-result = agents.start()
-```
-
-### Advanced Code Generation
-
-<CodeGroup>
-```python Data Analysis
-# Create a data analysis script
-code_task = Task(
-    description="""
-    Write a Python script that:
-    1. Creates a sample dataset
-    2. Performs basic statistical analysis
-    3. Generates a plot
-    """,
-    agent=code_agent
-)
-```
-
-```python Web Scraping
-# Create a web scraping script
-code_task = Task(
-    description="""
-    Write a Python script that:
-    1. Scrapes a website
-    2. Extracts specific data
-    3. Saves to CSV
-    """,
-    agent=code_agent
-)
-```
-</CodeGroup>
-
-## Best Practices
-
-<AccordionGroup>
-  <Accordion title="Code Safety">
-    Ensure safe code execution:
-    ```python
-    # Always use sandbox environment
-    exec_result = Sandbox().run_code(code)
-    
-    # Handle errors gracefully
-    if exec_result.error:
-        return {"error": str(exec_result.error)}
-    ```
-  </Accordion>
-
-  <Accordion title="Task Description">
-    Write clear code requirements:
-    ```python
-    # Good
-    Task(description="""
-        Write a Python script that:
-        1. Takes user input
-        2. Validates the input
-        3. Processes the data
-        4. Returns formatted output
-    """)
-    
-    # Too vague
-    Task(description="Write some Python code")
-    ```
-  </Accordion>
-</AccordionGroup>
-
-## Common Patterns
-
-### Code Generation and Testing
-```python
-# Generate code
-code_task = Task(
-    description="Write a function to calculate fibonacci numbers",
-    agent=code_agent
-)
-
-# Generate test cases
-test_task = Task(
-    description="Write test cases for the fibonacci function",
-    agent=code_agent
-)
-
-# Execute tests
-execution_task = Task(
-    description="Run the test cases",
-    agent=execution_agent
-)
-```
-
-### Interactive Code Development
-```python
-# Write initial code
-initial_code_task = Task(
-    description="Write initial version of the script",
-    agent=code_agent
-)
-
-# Test and improve
-improvement_task = Task(
-    description="Analyze execution results and improve the code",
-    agent=code_agent
+# Create an agent with advanced code execution configuration
+agent = Agent(
+    role="Code Developer",
+    goal="Write and execute Python code",
+    backstory="Expert in Python development",
+    tools=[code_interpreter],
+    verbose=True,  # Enable detailed logging
+    llm="gpt-4o"  # Language model to use
 )
 ```
 
 ## Troubleshooting
 
 <CardGroup cols={2}>
-  <Card title="Execution Errors" icon="triangle-exclamation">
-    Check sandbox execution results:
-    ```python
-    if exec_result.error:
-        print("[Error]", exec_result.error)
-    ```
+  <Card title="Code Errors" icon="triangle-exclamation">
+    If code execution fails:
+    - Check syntax errors
+    - Verify package imports
+    - Enable verbose mode for debugging
   </Card>
-  <Card title="Code Generation" icon="code">
-    Provide clear requirements and constraints in task description
+
+  <Card title="Sandbox Issues" icon="box">
+    If sandbox execution fails:
+    - Check environment setup
+    - Verify permissions
+    - Review resource limits
   </Card>
 </CardGroup>
 
 ## Next Steps
 
 <CardGroup cols={2}>
-  <Card title="Advanced Code Generation" icon="graduation-cap" href="./advanced-code">
-    Learn about complex code generation patterns
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
   </Card>
-  <Card title="Custom Tools" icon="wrench" href="./custom-tools">
-    Create custom code execution tools
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
   </Card>
 </CardGroup>
 
 <Note>
-  Code execution agents provide a powerful way to generate and run Python code safely. They're perfect for automated code generation, testing, and execution in a controlled environment.
+  For optimal results, ensure code is properly formatted and tested in the sandbox environment before production use.
 </Note>

docs/features/langchain.mdx

@@ -0,0 +1,219 @@
+---
+title: "LangChain Agents"
+sidebarTitle: "LangChain Agents"
+description: "Learn how to use LangChain tools and utilities with PraisonAI agents."
+icon: "link-simple"
+---
+
+## Quick Start
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the required packages:
+            ```bash
+            pip install praisonaiagents langchain-community wikipedia
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+<CodeGroup>
+  ```python Single Tool
+  from praisonaiagents import Agent, Task, PraisonAIAgents
+  from langchain_community.utilities import WikipediaAPIWrapper
+
+  # Create an agent with Wikipedia tool
+  agent = Agent(
+      name="WikiAgent",
+      role="Research Assistant",
+      goal="Search Wikipedia for accurate information",
+      backstory="I am an AI assistant specialized in Wikipedia research",
+      tools=[WikipediaAPIWrapper],
+      self_reflect=False
+  )
+
+  # Create a research task
+  task = Task(
+      name="wiki_search",
+      description="Research 'Artificial Intelligence' on Wikipedia",
+      expected_output="Comprehensive information from Wikipedia articles",
+      agent=agent
+  )
+
+  # Create and start the workflow
+  agents = PraisonAIAgents(
+      agents=[agent],
+      tasks=[task],
+      verbose=True
+  )
+
+  agents.start()
+  ```
+
+  ```python Multiple Tools
+  from praisonaiagents import Agent, Task, PraisonAIAgents
+  from langchain_community.tools import YouTubeSearchTool
+  from langchain_community.utilities import WikipediaAPIWrapper
+
+  # Create YouTube search agent
+  agent = Agent(
+      name="SearchAgent",
+      role="Research Assistant",
+      goal="Search for information from YouTube",
+      backstory="I am an AI assistant that can search YouTube for relevant videos.",
+      tools=[YouTubeSearchTool],
+      self_reflect=False
+  )
+
+  # Create Wikipedia research agent
+  agent2 = Agent(
+      name="WikiAgent",
+      role="Research Assistant",
+      goal="Search for information from Wikipedia",
+      backstory="I am an AI assistant that can search Wikipedia for accurate information.",
+      tools=[WikipediaAPIWrapper],
+      self_reflect=False
+  )
+
+  # Create YouTube search task
+  task = Task(
+      name="search_task",
+      description="Search for information about 'AI advancements' on YouTube",
+      expected_output="Relevant information from YouTube videos",
+      agent=agent
+  )
+
+  # Create Wikipedia research task
+  task2 = Task(
+      name="wiki_task",
+      description="Search for information about 'AI advancements' on Wikipedia",
+      expected_output="Comprehensive information from Wikipedia articles",
+      agent=agent2
+  )
+
+  # Create and start the workflow
+  agents = PraisonAIAgents(
+      agents=[agent, agent2],
+      tasks=[task, task2],
+      verbose=True
+  )
+
+  agents.start()
+  ```
+</CodeGroup>
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            (Upcoming Feature)
+            Install the PraisonAI package:
+            ```bash
+            pip install "praisonai"
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+roles:
+  researcher:
+    name: SearchAgent
+    role: Research Assistant
+    goal: Search for information from multiple sources
+    backstory: I am an AI assistant that can search YouTube and Wikipedia.
+    tools:
+      - youtube_search
+      - wikipedia
+    tasks:
+      search_task:
+        name: search_task
+        description: Search for information about 'AI advancements' on both YouTube and Wikipedia
+        expected_output: Combined information from YouTube videos and Wikipedia articles
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys)
+  - LangChain compatible tools and utilities
+</Note>
+
+## Understanding LangChain Integration
+
+<Card title="What is LangChain Integration?" icon="question">
+  LangChain integration enables agents to:
+  - Use LangChain's extensive tool ecosystem
+  - Access various data sources and APIs
+  - Leverage pre-built utilities and wrappers
+  - Combine multiple tools in a single agent
+  - Extend agent capabilities with community tools
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Tool Integration" icon="plug">
+    Seamlessly use LangChain tools with PraisonAI agents.
+  </Card>
+  <Card title="Multiple Sources" icon="database">
+    Access various data sources through LangChain utilities.
+  </Card>
+  <Card title="Community Tools" icon="users">
+    Leverage the extensive LangChain community ecosystem.
+  </Card>
+  <Card title="Custom Tools" icon="wrench">
+    Create and integrate custom LangChain tools.
+  </Card>
+</CardGroup>
+
+
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Memory Integration" icon="brain" href="../concepts/memory">
+    Learn how to combine LangChain tools with agent memory
+  </Card>
+  <Card title="Custom Tools" icon="wrench" href="./tools">
+    Create your own custom tools for agents
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal results, ensure all required dependencies are installed and API keys are properly configured for each tool.
+</Note>

docs/features/mathagent.mdx

@@ -0,0 +1,347 @@
+---
+title: "Math AI Agent"
+sidebarTitle: "Math Agent"
+description: "Learn how to create AI agents that can perform complex mathematical calculations, unit conversions, and financial computations."
+icon: "calculator"
+---
+
+## Quick Start
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install praisonaiagents sympy pint
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents
+            from praisonaiagents.tools import (
+                evaluate, solve_equation, convert_units,
+                calculate_statistics, calculate_financial
+            )
+
+            # Create math agent
+            math_agent = Agent(
+                role="Math Expert",
+                goal="Perform complex mathematical calculations",
+                backstory="Expert in mathematical computations and analysis",
+                tools=[
+                    evaluate, solve_equation, convert_units,
+                    calculate_statistics, calculate_financial
+                ],
+                verbose=True
+            )
+
+            # Create a task
+            task = Task(
+                description="Calculate compound interest and statistical analysis",
+                expected_output="Detailed mathematical analysis",
+                agent=math_agent
+            )
+
+            # Create and start the agents
+            agents = PraisonAIAgents(
+                agents=[math_agent],
+                tasks=[task],
+                process="sequential",
+                verbose=2
+            )
+
+            # Start execution
+            agents.start()
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai sympy pint
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: perform mathematical analysis
+roles:
+  mathematician:
+    backstory: Expert in mathematical computations and analysis.
+    goal: Perform complex mathematical calculations
+    role: Math Expert
+    tools:
+      - evaluate
+      - solve_equation
+      - convert_units
+      - calculate_statistics
+      - calculate_financial
+    tasks:
+      math_task:
+        description: Calculate compound interest and perform statistical analysis.
+        expected_output: Detailed mathematical analysis with results.
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+<Note>
+  **Requirements**
+
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+  - sympy and pint packages (automatically installed when needed)
+</Note>
+
+## Understanding Math Agents
+
+<Card title="What are Math Agents?" icon="question">
+  Math agents are specialized AI agents that can:
+  - Evaluate mathematical expressions
+  - Solve equations and systems of equations
+  - Perform unit conversions
+  - Calculate statistical metrics
+  - Handle financial calculations
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Expression Evaluator" icon="function">
+    Evaluates mathematical expressions and formulas.
+  </Card>
+  <Card title="Equation Solver" icon="equals">
+    Solves mathematical equations and systems.
+  </Card>
+  <Card title="Unit Converter" icon="arrows-rotate">
+    Converts between different units of measurement.
+  </Card>
+  <Card title="Statistical Calculator" icon="chart-simple">
+    Calculates statistical metrics and analysis.
+  </Card>
+</CardGroup>
+
+## Multi-Agent AI Math Analysis
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install praisonaiagents
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents
+            from praisonaiagents.tools import (
+                evaluate, solve_equation, convert_units,
+                calculate_statistics, calculate_financial
+            )
+
+            # Create first agent for calculations
+            calculator = Agent(
+                role="Mathematical Calculator",
+                goal="Perform complex calculations and analysis",
+                backstory="Expert in mathematical computations",
+                tools=[evaluate, solve_equation, convert_units],
+                verbose=True
+            )
+
+            # Create second agent for statistics
+            statistician = Agent(
+                role="Statistical Analyst",
+                goal="Perform statistical analysis and interpretation",
+                backstory="Expert in statistical analysis",
+                tools=[calculate_statistics, calculate_financial],
+                verbose=True
+            )
+
+            # Create first task
+            calc_task = Task(
+                description="Calculate compound interest for $10000 at 5% for 3 years",
+                expected_output="Detailed interest calculation",
+                agent=calculator
+            )
+
+            # Create second task
+            stats_task = Task(
+                description="Analyze the monthly interest distribution",
+                expected_output="Statistical analysis of interest data",
+                agent=statistician
+            )
+
+            # Create and start the agents
+            agents = PraisonAIAgents(
+                agents=[calculator, statistician],
+                tasks=[calc_task, stats_task],
+                process="sequential"
+            )
+
+            # Start execution
+            agents.start()
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: perform financial and statistical analysis
+roles:
+  calculator:
+    backstory: Expert in mathematical computations and analysis.
+    goal: Perform complex calculations
+    role: Mathematical Calculator
+    tools:
+      - evaluate
+      - solve_equation
+      - convert_units
+    tasks:
+      calc_task:
+        description: Calculate compound interest for investment scenario.
+        expected_output: Detailed interest calculations.
+
+  statistician:
+    backstory: Expert in statistical analysis and interpretation.
+    goal: Analyze numerical data and patterns
+    role: Statistical Analyst
+    tools:
+      - calculate_statistics
+      - calculate_financial
+    tasks:
+      stats_task:
+        description: Analyze the monthly interest distribution.
+        expected_output: Statistical analysis report.
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+### Configuration Options
+
+```python
+# Create an agent with advanced math configuration
+agent = Agent(
+    role="Math Expert",
+    goal="Perform complex mathematical analysis",
+    backstory="Expert in mathematical computations",
+    tools=[
+        evaluate,
+        solve_equation,
+        convert_units,
+        calculate_statistics,
+        calculate_financial
+    ],
+    verbose=True,  # Enable detailed logging
+    llm="gpt-4o"  # Language model to use
+)
+```
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Expression Errors" icon="triangle-exclamation">
+    If expressions are not evaluating:
+    - Check syntax and formatting
+    - Verify variable definitions
+    - Enable verbose mode for debugging
+  </Card>
+
+  <Card title="Calculation Issues" icon="calculator">
+    If calculations are incorrect:
+    - Review input formats
+    - Check unit compatibility
+    - Verify formula structure
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
+  </Card>
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal results, ensure mathematical expressions and units are properly formatted for your specific use case.
+</Note>

docs/features/mini.mdx

@@ -4,47 +4,112 @@ description: "Learn how to create simple yet powerful AI agents in just a few li
 icon: "robot"
 ---
 
-<Note>
-  **Prerequisites**
-  - Python 3.10 or higher
-  - PraisonAI Agents package installed
-  - Basic understanding of Python
-</Note>
-
 ## Quick Start
 
 Create multiple AI agents that can work together in just a few lines of code!
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+      <Step title="Install Package">
+        First, install the PraisonAI Agents package:
+        ```bash
+        pip install praisonaiagents duckduckgo_search
+        ```
+      </Step>
+      <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable in your terminal:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+      </Step>
+      <Step title="Create Your Agents">
+        <CodeGroup>
+        ```python Single Agent
+        from praisonaiagents import Agent, PraisonAIAgents
+        summarise_agent = Agent(instructions="Summarise Photosynthesis")
+        agents = PraisonAIAgents(agents=[summarise_agent])
+        agents.start()
+        ```
+        ```python Multiple Agents
+        # Agent with Internet Search Tool
+        from praisonaiagents import Agent, PraisonAIAgents
+        research_agent = Agent(instructions="Research about AI 2024", tools=[Tools.internet_search])
+        summarise_agent = Agent(instructions="Summarise research agent's findings")
+        agents = PraisonAIAgents(agents=[research_agent, summarise_agent])
+        agents.start()
+        ```
+        </CodeGroup>
+      </Step>
+      <Step title="Run Your Agents">
+        Execute your agents by running:
+        ```bash
+        python app.py
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+      <Step title="Install Package">
+        First, install the PraisonAI Agents package:
+        ```bash
+        pip install praisonaiagents duckduckgo_search
+        ```
+      </Step>
+      <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable in your terminal:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+      </Step>
+      <Step title="Create Your Agents">
+        <CodeGroup>
+        ```yaml Single Agent
+        # Create a new file `agents.yaml` with the following content:
+        roles:
+          summarise_agent
+            instructions: Summarise Photosynthesis
+        ```
+        ```yaml Multiple Agents
+        # Create a new file `agents.yaml` with the following content:
+        # Agent with Internet Search Tool
+        roles:
+          research_agent
+            instructions: Research about AI 2024
+            tools:
+              - internet_search
+          summarise_agent
+            instructions: Summarise research agent's findings
+        ```
+        </CodeGroup>
+      </Step>
+      <Step title="Run Your Agents">
+        Execute your agents by running:
+        ```bash
+        python app.py
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+</Tabs>
 
-<Steps>
-  <Step title="Install Package">
-    First, install the PraisonAI Agents package:
-    ```bash
-    pip install praisonaiagents
-    ```
-  </Step>
+<Note>
+  **Prerequisites**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+</Note>
+<br />
 
-  <Step title="Import Required Components">
-    Import the necessary components:
-    ```python
-    from praisonaiagents import Agent, Agents
-    ```
-  </Step>
-
-  <Step title="Create Your Agents">
-    Create specialized agents with specific roles:
-    ```python 
-    summarise_agent = Agent(instructions="Summarise what is Photosynthesis")
-    ```
-  </Step>
-
-  <Step title="Start Your Agents">
-    Initialize and run your agents:
-    ```python
-    agents = Agents(agents=[summarise_agent])
-    agents.start()
-    ```
-  </Step>
-</Steps>
+<div className="relative w-full aspect-video">
+  <iframe
+    className="absolute top-0 left-0 w-full h-full"
+    src="https://www.youtube.com/embed/OkvYp5aAGSg"
+    title="YouTube video player"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+    allowFullScreen
+  ></iframe>
+</div>
+<br />
 
 ## Understanding Mini AI Agents
 
@@ -96,34 +161,7 @@ Create multiple AI agents that can work together in just a few lines of code!
   </Card>
 </CardGroup>
 
-## Examples
-
-### Basic Research and Summary
-
-```terminal
-pip install praisonaiagents duckduckgo_search
-```
-
-```python
-from praisonaiagents import Agent, Agents, Tools
-
-# Create a research agent
-research_agent = Agent(
-    instructions="You are a research agent to search internet about AI 2024",
-    tools=[Tools.internet_search]
-)
-
-# Create a summarize agent
-summarise_agent = Agent(
-    instructions="You are a summarize agent to summarise research agent's findings"
-)
-
-# Initialize and run agents
-agents = Agents(agents=[research_agent, summarise_agent])
-agents.start()
-```
-
-### Custom Instructions
+## Custom Instructions
 
 <CodeGroup>
 ```python Basic

docs/features/multimodal.mdx

@@ -0,0 +1,314 @@
+---
+title: "Multimodal Agents"
+description: "Guide for creating and using multimodal AI agents in PraisonAI for processing images, videos, and other media types"
+icon: "images"
+---
+
+## Quick Start
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install praisonaiagents
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents
+
+            # Create Vision Analysis Agent
+            vision_agent = Agent(
+                name="VisionAnalyst",
+                role="Computer Vision Specialist",
+                goal="Analyze images and videos to extract meaningful information",
+                backstory="""You are an expert in computer vision and image analysis.
+                You excel at describing images, detecting objects, and understanding visual content.""",
+                llm="gpt-4o-mini",
+                self_reflect=False
+            )
+
+            # Create tasks with different media types
+            task = Task(
+                name="analyze_landmark",
+                description="Describe this famous landmark and its architectural features.",
+                expected_output="Detailed description of the landmark's architecture and significance",
+                agent=vision_agent,
+                images=["https://upload.wikimedia.org/wikipedia/commons/b/bf/Krakow_-_Kosciol_Mariacki.jpg"]
+            )
+
+            # Run the agents
+            agents = PraisonAIAgents(
+                agents=[vision_agent],
+                tasks=[task],
+                process="sequential",
+                verbose=True
+            )
+
+            agents.start()
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: analyze landmark image
+roles:
+  vision_analyst:
+    name: VisionAnalyst
+    role: Computer Vision Specialist
+    goal: Analyze images and videos to extract meaningful information
+    backstory: |
+      You are an expert in computer vision and image analysis.
+      You excel at describing images, detecting objects, and understanding visual content.
+    llm: gpt-4o-mini
+    self_reflect: false
+    tasks:
+      analyze_landmark:
+        description: Describe this famous landmark and its architectural features.
+        expected_output: Detailed description of the landmark's architecture and significance
+        images:
+          - https://upload.wikimedia.org/wikipedia/commons/b/bf/Krakow_-_Kosciol_Mariacki.jpg
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key with vision model access
+  - Basic understanding of Python and media handling
+</Note>
+
+<div className="relative w-full aspect-video">
+  <iframe
+    className="absolute top-0 left-0 w-full h-full"
+    src="https://www.youtube.com/embed/hjAWmUT1qqY"
+    title="YouTube video player"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+    allowFullScreen
+  ></iframe>
+</div>
+
+## Understanding Multimodal Agents
+
+<Card title="What are Multimodal Agents?" icon="question">
+  Multimodal agents are designed to:
+  - Process multiple types of data (text, images, videos)
+  - Understand context across different modalities
+  - Generate insights from diverse media sources
+  - Handle complex multimedia tasks
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Vision Processing" icon="eye">
+    Analyze images, detect objects, and understand visual content.
+  </Card>
+  <Card title="Video Analysis" icon="video">
+    Process video content for events and actions.
+  </Card>
+  <Card title="Text Extraction" icon="font">
+    Extract and analyze text from images and documents.
+  </Card>
+  <Card title="Cross-Modal Understanding" icon="arrows-repeat">
+    Integrate insights across different media types.
+  </Card>
+</CardGroup>
+
+## Multi-Agent Media Processing
+
+<Tabs>
+  <Tab title="Code">
+    ```python
+    from praisonaiagents import Agent, Task, PraisonAIAgents
+
+    # Create first agent for image analysis
+    vision_agent = Agent(
+        role="Image Analyst",
+        goal="Analyze visual content and extract key information",
+        backstory="Expert in visual analysis and image understanding",
+        llm="gpt-4o-mini",
+        self_reflect=False
+    )
+
+    # Create second agent for content writing
+    writer_agent = Agent(
+        role="Content Writer",
+        goal="Create engaging content based on image analysis",
+        backstory="Expert in creating compelling content from visual insights",
+        llm="gpt-4o-mini"
+    )
+
+    # Create tasks for different media types
+    document_task = Task(
+        description="Extract and summarize text from this document image",
+        expected_output="Structured text content with key information highlighted",
+        agent=vision_agent,
+        images=["document.jpg"]
+    )
+
+    writing_task = Task(
+        description="Create engaging content based on image analysis",
+        expected_output="Compelling article incorporating visual insights",
+        agent=writer_agent
+    )
+
+    # Create and start the agents
+    agents = PraisonAIAgents(
+        agents=[vision_agent, writer_agent],
+        tasks=[document_task, writing_task],
+        process="sequential"
+    )
+
+    result = agents.start()
+    ```
+  </Tab>
+  <Tab title="No Code">
+    ```yaml
+    framework: praisonai
+    process: sequential
+    topic: document analysis and content creation
+    roles:
+      vision_analyst:
+        role: Image Analyst
+        goal: Analyze visual content and extract key information
+        backstory: Expert in visual analysis and image understanding
+        llm: gpt-4o-mini
+        self_reflect: false
+        tasks:
+          document_task:
+            description: Extract and summarize text from this document image
+            expected_output: Structured text content with key information highlighted
+            images:
+              - document.jpg
+
+      content_writer:
+        role: Content Writer
+        goal: Create engaging content based on image analysis
+        backstory: Expert in creating compelling content from visual insights
+        llm: gpt-4o-mini
+        tasks:
+          writing_task:
+            description: Create engaging content based on image analysis
+            expected_output: Compelling article incorporating visual insights
+    ```
+  </Tab>
+</Tabs>
+
+### Configuration Options
+
+```python
+# Create an agent with multimodal configuration
+agent = Agent(
+    role="Media Analyst",
+    goal="Process multiple types of media",
+    backstory="Expert in multimedia analysis",
+    llm="gpt-4o-mini",  # Must support vision capabilities
+    verbose=True,  # Enable detailed logging
+    self_reflect=False  # Optional: disable self-reflection
+)
+
+# Task with media requirements
+task = Task(
+    description="Analyze media content",
+    expected_output="Comprehensive analysis",
+    agent=agent,
+    images=[  # Support multiple media sources
+        "https://example.com/image1.jpg",
+        "path/to/local/image.jpg",
+        "path/to/video.mp4"
+    ]
+)
+```
+
+## Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Media Handling" icon="image">
+    - Use supported formats (JPEG, PNG)
+    - Keep reasonable file sizes
+    - Provide high-quality media
+    - Validate files before processing
+  </Card>
+  <Card title="Task Design" icon="list-check">
+    - Write clear descriptions
+    - Break down complex analyses
+    - Specify expected outputs
+    - Handle errors gracefully
+  </Card>
+</CardGroup>
+
+## Example Use Cases
+
+<CardGroup cols={2}>
+  <Card title="Document Analysis" icon="file-lines">
+    Extract and analyze text from document images.
+  </Card>
+  <Card title="Security Monitoring" icon="camera-cctv">
+    Monitor security feeds for suspicious activity.
+  </Card>
+  <Card title="Medical Imaging" icon="microscope">
+    Analyze medical scans for abnormalities.
+  </Card>
+  <Card title="Architectural Analysis" icon="building">
+    Study architectural features and designs.
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
+  </Card>
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal results, ensure your media files are in supported formats and sizes for processing.
+</Note> 

docs/features/reasoning.mdx

@@ -1,10 +1,121 @@
 ---
-title: "Reasoning AI Agents"
-sidebarTitle: "Reasoning"
-description: "Reasoning enables AI agents to think logically, solve complex problems autonomously, and make human-like decisions through multi-step logical reasoning."
-icon: "brain-circuit"
+title: "Reasoning Agents"
+description: "Learn how to create AI agents with advanced reasoning capabilities for complex problem-solving."
+icon: "brain"
 ---
 
+## Quick Start
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install praisonaiagents
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents, Tools
+
+            # Create reasoning agent
+            reasoner = Agent(
+                role="Problem Solver",
+                goal="Solve complex problems using logical reasoning",
+                backstory="Expert in logical analysis and problem-solving",
+                tools=[Tools.internet_search],
+                verbose=True
+            )
+
+            # Create task
+            task = Task(
+                description="Analyze and solve a complex business problem",
+                expected_output="Detailed solution with reasoning steps",
+                agent=reasoner
+            )
+
+            # Create and start the agents
+            agents = PraisonAIAgents(
+                agents=[reasoner],
+                tasks=[task],
+                process="sequential",
+                verbose=2
+            )
+
+            # Start execution
+            result = agents.start()
+            print(result)
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: solve complex business problem
+roles:
+  reasoner:
+    backstory: Expert in logical analysis and problem-solving.
+    goal: Solve complex problems using logical reasoning
+    role: Problem Solver
+    tools:
+      - internet_search
+    tasks:
+      analysis_task:
+        description: Analyze and solve a complex business problem.
+        expected_output: Detailed solution with reasoning steps.
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+  - Basic understanding of Python
+</Note>
+
 <div className="relative w-full aspect-video">
   <iframe
     className="absolute top-0 left-0 w-full h-full"
@@ -15,225 +126,210 @@ icon: "brain-circuit"
   ></iframe>
 </div>
 
-## Overview
+## Understanding Reasoning
 
-Reasoning in PraisonAI agents enables:
-- Autonomous problem solving
-- Multi-step logical reasoning
-- Human-like decision making
-- Deep comprehension of tasks
-- Error handling with alternative solutions
+<Card title="What is Reasoning?" icon="question">
+  Reasoning agents are designed to:
+  - Break down complex problems into manageable steps
+  - Apply logical analysis to find solutions
+  - Explain their thought process and decisions
+  - Handle uncertainty and incomplete information
+</Card>
 
-## Usage
+## Features
 
-Reasoning is controlled through reflection cycles using `min_reflect` and `max_reflect` parameters:
+<CardGroup cols={2}>
+  <Card title="Problem Decomposition" icon="puzzle-piece">
+    Break complex problems into smaller, manageable parts.
+  </Card>
+  <Card title="Logical Analysis" icon="brain">
+    Apply structured thinking to solve problems.
+  </Card>
+  <Card title="Error Recovery" icon="shield-check">
+    Handle edge cases and recover from errors.
+  </Card>
+  <Card title="Explanation" icon="comment">
+    Provide detailed reasoning for decisions.
+  </Card>
+</CardGroup>
+
+## Multi-Agent Reasoning
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install praisonaiagents
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents, Tools
+
+            # Create first agent for analysis
+            analyst = Agent(
+                role="Business Analyst",
+                goal="Analyze business problems and identify key issues",
+                backstory="Expert in business analysis and problem identification",
+                tools=[Tools.internet_search],
+                verbose=True
+            )
+
+            # Create second agent for solution development
+            solver = Agent(
+                role="Solution Architect",
+                goal="Develop comprehensive solutions to business problems",
+                backstory="Expert in solution design and implementation",
+                verbose=True
+            )
+
+            # Create first task
+            analysis_task = Task(
+                description="Analyze the current market challenges",
+                expected_output="Detailed analysis of key issues",
+                agent=analyst
+            )
+
+            # Create second task
+            solution_task = Task(
+                description="Develop solutions for identified challenges",
+                expected_output="Comprehensive solution strategy",
+                agent=solver
+            )
+
+            # Create and start the agents
+            agents = PraisonAIAgents(
+                agents=[analyst, solver],
+                tasks=[analysis_task, solution_task],
+                process="sequential"
+            )
+
+            # Start execution
+            result = agents.start()
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: solve market challenges
+roles:
+  analyst:
+    backstory: Expert in business analysis and problem identification.
+    goal: Analyze business problems and identify key issues
+    role: Business Analyst
+    tools:
+      - internet_search
+    tasks:
+      analysis_task:
+        description: Analyze the current market challenges.
+        expected_output: Detailed analysis of key issues.
+
+  solver:
+    backstory: Expert in solution design and implementation.
+    goal: Develop comprehensive solutions to business problems
+    role: Solution Architect
+    tasks:
+      solution_task:
+        description: Develop solutions for identified challenges.
+        expected_output: Comprehensive solution strategy.
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+### Configuration Options
 
 ```python
-from praisonaiagents import Agent
-
+# Create an agent with reasoning configuration
 agent = Agent(
-    name="SystemOps",
-    role="System Administrator",
-    goal="Manage and monitor system operations",
-    backstory="You are an expert system administrator",
-    min_reflect=6,  # Minimum reflection cycles
-    max_reflect=10  # Maximum reflection cycles
-)
-```
-
-## Benefits
-
-- **Deep Comprehension**: Instead of rule-based responses, agents understand tasks deeply
-- **Error Recovery**: Agents can reason through errors and find alternative solutions
-- **Step-by-Step Processing**: Complex tasks are broken down and processed systematically
-- **Quality Control**: Multiple reflection cycles ensure high-quality outputs
-- **Adaptive Problem Solving**: Agents can adjust their approach based on reasoning
-
-## Example
-
-Here's a complete example showing reasoning in action:
-
-```python
-from praisonaiagents import Agent, Task, PraisonAIAgents
-import subprocess
-import os
-
-def run_terminal_command(command: str):
-    """
-    Run a terminal command and return its output.
-    """
-    try:
-        result = subprocess.run(command, shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-        print(f"Command output: {result}")
-        return {"stdout": result.stdout, "stderr": result.stderr}
-    except subprocess.CalledProcessError as e:
-        return {"error": str(e), "stdout": e.stdout, "stderr": e.stderr}
-
-def save_to_file(file_path: str, content: str):
-    """
-    Save the given content to the specified file path. Create the folder/file if it doesn't exist.
-    """
-    # Ensure the directory exists
-    os.makedirs(os.path.dirname(file_path), exist_ok=True)
-    
-    # Write the content to the file
-    with open(file_path, 'w') as file:
-        file.write(content)
-
-    return file_path
-
-# Create System Operations Agent
-system_ops_agent = Agent(
-    name="SystemOps",
-    role="System Operations Specialist",
-    goal="Execute and manage complex system operations and commands",
-    backstory="""You are an expert system administrator with deep knowledge of Unix/Linux systems.
-    You excel at running complex system commands, managing processes, and handling system operations.
-    You always validate commands before execution and ensure they are safe to run.""",
-    min_reflect=6,
-    max_reflect=10,
-    tools=[run_terminal_command, save_to_file],
-    llm="gpt-4o-mini"
+    role="Problem Solver",
+    goal="Solve complex problems",
+    backstory="Expert in problem-solving",
+    tools=[Tools.internet_search],
+    verbose=True,  # Enable detailed logging
+    llm="gpt-4o"  # Language model to use
 )
 
-# Create a complex task that tests various system operations
+# Task with reasoning requirements
 task = Task(
-    name="system_analysis_task",
-    description="""Perform a comprehensive system analysis by executing the following operations in sequence:
-    1. Get system information (OS, kernel version)
-    2. List 5 running processes and sort them by CPU usage
-    3. Check disk space usage and list directories over 1GB
-    4. Display current system load and memory usage
-    5. List 5 network connections
-    6. Create a summary report with all findings in a text file called system_report.txt
-    
-    Do it step by step. One task at a time. 
-    Save only the Summary report in the file.
-    Use appropriate commands for each step and ensure proper error handling.""",
-    expected_output="A comprehensive system report containing all requested information saved in system_report.txt",
-    agent=system_ops_agent,
+    description="Solve complex problem",
+    expected_output="Detailed solution",
+    agent=agent
 )
-
-agents = PraisonAIAgents(
-    agents=[system_ops_agent],
-    tasks=[task],
-    process="sequential"
-)
-
-result = agents.start()
 ```
 
-## e2b Tool Integration Example
+## Troubleshooting
 
-```python
-from praisonaiagents import Agent, Task, PraisonAIAgents, error_logs
-import json
-from e2b_code_interpreter import Sandbox
+<CardGroup cols={2}>
+  <Card title="Reasoning Errors" icon="triangle-exclamation">
+    If reasoning seems incorrect:
+    - Check problem description clarity
+    - Enable verbose mode for debugging
+    - Review agent configuration
+  </Card>
 
-def code_interpret(code: str):
-    """
-    A function to demonstrate running Python code dynamically using e2b_code_interpreter.
-    """
-    print(f"\n{'='*50}\n> Running following AI-generated code:\n{code}\n{'='*50}")
-    exec_result = Sandbox().run_code(code)
-    if exec_result.error:
-        print("[Code Interpreter error]", exec_result.error)
-        return {"error": str(exec_result.error)}
-    else:
-        results = []
-        for result in exec_result.results:
-            if hasattr(result, '__iter__'):
-                results.extend(list(result))
-            else:
-                results.append(str(result))
-        logs = {"stdout": list(exec_result.logs.stdout), "stderr": list(exec_result.logs.stderr)}
-        return json.dumps({"results": results, "logs": logs})
+  <Card title="Process Flow" icon="code">
+    If process flow is unclear:
+    - Verify task dependencies
+    - Check agent roles and goals
+    - Review task descriptions
+  </Card>
+</CardGroup>
 
-# 1) Create Agents
-web_scraper_agent = Agent(
-    name="WebScraper",
-    role="Web Scraper",
-    goal="Extract URLs from https://quotes.toscrape.com/",
-    backstory="An expert in data extraction from websites, adept at navigating and retrieving detailed information.",
-    tools=[code_interpret],
-    llm="gpt-4o"
-)
+## Next Steps
 
-url_data_extractor_agent = Agent(
-    name="URLDataExtractor",
-    role="URL Data Extractor",
-    goal="Crawl each URL for data extraction",
-    backstory="Specializes in crawling websites to gather comprehensive data, ensuring nothing is missed from each link.",
-    tools=[code_interpret],
-    llm="gpt-4o"
-)
+<CardGroup cols={2}>
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
+  </Card>
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
+  </Card>
+</CardGroup>
 
-blog_writer_agent = Agent(
-    name="BlogWriter",
-    role="Creative Content Writer",
-    goal="Create engaging and insightful blog posts from provided data",
-    backstory="An experienced content creator and storyteller with a knack for weaving compelling narratives. Skilled at analyzing quotes and creating meaningful connections that resonate with readers.",
-    tools=[code_interpret],
-    llm="gpt-4o"
-)
-
-# 2) Create Tasks
-task_url_extraction = Task(
-    name="url_extraction_task",
-    description="""Use code_interpret to run Python code that fetches https://quotes.toscrape.com/
-    and extracts 5 URLs from the page, then outputs them as a list. Only first 5 urls""",
-    expected_output="A list of URLs extracted from the source page.",
-    agent=web_scraper_agent,
-    output_file="urls.txt" 
-)
-
-task_data_extraction = Task(
-    name="data_extraction_task",
-    description="""Take the URLs from url_extraction_task, crawl each URL and extract all pertinent
-    data using code_interpret to run Python code, then output raw txt, not the html.""",
-    expected_output="Raw data collected from each crawled URL.",
-    agent=url_data_extractor_agent,
-    context=[task_url_extraction]
-)
-
-blog_writing_task = Task(
-    name="blog_writing_task",
-    description="""Write an engaging blog post using the extracted quotes data. The blog post should:
-    1. Have a catchy title
-    2. Include relevant quotes from the data
-    3. Provide commentary and insights about the quotes
-    4. Be well-structured with introduction, body, and conclusion
-    5. Be approximately 500 words long""",
-    expected_output="A well-written blog post incorporating the extracted quotes with analysis",
-    agent=blog_writer_agent,
-    context=[task_data_extraction],
-    output_file="blog_post.txt"  
-)
-
-# 3) Create and run Agents manager
-agents_manager = PraisonAIAgents(
-    agents=[web_scraper_agent, url_data_extractor_agent, blog_writer_agent],
-    tasks=[task_url_extraction, task_data_extraction, blog_writing_task],
-    verbose=True,
-    process="hierarchical",
-    manager_llm="gpt-4o"
-)
-
-result = agents_manager.start()
-```
-
-## Integration with Tools
-
-Reasoning works particularly well with tools that require complex decision-making:
-
-- **Code Interpreter**: For dynamic code generation and execution
-- **System Operations**: For multi-step system management tasks
-- **Data Analysis**: For complex data processing workflows
-- **Web Scraping**: For intelligent data extraction and processing
-
-## Performance Considerations
-
-- Higher reflection cycles mean more thorough reasoning but longer processing time
-- `min_reflect` ensures minimum quality standards
-- `max_reflect` prevents excessive processing
-- Balance based on task complexity and quality requirements
+<Note>
+  For optimal results, ensure your problem descriptions are clear and provide sufficient context for the reasoning agents.
+</Note>

docs/features/selfreflection.mdx

@@ -1,10 +1,125 @@
 ---
 title: "Self Reflection AI Agents"
-sidebarTitle: "Self-Reflection"
-description: "Self-reflection is a powerful feature in PraisonAI that enables agents to evaluate and improve their own responses before delivering them. This leads to higher quality outputs and more reliable task completion."
+sidebarTitle: "Self Reflection Agents"
+description: "Self-reflection enables agents to evaluate and improve their own responses before delivering them."
 icon: "brain"
 ---
 
+## Quick Start
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install praisonaiagents
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents
+
+            # Create an agent with self-reflection
+            agent = Agent(
+                role="Senior Research Analyst",
+                goal="Analyze and provide insights on given topics",
+                backstory="You are an expert analyst with strong critical thinking skills",
+                self_reflect=True  # Enable self-reflection
+            )
+
+            # Create a task
+            task = Task(
+                description="Analyze recent developments in AI",
+                expected_output="A detailed analysis report",
+                agent=agent
+            )
+
+            # Create and start the agents
+            agents = PraisonAIAgents(
+                agents=[agent],
+                tasks=[task],
+                process="sequential",
+                verbose=2
+            )
+
+            # Start execution
+            agents.start()
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: create movie script about cat in mars
+roles:
+  scriptwriter:
+    backstory: Expert in dialogue and script structure, translating concepts into
+      scripts.
+    goal: Write a movie script about a cat in Mars
+    role: Scriptwriter
+    self_reflect: true
+    min_reflect: 1
+    max_reflect: 2
+    tasks:
+      scriptwriting_task:
+        description: Turn the story concept into a production-ready movie script,
+          including dialogue and scene details.
+        expected_output: Final movie script with dialogue and scene details.
+    tools:
+    - search_tool
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+<Note>
+  **Requirements**
+
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+</Note>
+
 <div className="relative w-full aspect-video">
   <iframe
     className="absolute top-0 left-0 w-full h-full"
@@ -15,88 +130,209 @@ icon: "brain"
   ></iframe>
 </div>
 
-## Overview
+## Understanding Self-Reflection
 
-When an agent with self-reflection enabled processes a task:
-1. It generates an initial response using its tools and capabilities
-2. The agent then reflects on its own response, evaluating:
-   - Completeness
-   - Accuracy
-   - Relevance
-   - Quality
-3. Based on this reflection, the agent may revise and improve its response
-4. This cycle can repeat until the agent is satisfied with the quality
+<Card title="What is Self-Reflection?" icon="question">
+  Self-reflection enables agents to:
+  - Evaluate their own responses before delivery
+  - Check for completeness and accuracy
+  - Improve output quality through iteration
+  - Ensure task requirements are met
+  - Make conscious decisions about their responses
+</Card>
 
-## Usage
+## Features
 
-Self-reflection is enabled by default for all agents. You can explicitly control it using the `self_reflect` parameter:
+<CardGroup cols={2}>
+  <Card title="Quality Assurance" icon="check-double">
+    Evaluates and improves response quality through self-review.
+  </Card>
+  <Card title="Iterative Improvement" icon="rotate">
+    Refines responses through multiple reflection cycles.
+  </Card>
+  <Card title="Task Validation" icon="list-check">
+    Ensures all aspects of the task are properly addressed.
+  </Card>
+  <Card title="Conscious Decision Making" icon="brain">
+    Enables thoughtful evaluation of responses.
+  </Card>
+</CardGroup>
+
+## Multi-Agent Self-Reflection
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install praisonaiagents
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents
+
+            # Create first agent with self-reflection
+            researcher = Agent(
+                role="Senior Research Analyst",
+                goal="Research and analyze AI developments",
+                backstory="Expert analyst specializing in AI trends and impacts",
+                self_reflect=True,
+                verbose=True
+            )
+
+            # Create second agent with self-reflection
+            writer = Agent(
+                role="Technical Writer",
+                goal="Transform research into clear documentation",
+                backstory="Experienced in creating technical content and documentation",
+                self_reflect=True,
+                verbose=True
+            )
+
+            # Create first task
+            research_task = Task(
+                description="Research and analyze recent AI developments",
+                expected_output="Comprehensive analysis of AI trends",
+                agent=researcher
+            )
+
+            # Create second task
+            documentation_task = Task(
+                description="Create technical documentation from research findings",
+                expected_output="Well-structured technical documentation",
+                agent=writer
+            )
+
+            # Create and start the agents
+            agents = PraisonAIAgents(
+                agents=[researcher, writer],
+                tasks=[research_task, documentation_task],
+                process="sequential"
+            )
+
+            # Start execution
+            agents.start()
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai duckduckgo_search
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: create technical documentation about AI trends
+roles:
+  researcher:
+    backstory: Expert analyst specializing in AI trends and their implications.
+    goal: Research and analyze current AI developments
+    role: Senior Research Analyst
+    self_reflect: true
+    min_reflect: 1
+    max_reflect: 2
+    tasks:
+      research_task:
+        description: Research and analyze recent developments in AI technology.
+        expected_output: Comprehensive analysis of current AI trends.
+    tools:
+    - duckduckgo
+
+  writer:
+    backstory: Experienced technical writer skilled in creating clear documentation.
+    goal: Transform research into accessible documentation
+    role: Technical Writer
+    tasks:
+      documentation_task:
+        description: Create technical documentation from research findings.
+        expected_output: Well-structured technical documentation.
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+### Configuration Options
 
 ```python
-from praisonaiagents import Agent
-
+# Create an agent with advanced self-reflection configuration
 agent = Agent(
-    name="Researcher",
-    role="Senior Research Analyst",
-    goal="Uncover cutting-edge developments in AI",
-    backstory="You are an expert at analyzing tech trends",
-    self_reflect=True  # Enable self-reflection (default)
+    role="Research Analyst",
+    goal="Provide comprehensive analysis",
+    backstory="Expert analyst with critical thinking skills",
+    self_reflect=True,  # Enable self-reflection
+    verbose=True,  # Enable detailed logging
+    llm="gpt-4o",  # Language model to use
+    allow_delegation=True  # Allow task delegation
 )
 ```
 
-## Benefits
+## Troubleshooting
 
-- **Higher Quality Outputs**: Agents can catch and correct potential issues before delivering responses
-- **More Reliable Task Completion**: Self-reflection helps ensure all aspects of a task are properly addressed
-- **Conscious Decision Making**: Agents evaluate their own work, leading to more thoughtful responses
-- **Improved Accuracy**: Multiple reflection cycles help refine and perfect the output
+<CardGroup cols={2}>
+  <Card title="Response Issues" icon="rotate">
+    If responses are not meeting expectations:
+    - Enable verbose mode for debugging
+    - Review agent configuration
+    - Check task description clarity
+  </Card>
 
-## Integration with Processes
+  <Card title="Quality Issues" icon="triangle-exclamation">
+    If output quality is insufficient:
+    - Enable verbose mode
+    - Review agent role and goal
+    - Clarify expected output
+  </Card>
+</CardGroup>
 
-Self-reflection works seamlessly with both sequential and hierarchical processes:
+## Next Steps
 
-- **Sequential**: Each agent self-reflects on their individual tasks
-- **Hierarchical**: Agents self-reflect before reporting to the manager agent, ensuring high-quality inputs for decision-making
+<CardGroup cols={2}>
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
+  </Card>
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
+  </Card>
+</CardGroup>
 
-## Example
-
-Here's a complete example showing self-reflection in action:
-
-```python
-from praisonaiagents import Agent, Task, PraisonAIAgents
-
-researcher = Agent(
-    name="Researcher",
-    role="Senior Research Analyst",
-    goal="Uncover cutting-edge developments in AI",
-    backstory="You are an expert at analyzing tech trends",
-    self_reflect=True,
-    llm="gpt-4o"
-)
-
-task = Task(
-    name="research_task",
-    description="Analyze 2024's AI advancements",
-    expected_output="A detailed report on AI trends",
-    agent=researcher
-)
-
-agents = PraisonAIAgents(
-    agents=[researcher],
-    tasks=[task],
-    process="sequential"
-)
-
-result = agents.start()
-```
-
-In this example, the researcher agent will:
-1. Research AI advancements
-2. Generate an initial report
-3. Self-reflect on the report's quality
-4. Make improvements if needed
-5. Deliver the final, refined output
-
-## Performance Impact
-
-While self-reflection adds additional processing time, the improvement in output quality often justifies the extra computation. 
-The number of reflection cycles need to be manually optimized to balance quality and performance.
+<Note>
+  For optimal results, configure reflection parameters based on your specific use case requirements.
+</Note>

docs/features/structured.mdx

@@ -4,62 +4,133 @@ description: "Learn how to create AI agents that return structured, type-safe ou
 icon: "cube"
 ---
 
-<Note>
-  **Prerequisites**
-  - Python 3.10 or higher
-  - PraisonAI Agents package installed
-  - Basic understanding of Python and Pydantic
-</Note>
-
 ## Quick Start
 
-Create AI agents that return structured, validated outputs in just a few lines of code!
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install praisonaiagents
+            ```
+        </Step>
 
-<Steps>
-  <Step title="Install Package">
-    First, install the PraisonAI Agents package:
-    ```bash
-    pip install praisonaiagents
-    ```
-  </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
 
-  <Step title="Import Required Components">
-    Import the necessary components:
-    ```python
-    from praisonaiagents import Agent, Task, PraisonAIAgents, Tools
-    from pydantic import BaseModel
-    ```
-  </Step>
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents, Tools
+            from pydantic import BaseModel
 
-  <Step title="Define Your Data Model">
-    Create a Pydantic model to define your output structure:
-    ```python
-    class AnalysisReport(BaseModel):
-        title: str
-        findings: str
-        summary: str
-    ```
-  </Step>
+            # Define your data structure
+            class AnalysisReport(BaseModel):
+                title: str
+                findings: str
+                summary: str
 
-  <Step title="Create Structured Tasks">
-    Create tasks with structured outputs:
-    ```python
-    research_task = Task(
-        description="Research recent AI developments",
-        agent=researcher,
-        expected_output="Research findings"
-    )
+            # Create agent
+            analyst = Agent(
+                role="Data Analyst",
+                goal="Analyze data and provide structured insights",
+                backstory="Expert in data analysis and insights generation",
+                tools=[Tools.internet_search],
+                verbose=True
+            )
 
-    analysis_task = Task(
-        description="Analyze research findings",
-        agent=analyst,
-        output_pydantic=AnalysisReport,  # For Pydantic output
-        # or output_json=AnalysisReport  # For JSON output
-        expected_output="Structured analysis report"
-    )
-    ```
-  </Step>
-</Steps>
+            # Create task with structured output
+            task = Task(
+                description="Analyze recent AI developments",
+                expected_output="Structured analysis report",
+                agent=analyst,
+                output_pydantic=AnalysisReport
+            )
+
+            # Create and start the agents
+            agents = PraisonAIAgents(
+                agents=[analyst],
+                tasks=[task],
+                process="sequential",
+                verbose=2
+            )
+
+            # Start execution
+            result = agents.start()
+            print(result.pydantic.title)
+            print(result.pydantic.findings)
+            print(result.pydantic.summary)
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: analyze AI developments with structured output
+roles:
+  analyst:
+    backstory: Expert in data analysis and insights generation.
+    goal: Analyze data and provide structured insights
+    role: Data Analyst
+    tools:
+      - internet_search
+    tasks:
+      analysis_task:
+        description: Analyze recent AI developments.
+        expected_output: Structured analysis report.
+        output_structure:
+          type: pydantic
+          model:
+            title: str
+            findings: str
+            summary: str
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+  - Basic understanding of Python and Pydantic
+</Note>
 
 ## Understanding Structured Outputs
 
@@ -71,221 +142,196 @@ Create AI agents that return structured, validated outputs in just a few lines o
   - Ensure consistent output format across agent responses
 </Card>
 
-## Key Components
+## Features
 
 <CardGroup cols={2}>
   <Card title="Pydantic Models" icon="cube">
-    Define your data structure
-    ```python
-    class ResearchReport(BaseModel):
-        title: str
-        content: str
-    ```
-  </Card>
-  <Card title="Task Configuration" icon="gear">
-    Configure output format
-    ```python
-    Task(output_pydantic=Model)
-    # or
-    Task(output_json=Model)
-    ```
-  </Card>
-  <Card title="Output Validation" icon="check">
-    Automatic validation of responses against your model
-  </Card>
-  <Card title="Format Options" icon="code">
-    Choose between Pydantic objects or JSON output
-  </Card>
-</CardGroup>
-
-## Output Types
-
-<CardGroup cols={2}>
-  <Card title="Pydantic Output" icon="cube">
-    ```python
-    task = Task(
-        output_pydantic=AnalysisReport
-    )
-    # Returns Pydantic object
-    ```
-    Get type-safe Pydantic model instances
+    Define exact data structures with validation.
   </Card>
   <Card title="JSON Output" icon="brackets-curly">
-    ```python
-    task = Task(
-        output_json=AnalysisReport
-    )
-    # Returns JSON dict
-    ```
-    Get JSON dictionary matching model schema
+    Get structured JSON responses.
+  </Card>
+  <Card title="Type Safety" icon="shield-check">
+    Ensure type-safe, validated outputs.
+  </Card>
+  <Card title="Format Options" icon="code">
+    Choose between Pydantic or JSON.
   </Card>
 </CardGroup>
 
-## Examples
+## Multi-Agent Structured Analysis
 
-### Research Analysis with Structured Output
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+        <Step title="Install Package">
+            First, install the PraisonAI Agents package:
+            ```bash
+            pip install praisonaiagents
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+
+        <Step title="Create a file">
+            Create a new file `app.py` with the basic setup:
+            ```python
+            from praisonaiagents import Agent, Task, PraisonAIAgents, Tools
+            from pydantic import BaseModel
+
+            # Define output structures
+            class ResearchReport(BaseModel):
+                topic: str
+                findings: str
+                sources: list[str]
+
+            class Analysis(BaseModel):
+                key_points: list[str]
+                implications: str
+                recommendations: str
+
+            # Create first agent for research
+            researcher = Agent(
+                role="Research Analyst",
+                goal="Gather and structure research data",
+                backstory="Expert in research and data collection",
+                tools=[Tools.internet_search],
+                verbose=True
+            )
+
+            # Create second agent for analysis
+            analyst = Agent(
+                role="Data Analyst",
+                goal="Analyze research and provide structured insights",
+                backstory="Expert in data analysis and insights generation",
+                verbose=True
+            )
+
+            # Create first task
+            research_task = Task(
+                description="Research quantum computing developments",
+                expected_output="Structured research findings",
+                agent=researcher,
+                output_pydantic=ResearchReport
+            )
+
+            # Create second task
+            analysis_task = Task(
+                description="Analyze research implications",
+                expected_output="Structured analysis report",
+                agent=analyst,
+                output_pydantic=Analysis
+            )
+
+            # Create and start the agents
+            agents = PraisonAIAgents(
+                agents=[researcher, analyst],
+                tasks=[research_task, analysis_task],
+                process="sequential"
+            )
+
+            # Start execution
+            result = agents.start()
+            ```
+        </Step>
+
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+            ```bash
+            python app.py
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+        <Step title="Install Package">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_api_key_here
+            ```
+        </Step>
+        <Step title="Create a file">
+            Create a new file `agents.yaml` with the basic setup:
+```yaml
+framework: praisonai
+process: sequential
+topic: research and analyze quantum computing
+roles:
+  researcher:
+    backstory: Expert in research and data collection.
+    goal: Gather and structure research data
+    role: Research Analyst
+    tools:
+      - internet_search
+    tasks:
+      research_task:
+        description: Research quantum computing developments.
+        expected_output: Structured research findings.
+        output_structure:
+          type: pydantic
+          model:
+            topic: str
+            findings: str
+            sources: list[str]
+
+  analyst:
+    backstory: Expert in data analysis and insights generation.
+    goal: Analyze research and provide structured insights
+    role: Data Analyst
+    tasks:
+      analysis_task:
+        description: Analyze research implications.
+        expected_output: Structured analysis report.
+        output_structure:
+          type: pydantic
+          model:
+            key_points: list[str]
+            implications: str
+            recommendations: str
+```
+        </Step>
+        <Step title="Start Agents">
+            Type this in your terminal to run your agents:
+```bash
+praisonai agents.yaml
+```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+### Configuration Options
 
 ```python
-from praisonaiagents import Agent, Task, PraisonAIAgents, Tools
-from pydantic import BaseModel
-
-# Define output structure
-class AnalysisReport(BaseModel):
-    title: str
-    findings: str
-    summary: str
-
-# Create agents
-researcher = Agent(
-    name="AIResearcher",
-    role="Technology Research Analyst",
-    tools=[Tools.internet_search]
+# Create an agent with structured output configuration
+agent = Agent(
+    role="Data Analyst",
+    goal="Provide structured analysis",
+    backstory="Expert in data analysis",
+    tools=[Tools.internet_search],
+    verbose=True,  # Enable detailed logging
+    llm="gpt-4o"  # Language model to use
 )
 
-analyst = Agent(
-    name="DataAnalyst",
-    role="Data Insights Specialist"
-)
-
-# Define structured tasks
-research_task = Task(
-    name="gather_research",
-    description="Research recent AI developments in 2024",
-    agent=researcher,
-    expected_output="Research findings"
-)
-
-analysis_task = Task(
-    name="analyze_findings",
-    description="Analyze research findings and create structured report",
-    agent=analyst,
-    output_pydantic=AnalysisReport,
-    expected_output="Structured analysis report"
-)
-
-# Initialize and run agents
-agents = PraisonAIAgents(
-    agents=[researcher, analyst],
-    tasks=[research_task, analysis_task]
-)
-result = agents.start()
-```
-
-### Different Output Formats
-
-<CodeGroup>
-```python Pydantic
-# Get Pydantic model instance
-analysis_task = Task(
-    description="Analyze findings",
-    agent=analyst,
-    output_pydantic=AnalysisReport
-)
-
-# Result will be AnalysisReport instance
-result.pydantic.title
-result.pydantic.findings
-result.pydantic.summary
-```
-
-```python JSON
-# Get JSON dictionary
-analysis_task = Task(
-    description="Analyze findings",
-    agent=analyst,
-    output_json=AnalysisReport
-)
-
-# Result will be dictionary
-result.json_dict['title']
-result.json_dict['findings']
-result.json_dict['summary']
-```
-</CodeGroup>
-
-## Best Practices
-
-<AccordionGroup>
-  <Accordion title="Model Design">
-    Design clear, focused Pydantic models:
-    ```python
-    # Good
-    class ResearchReport(BaseModel):
-        title: str
-        findings: str
-        summary: str
-    
-    # Too complex
-    class Report(BaseModel):
-        title: str
-        subtitle: Optional[str]
-        findings: List[Dict[str, Any]]
-    ```
-  </Accordion>
-
-  <Accordion title="Output Format Selection">
-    Choose the right output format:
-    ```python
-    # Use Pydantic when you need:
-    # - Type validation
-    # - Model methods
-    task = Task(output_pydantic=Model)
-    
-    # Use JSON when you need:
-    # - Simple dictionary access
-    # - Serialization
-    task = Task(output_json=Model)
-    ```
-  </Accordion>
-</AccordionGroup>
-
-## Common Patterns
-
-### Research and Structured Analysis
-```python
-class ResearchReport(BaseModel):
-    topic: str
-    findings: str
-    sources: list[str]
-
-class Analysis(BaseModel):
-    key_points: list[str]
-    implications: str
-    recommendations: str
-
-research_task = Task(
-    description="Research quantum computing",
-    agent=researcher,
-    output_pydantic=ResearchReport
-)
-
-analysis_task = Task(
-    description="Analyze research implications",
-    agent=analyst,
-    output_pydantic=Analysis
-)
-```
-
-### Data Collection and Summary
-```python
-class DataPoint(BaseModel):
-    timestamp: str
-    value: float
-    source: str
-
-class Summary(BaseModel):
-    average: float
-    trends: str
-    insights: str
-
-collection_task = Task(
-    description="Collect data points",
-    output_pydantic=DataPoint
-)
-
-summary_task = Task(
-    description="Summarize data",
-    output_pydantic=Summary
+# Task with Pydantic output
+task = Task(
+    description="Analyze data",
+    expected_output="Structured report",
+    agent=agent,
+    output_pydantic=AnalysisReport  # Use Pydantic model
+    # or output_json=AnalysisReport  # Use JSON output
 )
 ```
 
@@ -293,30 +339,31 @@ summary_task = Task(
 
 <CardGroup cols={2}>
   <Card title="Validation Errors" icon="triangle-exclamation">
-    Check if your model matches the expected output structure
-    ```python
-    # Print model schema
-    print(Model.schema_json())
-    ```
+    If model validation fails:
+    - Check data types match model
+    - Verify required fields
+    - Enable verbose mode for debugging
   </Card>
+
   <Card title="Output Format" icon="code">
-    Verify you're accessing the right output field:
-    - `result.pydantic` for Pydantic
-    - `result.json_dict` for JSON
+    If output format is incorrect:
+    - Verify model definition
+    - Check output_pydantic vs output_json
+    - Review field specifications
   </Card>
 </CardGroup>
 
 ## Next Steps
 
 <CardGroup cols={2}>
-  <Card title="Advanced Models" icon="graduation-cap" href="./advanced-models">
-    Learn about advanced Pydantic model configurations
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
   </Card>
-  <Card title="Custom Validation" icon="check-double" href="./validation">
-    Add custom validation to your models
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
   </Card>
 </CardGroup>
 
 <Note>
-  Structured outputs make your AI agents more reliable and their responses more predictable. They're perfect for production systems where data consistency is crucial.
+  For optimal results, ensure your Pydantic models accurately represent your desired output structure.
 </Note>

docs/framework/multimodalagents.mdx

@@ -1,198 +0,0 @@
----
-title: "Multimodal AI Agents"
-description: "Guide for creating and using multimodal AI agents in PraisonAI for processing images, videos, and other media types"
-icon: "images"
----
-
-<div className="relative w-full aspect-video">
-  <iframe
-    className="absolute top-0 left-0 w-full h-full"
-    src="https://www.youtube.com/embed/hjAWmUT1qqY"
-    title="YouTube video player"
-    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-    allowFullScreen
-  ></iframe>
-</div>
-
-# Multimodal AI Agents
-
-PraisonAI supports multimodal AI agents capable of processing various types of media including images and videos. This enables you to create agents that can understand and analyze visual content alongside text.
-
-## Installation
-
-```bash
-pip install praisonaiagents
-export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
-```
-
-## Quick Start
-
-Create `multimodal_app.py` and add the following code:
-
-```python
-from praisonaiagents import Agent, Task, PraisonAIAgents
-
-# Create Vision Analysis Agent
-vision_agent = Agent(
-    name="VisionAnalyst",
-    role="Computer Vision Specialist",
-    goal="Analyze images and videos to extract meaningful information",
-    backstory="""You are an expert in computer vision and image analysis.
-    You excel at describing images, detecting objects, and understanding visual content.""",
-    llm="gpt-4o-mini",
-    self_reflect=False
-)
-
-# Create tasks with different media types
-task = Task(
-    name="analyze_landmark",
-    description="Describe this famous landmark and its architectural features.",
-    expected_output="Detailed description of the landmark's architecture and significance",
-    agent=vision_agent,
-    images=["https://upload.wikimedia.org/wikipedia/commons/b/bf/Krakow_-_Kosciol_Mariacki.jpg"]
-)
-
-# Run the agents
-agents = PraisonAIAgents(
-    agents=[vision_agent],
-    tasks=[task],
-    process="sequential",
-    verbose=True
-)
-
-result = agents.start()
-print(result)
-```
-
-## Agent Configuration
-
-### Core Attributes
-- All standard agent attributes apply (role, goal, backstory, etc.)
-- `llm`: Must be a model that supports vision capabilities (e.g., "gpt-4o-mini")
-- `verbose`: Enable detailed logs (default: False)
-
-## Task Configuration
-
-### Media Support
-Tasks can include various types of media through the `images` parameter:
-
-1. **Image URLs**
-```python
-task = Task(
-    description="Analyze the image",
-    images=["https://example.com/image.jpg"]
-)
-```
-
-2. **Local Image Files**
-```python
-task = Task(
-    description="Analyze the local image",
-    images=["path/to/local/image.jpg"]
-)
-```
-
-3. **Video Files**
-```python
-task = Task(
-    description="Analyze the video content",
-    images=["path/to/video.mp4"]
-)
-```
-
-### Task Types
-
-1. **Image Analysis**
-- Object detection
-- Scene description
-- Architectural analysis
-- Text extraction from images
-
-2. **Video Analysis**
-- Event summarization
-- Object tracking
-- Action recognition
-- Text and caption extraction
-
-## Advanced Features
-
-### Multiple Media Sources
-Tasks can process multiple media sources simultaneously:
-
-```python
-task = Task(
-    description="Compare these images and describe the differences",
-    images=[
-        "https://example.com/image1.jpg",
-        "https://example.com/image2.jpg"
-    ]
-)
-```
-
-### Combining Text and Visual Analysis
-Create tasks that leverage both text and visual understanding:
-
-```python
-task = Task(
-    description="""Analyze this technical diagram and:
-    1. Explain the components
-    2. Describe their relationships
-    3. Identify any text or labels
-    4. Provide technical insights""",
-    images=["diagram.jpg"]
-)
-```
-
-## Best Practices
-
-1. **Media Handling**
-   - Ensure images are in supported formats (JPEG, PNG, etc.)
-   - Keep video files within reasonable size limits
-   - Provide clear, high-quality media for best results
-
-2. **Task Design**
-   - Write clear, specific descriptions
-   - Break complex analyses into subtasks
-   - Include expected output format
-
-3. **Performance Optimization**
-   - Use appropriate model versions for your needs
-   - Consider caching for repeated analyses
-   - Monitor token usage with visual content
-
-4. **Error Handling**
-   - Validate media files before processing
-   - Handle missing or corrupted files gracefully
-   - Implement retry logic for failed analyses
-
-## Example Use Cases
-
-1. **Document Analysis**
-```python
-document_task = Task(
-    description="Extract and summarize text from this document image",
-    expected_output="Structured text content with key information highlighted",
-    agent=vision_agent,
-    images=["document.jpg"]
-)
-```
-
-2. **Security Monitoring**
-```python
-security_task = Task(
-    description="Monitor this security camera feed and report any suspicious activity",
-    expected_output="Detailed report of detected events and anomalies",
-    agent=vision_agent,
-    images=["security_feed.mp4"]
-)
-```
-
-3. **Medical Imaging**
-```python
-medical_task = Task(
-    description="Analyze this medical scan and identify any abnormalities",
-    expected_output="Professional medical image analysis report",
-    agent=vision_agent,
-    images=["medical_scan.jpg"]
-)
-``` 

docs/installation.mdx

@@ -1,64 +1,115 @@
 ---
-title: "Installation"
-description: "Guide for installing PraisonAI and its various components including framework support and additional features"
-icon: "download"
+title: Installation
+description: Set up PraisonAI in your development environment
+icon: download
 ---
 
-## Basic Installation
-```bash
+<RequestExample>
+```bash Code
+pip install praisonaiagents
+```
+```bash No Code
 pip install praisonai
 ```
+</RequestExample>
 
-## Framework-specific Installation
+<Note>
+  **Requirements**
+  
+  - Python 3.10 or higher
+  - pip package manager
+  - Virtual environment (recommended)
+</Note>
 
-### PraisonAI Agents Support (Default)
+# Installing PraisonAI
 
-```bash
-pip install praisonai
-``` 
+Follow these steps to set up PraisonAI in your development environment.
+<Tabs>
+  <Tab title="Code">
 
-### CrewAI Support
-```bash
-pip install "praisonai[crewai]"
-```
+    <Steps>
+      <Step title="Create Virtual Environment (Optional)">
+        First, create and activate a virtual environment:
+        <CodeGroup>
+        ```bash Mac/Linux
+        python -m venv praisonai-env
+        source praisonai-env/bin/activate
+        ```
 
-Includes:
-- CrewAI framework
-- PraisonAI tools integration
-- Task delegation capabilities
-- Sequential and parallel task execution
+        ```bash Windows
+        python -m venv praisonai-env
+        .\praisonai-env\Scripts\activate
+        ```
+        </CodeGroup>
+      </Step>
 
-### AutoGen Support
-```bash
-pip install "praisonai[autogen]"
-```
+      <Step title="Install PraisonAI Agents">
+        Install the core PraisonAI Package:
+        ```bash Terminal
+        pip install praisonaiagents
+        ```
+      </Step>
 
-Includes:
-- AutoGen framework
-- PraisonAI tools integration
-- Multi-agent conversation capabilities
-- Code execution environment
+      <Step title="Configure Environment">
+        Set your OpenAI API key as an environment variable in your terminal:
+  ```bash Terminal
+  export OPENAI_API_KEY=your_openai_key
+  ```
+      </Step>
 
-### Both Frameworks
-```bash
-pip install "praisonai[crewai,autogen]"
-```
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
 
-## Additional Features
+    <Steps>
+        <Step title="Create Virtual Environment (Optional)">
+        First, create and activate a virtual environment:
+        <CodeGroup>
+        ```bash Mac/Linux
+        python -m venv praisonai-env
+        source praisonai-env/bin/activate
+        ```
 
-```bash
-# UI support
-pip install "praisonai[ui]"
+        ```bash Windows
+        python -m venv praisonai-env
+        .\praisonai-env\Scripts\activate
+        ```
+        </CodeGroup>
+      </Step>
+        <Step title="Install PraisonAI">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_openai_key
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
 
-# Chat interface
-pip install "praisonai[chat]"
+Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
+You can also use other LLM providers like Anthropic, Google, etc. Please refer to the [Models](/models) for more information.
 
-# Code interface
-pip install "praisonai[code]"
+## Next Steps
 
-# Realtime voice interaction
-pip install "praisonai[realtime]"
-
-# Call feature
-pip install "praisonai[call]"
-```
+<CardGroup cols={2}>
+  <Card
+    title="Quick Start Guide"
+    icon="bolt"
+    href="/code/quickstart"
+  >
+    Build your first AI agent
+  </Card>
+  <Card
+    title="API Reference"
+    icon="code"
+    href="/api/praisonaiagents/index"
+  >
+    Explore the API documentation
+  </Card>
+</CardGroup> 

docs/introduction.mdx

@@ -1,76 +1,361 @@
 ---
-title: 'Introduction'
-description: 'Get started with PraisonAI, an intelligent AI-powered tool'
-icon: "hand-wave"
+title: "Introduction"
+description: "Welcome to PraisonAI - The Next Generation AI Agent Framework"
+icon: "book-open"
 ---
 
+## What is PraisonAI?
+
 <Note>
-  PraisonAI is a low-code, centralized framework designed to simplify the creation and orchestration of multi-agent systems for various LLM applications.
+  PraisonAI is a powerful Multi-Agent Framework for building and deploying AI agents that can understand, reason, and execute complex tasks autonomously.
 </Note>
-
-# Welcome to PraisonAI
-
-<Frame caption="PraisonAI Framework Overview">
-  ![PraisonAI Overview](/images/praisonai-overview.png)
-</Frame>
-
-## Core Features
-
-<CardGroup cols={2}>
-  <Card title="Multi-Agent Systems" icon="users">
-    Create and orchestrate sophisticated multi-agent systems with ease
-  </Card>
-  <Card title="Framework Integration" icon="puzzle-piece">
-    Seamlessly integrates AutoGen and CrewAI capabilities
-  </Card>
-  <Card title="Low-Code Design" icon="code">
-    Build complex AI systems with minimal coding required
-  </Card>
-  <Card title="Human-AI Interaction" icon="people-arrows">
-    Enhanced support for human-agent collaboration
+<CardGroup cols={1}>
+  <Card title="Welcome to PraisonAI" icon="wand-magic-sparkles">
+    Build powerful autonomous agents that understand, decide, and execute with unprecedented capability.
   </Card>
 </CardGroup>
 
-## Getting Started
+# Core Components
+<br />
+```mermaid
+graph LR
+    %% Define the main flow
+    Start([▶ Start]) --> Agent1
+    Agent1 --> Process[⚙ Process]
+    Process --> Agent2
+    Agent2 --> Output([✓ Output])
+    Process -.-> Agent1
+    
+    %% Styling for main elements
+    style Start fill:#2D3047,stroke:#7C90A0,color:#fff
+    style Output fill:#2D3047,stroke:#7C90A0,color:#fff
+    style Process fill:#5C80BC,stroke:#7C90A0,color:#fff
+    
+    %% Define subgraphs for agents and their tasks
+    subgraph Agent1[" "]
+        Task1[📋 Task]
+        AgentIcon1[🤖 AI Agent]
+        Tools1[🔧 Tools]
+        
+        Task1 --- AgentIcon1
+        AgentIcon1 --- Tools1
+        
+        style Task1 fill:#2D3047,stroke:#7C90A0,color:#fff
+        style AgentIcon1 fill:#5C80BC,stroke:#7C90A0,color:#fff
+        style Tools1 fill:#2D3047,stroke:#7C90A0,color:#fff
+    end
+    
+    subgraph Agent2[" "]
+        Task2[📋 Task]
+        AgentIcon2[🤖 AI Agent]
+        Tools2[🔧 Tools]
+        
+        Task2 --- AgentIcon2
+        AgentIcon2 --- Tools2
+        
+        style Task2 fill:#2D3047,stroke:#7C90A0,color:#fff
+        style AgentIcon2 fill:#5C80BC,stroke:#7C90A0,color:#fff
+        style Tools2 fill:#2D3047,stroke:#7C90A0,color:#fff
+    end
+    
+    %% Style for agent containers
+    style Agent1 fill:#1B1F3B,stroke:#7C90A0,color:#fff
+    style Agent2 fill:#1B1F3B,stroke:#7C90A0,color:#fff
+    
+    %% Global styles
+    classDef default fill:#2D3047,stroke:#7C90A0,color:#fff
+    linkStyle default stroke:#7C90A0,stroke-width:2px
+```
+<br />
+<CardGroup cols={2}>
+  <Card title="Agents" icon="user-robot">
+    Autonomous AI entities that can understand context and execute tasks
+  </Card>
+  <Card title="Tasks" icon="list-check">
+    Units of work that agents can execute independently or collaboratively
+  </Card>
+  <Card title="Process" icon="diagram-project">
+    Workflow management for coordinating agent activities
+  </Card>
+  <Card title="Tools" icon="toolbox">
+    Extensible capabilities that agents can leverage
+  </Card>
+</CardGroup>
 
-<Steps>
-  <Step title="Installation">
-    Follow our [Installation Guide](./installation) to set up PraisonAI
-  </Step>
-  <Step title="Quick Overview">
-    Check out our [TL;DR](./tldr) for a rapid introduction
-  </Step>
-  <Step title="First Project">
-    Create your first project following our [Quick Start](./quickstart) guide
-  </Step>
-</Steps>
-
-## Key Components
-
-| Component | Description | Benefits |
-|:----------|:------------|:---------|
-| **UI Tools** | Intuitive interface components | Easy system interaction and monitoring |
-| **Model Integration** | Support for various LLM models | Flexibility in AI model selection |
-| **Tool System** | Extensible tool framework | Custom capability integration |
-| **API Layer** | Comprehensive API access | Full programmatic control |
-
-## Explore Further
+## Use Cases
 
 <CardGroup cols={2}>
-  <Card title="User Interface" icon="desktop" href="./ui/ui">
-    Learn about our intuitive UI components
+  <Card title="Customer Service" icon="headset">
+    Build intelligent support agents that can handle customer inquiries and resolve issues autonomously.
   </Card>
-  <Card title="Models" icon="robot" href="./models">
-    Explore supported AI models
+  <Card title="Data Analysis" icon="chart-line">
+    Create agents that can process, analyze, and derive insights from complex datasets.
   </Card>
-  <Card title="Tools" icon="wrench" href="./tools">
-    Discover available tools and integrations
+  <Card title="Content Creation" icon="pen-nib">
+    Deploy agents that can generate, edit, and optimize content across various formats.
   </Card>
-  <Card title="API Reference" icon="code" href="./api-reference">
-    Access comprehensive API documentation
+  <Card title="Process Automation" icon="gears">
+    Automate complex workflows with intelligent agents that can coordinate and execute tasks.
+  </Card>
+</CardGroup>
+
+## Getting Started is Easy
+<Tabs>
+  <Tab title="Code">
+<Steps>
+
+  <Step title="Install PraisonAI">
+    Install the core package:
+    ```bash Terminal
+    pip install praisonaiagents
+    ```
+  </Step>
+
+  <Step title="Configure Environment">
+    ```bash Terminal
+    export OPENAI_API_KEY=your_openai_key
+    ```
+    Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
+    Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
+  </Step>
+
+  <Step title="Create Agent">
+    Create `app.py`:
+<CodeGroup>
+  ```python Single Agent
+  from praisonaiagents import Agent, Task, PraisonAIAgents
+
+  # Create an agent
+  researcher = Agent(
+      name="Researcher",
+      role="Senior Research Analyst",
+      goal="Uncover cutting-edge developments in AI",
+      backstory="You are an expert at a technology research group",
+      verbose=True,
+      llm="gpt-4o"
+  )
+
+  # Define a task
+  task = Task(
+      name="research_task",
+      description="Analyze 2024's AI advancements",
+      expected_output="A detailed report",
+      agent=researcher
+  )
+
+  # Run the agents
+  agents = PraisonAIAgents(
+      agents=[researcher],
+      tasks=[task],
+      verbose=False
+  )
+
+  result = agents.start()
+  ```
+
+  ```python Multiple Agents
+  from praisonaiagents import Agent, Task, PraisonAIAgents
+
+  # Create multiple agents
+  researcher = Agent(
+      name="Researcher",
+      role="Senior Research Analyst",
+      goal="Uncover cutting-edge developments in AI",
+      backstory="You are an expert at a technology research group",
+      verbose=True,
+      llm="gpt-4o",
+      markdown=True
+  )
+
+  writer = Agent(
+      name="Writer",
+      role="Tech Content Strategist",
+      goal="Craft compelling content on tech advancements",
+      backstory="You are a content strategist",
+      llm="gpt-4o",
+      markdown=True
+  )
+
+  # Define multiple tasks
+  task1 = Task(
+      name="research_task",
+      description="Analyze 2024's AI advancements",
+      expected_output="A detailed report",
+      agent=researcher
+  )
+
+  task2 = Task(
+      name="writing_task",
+      description="Create a blog post about AI advancements",
+      expected_output="A blog post",
+      agent=writer
+  )
+
+  # Run with hierarchical process
+  agents = PraisonAIAgents(
+      agents=[researcher, writer],
+      tasks=[task1, task2],
+      verbose=False,
+      process="hierarchical",
+      manager_llm="gpt-4o"
+  )
+
+  result = agents.start()
+  ```
+</CodeGroup>
+  </Step>
+
+  <Step title="Start Agents">
+    Execute your script:
+    ```bash Terminal
+    python app.py
+    ```
+  </Step>
+</Steps>
+</Tab>
+
+  <Tab title="No Code">
+    <Steps>
+
+        <Step title="Install PraisonAI">
+            Install the PraisonAI package:
+            ```bash
+            pip install praisonai
+            ```
+        </Step>
+
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash Terminal
+            export OPENAI_API_KEY=your_openai_key
+            ```
+            Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
+            Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
+        </Step>
+
+        <Step title="Start AutoAgents">    
+            Run your AutoAgents:
+            ```bash
+            praisonai --auto "Create a movie script about a robot in Mars"
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+## Key Features
+
+<CardGroup cols={3}>
+  <Card title="Autonomous Agents" icon="robot">
+    Create intelligent agents that can:
+    
+    - Understand natural language instructions
+    - Make decisions based on context
+    - Execute complex tasks autonomously
+  </Card>
+
+  <Card title="Flexible Architecture" icon="cubes">
+    Build with:
+    
+    - Modular components
+    - Extensible tools
+    - Customizable workflows
+  </Card>
+
+  <Card title="Advanced Capabilities" icon="wand-sparkles">
+    Leverage:
+    
+    - Multi-agent collaboration
+    - Memory and context management
+    - Tool integration
+  </Card>
+</CardGroup>
+
+
+  <Card title="Why Choose PraisonAI?" icon="stars">
+    <CardGroup cols={2}>
+## Developer First
+Build with modern tools and frameworks you already love. Our SDK is designed to be intuitive and powerful.
+
+## Production Ready
+Enterprise-grade reliability with built-in security features and scalable architecture.
+
+## Open Source
+PraisonAI is open source and available on [GitHub](https://github.com/MervinPraison/PraisonAI).
+
+## Low Code User Friendly
+PraisonAI is designed to be easy to learn and use for non technical users.
+    </CardGroup>
+  </Card>
+
+## Chat with One Agent
+
+<Tabs>
+<Tab title="Basic Agent">
+<Steps>
+  <Step title="Install PraisonAI">
+    Get started with a simple pip install:
+    ```bash
+    pip install praisonaiagents
+    ```
+  </Step>
+  <Step title="Initialize Your Agent">
+    Create your first autonomous agent in just a few lines:
+    ```python
+    from praisonaiagents import Agent
+    agent = Agent(instructions="Your are a helpful AI assistant")
+    agent.chat("Write a movie script about a robot in Mars")
+    ```
+  </Step>
+  <Step title="Build Amazing Things">
+    Start building powerful AI applications with autonomous capabilities!
+  </Step>
+</Steps>
+</Tab>
+
+<Tab title="Agent with Tools">
+<Steps>
+  <Step title="Install PraisonAI">
+    Get started with a simple pip install:
+    ```bash
+    pip install praisonaiagents duckduckgo_search
+    ```
+  </Step>
+  <Step title="Initialize Your Agent">
+
+    Create your first autonomous agent in just a few lines:
+```python
+from praisonaiagents import Agent, Tools
+agent = Agent(instructions="Your are a helpful AI assistant", tools=[Tools.internet_search])
+agent.chat("Write a movie script about a robot in Mars")
+```
+  </Step>
+  <Step title="Build Amazing Things">
+    Start building powerful AI applications with autonomous capabilities!
+  </Step>
+</Steps>
+</Tab>
+</Tabs>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card
+    title="Installation"
+    icon="download"
+    href="/code/installation"
+  >
+    Complete installation guide and setup instructions
+  </Card>
+  <Card
+    title="Quick Start"
+    icon="play"
+    href="/code/quickstart"
+  >
+    Build your first AI agent in minutes
   </Card>
 </CardGroup>
 
 <Tip>
-  Start with our no-code interface to learn the basics, then transition to code-based development for more advanced use cases.
-</Tip>
+  Join our community on [Discord](https://www.youtube.com/redirect?event=channel_description&redir_token=QUFFLUhqbUpiZE00YlF1MjB1LVNIeTFxTnV6MWRRc18wZ3xBQ3Jtc0ttQVZ0aFJ4RXRDanlBQU1Vd3lHU3BBcml3bzhoek1pTmlkZkFkWjlNVDBpRkxZd1dTOWhPc20xbHJOb1NibmNYeTEydklJT0pZOVJFQW93MmJOQXU0WkJNVzNsd29SZ3FBNFVwMTFGNThNSHBWVUhjSQ&q=https%3A%2F%2Fdiscord.gg%2FnNZu5gGT59) to connect with other developers and get help!
+</Tip> 

docs/mint.json

@@ -60,11 +60,11 @@
       "pages": ["index"]
     },
     {
-      "group": "Getting Started (Code)",
+      "group": "Getting Started",
       "pages": [
-        "code/introduction",
-        "code/installation",
-        "code/quickstart"
+        "introduction",
+        "installation",
+        "quickstart"
       ]
     },
     {
@@ -73,44 +73,24 @@
         "concepts/agents",
         "concepts/tasks",
         "concepts/process",
-        "concepts/tools"
-      ]
-    },
-    {
-      "group": "Getting Started (No Code)",
-      "pages": [
-        "introduction",
-        "tldr",
-        "installation",
-        "initialise",
-        "run",
-        "auto"
+        "concepts/tools",
+        "concepts/memory"
       ]
     },
     {
       "group": "Features",
       "pages": [
+        "features/autoagents",
         "features/selfreflection",
         "features/reasoning",
-        "framework/multimodalagents",
+        "features/multimodal",
+        "features/langchain",
         "features/async",
         "features/mini",
         "features/codeagent",
+        "features/mathagent",
         "features/structured",
-        "features/callbacks",
-        "train",
-        "framework/praisonaiagents",
-        "framework/crewai",
-        "framework/autogen"
-      ]
-    },
-    {
-      "group": "User Interface",
-      "pages": [
-        "ui/ui",
-        "ui/chat",
-        "ui/code",
-        "ui/realtime"
+        "features/callbacks"
       ]
     },
     {
@@ -129,7 +109,7 @@
       ]
     },
     {
-      "group": "Tools (No Code)",
+      "group": "Tools",
       "pages": [
         "tools/duckduckgo_tools",
         "tools/arxiv_tools",
@@ -165,6 +145,24 @@
         "tools/googlecalendar"
       ]
     },
+    {
+      "group": "Other Features",
+      "pages": [
+        "train",
+        "framework/crewai",
+        "framework/autogen",
+        "framework/praisonaiagents"
+      ]
+    },
+    {
+      "group": "User Interface",
+      "pages": [
+        "ui/ui",
+        "ui/chat",
+        "ui/code",
+        "ui/realtime"
+      ]
+    },
     {
       "group": "Monitoring",
       "pages": ["monitoring/agentops"]
@@ -181,12 +179,24 @@
         "deploy"
       ]
     },
+    {
+      "group": "Getting Started (No Code)",
+      "pages": [
+        "nocode/introduction",
+        "nocode/tldr",
+        "nocode/installation",
+        "nocode/initialise",
+        "nocode/run",
+        "nocode/auto"
+      ]
+    },
     {
       "group": "API Reference",
       "pages": [
         "api/praisonaiagents/index",
         "api/praisonaiagents/agent/agent",
         "api/praisonaiagents/agents/agents",
+        "api/praisonaiagents/agents/autoagents",
         "api/praisonaiagents/task/task",
         "api/praisonaiagents/process/process"
       ]

docs/nocode/installation.mdx

@@ -0,0 +1,64 @@
+---
+title: "Installation"
+description: "Guide for installing PraisonAI and its various components including framework support and additional features"
+icon: "download"
+---
+
+## Basic Installation
+```bash
+pip install praisonai
+```
+
+## Framework-specific Installation
+
+### PraisonAI Agents Support (Default)
+
+```bash
+pip install praisonai
+``` 
+
+### CrewAI Support
+```bash
+pip install "praisonai[crewai]"
+```
+
+Includes:
+- CrewAI framework
+- PraisonAI tools integration
+- Task delegation capabilities
+- Sequential and parallel task execution
+
+### AutoGen Support
+```bash
+pip install "praisonai[autogen]"
+```
+
+Includes:
+- AutoGen framework
+- PraisonAI tools integration
+- Multi-agent conversation capabilities
+- Code execution environment
+
+### Both Frameworks
+```bash
+pip install "praisonai[crewai,autogen]"
+```
+
+## Additional Features
+
+```bash
+# UI support
+pip install "praisonai[ui]"
+
+# Chat interface
+pip install "praisonai[chat]"
+
+# Code interface
+pip install "praisonai[code]"
+
+# Realtime voice interaction
+pip install "praisonai[realtime]"
+
+# Call feature
+pip install "praisonai[call]"
+```

docs/nocode/introduction.mdx

@@ -0,0 +1,76 @@
+---
+title: 'Introduction'
+description: 'Get started with PraisonAI, an intelligent AI-powered tool'
+icon: "hand-wave"
+---
+
+<Note>
+  PraisonAI is a low-code, centralized framework designed to simplify the creation and orchestration of multi-agent systems for various LLM applications.
+</Note>
+
+# Welcome to PraisonAI
+
+<Frame caption="PraisonAI Framework Overview">
+  ![PraisonAI Overview](/images/praisonai-overview.png)
+</Frame>
+
+## Core Features
+
+<CardGroup cols={2}>
+  <Card title="Multi-Agent Systems" icon="users">
+    Create and orchestrate sophisticated multi-agent systems with ease
+  </Card>
+  <Card title="Framework Integration" icon="puzzle-piece">
+    Seamlessly integrates AutoGen and CrewAI capabilities
+  </Card>
+  <Card title="Low-Code Design" icon="code">
+    Build complex AI systems with minimal coding required
+  </Card>
+  <Card title="Human-AI Interaction" icon="people-arrows">
+    Enhanced support for human-agent collaboration
+  </Card>
+</CardGroup>
+
+## Getting Started
+
+<Steps>
+  <Step title="Installation">
+    Follow our [Installation Guide](./installation) to set up PraisonAI
+  </Step>
+  <Step title="Quick Overview">
+    Check out our [TL;DR](./tldr) for a rapid introduction
+  </Step>
+  <Step title="First Project">
+    Create your first project following our [Quick Start](./quickstart) guide
+  </Step>
+</Steps>
+
+## Key Components
+
+| Component | Description | Benefits |
+|:----------|:------------|:---------|
+| **UI Tools** | Intuitive interface components | Easy system interaction and monitoring |
+| **Model Integration** | Support for various LLM models | Flexibility in AI model selection |
+| **Tool System** | Extensible tool framework | Custom capability integration |
+| **API Layer** | Comprehensive API access | Full programmatic control |
+
+## Explore Further
+
+<CardGroup cols={2}>
+  <Card title="User Interface" icon="desktop" href="./ui/ui">
+    Learn about our intuitive UI components
+  </Card>
+  <Card title="Models" icon="robot" href="./models">
+    Explore supported AI models
+  </Card>
+  <Card title="Tools" icon="wrench" href="./tools">
+    Discover available tools and integrations
+  </Card>
+  <Card title="API Reference" icon="code" href="./api-reference">
+    Access comprehensive API documentation
+  </Card>
+</CardGroup>
+
+<Tip>
+  Start with our no-code interface to learn the basics, then transition to code-based development for more advanced use cases.
+</Tip>

docs/quickstart.mdx

@@ -0,0 +1,339 @@
+---
+title: Quick Start
+description: Build your first AI agent with PraisonAI
+icon: bolt
+---
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+      <Step title="Install PraisonAI">
+        Install the core package:
+        ```bash Terminal
+        pip install praisonaiagents
+        ```
+      </Step>
+
+      <Step title="Configure Environment">
+        ```bash Terminal
+        export OPENAI_API_KEY=your_openai_key
+        ```
+        Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
+        Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
+      </Step>
+
+      <Step title="Create Agent">
+        Create `app.py`:
+    <CodeGroup>
+      ```python Single Agent
+      from praisonaiagents import Agent, Task, PraisonAIAgents
+
+      # Create an agent
+      researcher = Agent(
+          name="Researcher",
+          role="Senior Research Analyst",
+          goal="Uncover cutting-edge developments in AI",
+          backstory="You are an expert at a technology research group",
+          verbose=True,
+          llm="gpt-4o"
+      )
+
+      # Define a task
+      task = Task(
+          name="research_task",
+          description="Analyze 2024's AI advancements",
+          expected_output="A detailed report",
+          agent=researcher
+      )
+
+      # Run the agents
+      agents = PraisonAIAgents(
+          agents=[researcher],
+          tasks=[task],
+          verbose=False
+      )
+
+      result = agents.start()
+      ```
+
+      ```python Multiple Agents
+      from praisonaiagents import Agent, Task, PraisonAIAgents
+
+      # Create multiple agents
+      researcher = Agent(
+          name="Researcher",
+          role="Senior Research Analyst",
+          goal="Uncover cutting-edge developments in AI",
+          backstory="You are an expert at a technology research group",
+          verbose=True,
+          llm="gpt-4o",
+          markdown=True
+      )
+
+      writer = Agent(
+          name="Writer",
+          role="Tech Content Strategist",
+          goal="Craft compelling content on tech advancements",
+          backstory="You are a content strategist",
+          llm="gpt-4o",
+          markdown=True
+      )
+
+      # Define multiple tasks
+      task1 = Task(
+          name="research_task",
+          description="Analyze 2024's AI advancements",
+          expected_output="A detailed report",
+          agent=researcher
+      )
+
+      task2 = Task(
+          name="writing_task",
+          description="Create a blog post about AI advancements",
+          expected_output="A blog post",
+          agent=writer
+      )
+
+      # Run with hierarchical process
+      agents = PraisonAIAgents(
+          agents=[researcher, writer],
+          tasks=[task1, task2],
+          verbose=False,
+          process="hierarchical",
+          manager_llm="gpt-4o"
+      )
+
+      result = agents.start()
+      ```
+    </CodeGroup>
+      </Step>
+
+      <Step title="Start Agents">
+        Execute your script:
+        ```bash Terminal
+        python app.py
+        ```
+
+        You should see:
+        - Agent initialization
+        - Agents progress
+        - Final results
+        - Generated report
+      </Step>
+    </Steps>
+  </Tab>
+  <Tab title="No Code">
+    <Steps>
+      <Step title="Install No Code PraisonAI">
+        Install the No Code PraisonAI Package:
+        ```bash Terminal
+        pip install praisonai
+        ```
+      </Step>
+
+      <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable in your terminal:
+        ```bash Terminal
+        export OPENAI_API_KEY=your_openai_key
+        ```
+      </Step>
+
+      <Step title="Create a file">
+
+        Create a new file `agents.yaml` with the basic setup:
+
+```yaml
+framework: praisonai
+topic: create movie script about cat in mars
+roles:
+  scriptwriter:
+    backstory: Expert in dialogue and script structure, translating concepts into
+      scripts.
+    goal: Write a movie script about a cat in Mars
+    role: Scriptwriter
+    tasks:
+      scriptwriting_task:
+        description: Turn the story concept into a production-ready movie script,
+          including dialogue and scene details.
+        expected_output: Final movie script with dialogue and scene details.
+```
+
+<Note>
+You can automatically create `agents.yaml` file using
+```bash Terminal
+praisonai --init create movie script about cat in mars
+```
+</Note>
+
+      </Step>
+
+      <Step title="Start Agents">
+        Execute your script:
+        ```bash Terminal
+        praisonai agents.yaml
+        ```
+      </Step>
+
+
+    </Steps>
+  </Tab>
+</Tabs>
+
+
+## Creating Custom Tool for Agents
+
+<Info>
+Tools makes the Agent powerful.
+</Info>
+More information about tools can be found in the [Tools](/concepts/tools) section.
+
+<Tabs>
+  <Tab title="Code">
+<Steps>
+<Step title="Install PraisonAI">
+Install the core package and duckduckgo_search package:
+```bash Terminal
+pip install praisonai duckduckgo_search
+```
+</Step>
+<Step title="Create Tools and Agents">
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from duckduckgo_search import DDGS
+from typing import List, Dict
+
+# 1. Tool
+def internet_search_tool(query: str) -> List[Dict]:
+    """
+    Perform Internet Search
+    """
+    results = []
+    ddgs = DDGS()
+    for result in ddgs.text(keywords=query, max_results=5):
+        results.append({
+            "title": result.get("title", ""),
+            "url": result.get("href", ""),
+            "snippet": result.get("body", "")
+        })
+    return results
+
+# 2. Agent
+data_agent = Agent(
+    name="DataCollector",
+    role="Search Specialist",
+    goal="Perform internet searches to collect relevant information.",
+    backstory="Expert in finding and organising internet data.",
+    tools=[internet_search_tool],
+    self_reflect=False
+)
+
+# 3. Tasks
+collect_task = Task(
+    description="Perform an internet search using the query: 'AI job trends in 2024'. Return results as a list of title, URL, and snippet.",
+    expected_output="List of search results with titles, URLs, and snippets.",
+    agent=data_agent,
+    name="collect_data",
+)
+
+# 4. Start Agents
+agents = PraisonAIAgents(
+    agents=[data_agent],
+    tasks=[collect_task],
+    process="sequential"
+)
+
+agents.start()
+```
+</Step>
+<Step title="Start Agents">
+Run your script:
+```bash Terminal
+python app.py
+```
+</Step>
+</Steps>
+</Tab>
+
+<Tab title="No Code">
+<Steps>
+<Step title="Install PraisonAI">
+Install the core package and duckduckgo_search package:
+```bash Terminal
+pip install praisonai duckduckgo_search
+```
+</Step>
+<Step title="Create Custom Tool">
+<Info>
+To add additional tools/features you need some coding which can be generated using ChatGPT or any LLM
+</Info>
+Create a new file `tools.py` with the following content:
+```python
+from duckduckgo_search import DDGS
+from typing import List, Dict
+
+# 1. Tool
+def internet_search_tool(query: str) -> List[Dict]:
+    """
+    Perform Internet Search
+    """
+    results = []
+    ddgs = DDGS()
+    for result in ddgs.text(keywords=query, max_results=5):
+        results.append({
+            "title": result.get("title", ""),
+            "url": result.get("href", ""),
+            "snippet": result.get("body", "")
+        })
+    return results  
+```
+</Step>
+<Step title="Create Agent">
+
+Create a new file `agents.yaml` with the following content:
+```yaml
+framework: praisonai
+topic: create movie script about cat in mars
+roles:
+  scriptwriter:
+    backstory: Expert in dialogue and script structure, translating concepts into
+      scripts.
+    goal: Write a movie script about a cat in Mars
+    role: Scriptwriter
+    tools:
+      - internet_search_tool # <-- Tool assigned to Agent here
+    tasks:
+      scriptwriting_task:
+        description: Turn the story concept into a production-ready movie script,
+          including dialogue and scene details.
+        expected_output: Final movie script with dialogue and scene details.
+```
+</Step>
+
+<Step title="Start Agents">
+
+Execute your script:
+```bash Terminal
+praisonai agents.yaml
+```
+</Step>
+</Steps>
+</Tab>
+</Tabs>
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card
+    title="Core Concepts"
+    icon="book"
+    href="/concepts/agents"
+  >
+    Learn about agents, tasks, and processes
+  </Card>
+  <Card
+    title="API Reference"
+    icon="code"
+    href="/api/praisonaiagents/index"
+  >
+    Explore detailed API documentation
+  </Card>
+</CardGroup> 

docs/tools/arxiv_tools.mdx

@@ -1,7 +1,7 @@
 ---
-title: "arXiv Tools"
-description: "Scientific paper search and retrieval tools for AI agents."
-icon: "book"
+title: "arXiv Agent"
+description: "arXiv research paper search and analysis tools for AI agents."
+icon: "book-open"
 ---
 
 <Note>
@@ -11,9 +11,9 @@ icon: "book"
   - `arxiv` package installed
 </Note>
 
-## Quick Start
+## arXiv Tools
 
-Use arXiv Tools to search and retrieve scientific papers with AI agents.
+Use arXiv Tools to search and analyze research papers with AI agents.
 
 <Steps>
   <Step title="Install Dependencies">
@@ -27,7 +27,7 @@ Use arXiv Tools to search and retrieve scientific papers with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import arxiv
+    from praisonaiagents.tools import search_arxiv, get_arxiv_paper, get_papers_by_author, get_papers_by_category
     ```
   </Step>
 
@@ -39,7 +39,7 @@ Use arXiv Tools to search and retrieve scientific papers with AI agents.
         role="Scientific Literature Specialist",
         goal="Find and analyze relevant scientific papers.",
         backstory="Expert in academic research and literature review.",
-        tools=[arxiv],
+        tools=[search_arxiv, get_arxiv_paper, get_papers_by_author, get_papers_by_category],
         self_reflect=False
     )
     ```
@@ -81,34 +81,214 @@ Use arXiv Tools to search and retrieve scientific papers with AI agents.
   - PDF download options
 </Card>
 
-## Key Components
+## Available Functions
 
-<CardGroup cols={2}>
-  <Card title="Research Agent" icon="user-robot">
-    Create specialized research agents:
-    ```python
-    Agent(tools=[arxiv])
-    ```
-  </Card>
-  <Card title="Research Task" icon="list-check">
-    Define research tasks:
-    ```python
-    Task(description="research_query")
-    ```
-  </Card>
-  <Card title="Process Types" icon="arrows-split-up-and-left">
-    Sequential or parallel processing:
-    ```python
-    process="sequential"
-    ```
-  </Card>
-  <Card title="Search Options" icon="sliders">
-    Customize search parameters:
-    ```python
-    max_results=10, sort_by="relevance"
-    ```
-  </Card>
-</CardGroup>
+```python
+from praisonaiagents.tools import search_arxiv
+from praisonaiagents.tools import get_arxiv_paper
+from praisonaiagents.tools import get_papers_by_author
+from praisonaiagents.tools import get_papers_by_category
+```
+
+## Function Details
+
+### search_arxiv(query: str, max_results: int = 10, sort_by: str = "relevance", sort_order: str = "descending", include_fields: Optional[List[str]] = None)
+
+Search arXiv for papers:
+- Flexible query support
+- Customizable results
+- Multiple sorting options
+- Field selection
+- Error handling
+
+```python
+# Basic search
+papers = search_arxiv("quantum computing")
+
+# Advanced search
+papers = search_arxiv(
+    query="quantum computing",
+    max_results=5,
+    sort_by="submittedDate",
+    sort_order="descending",
+    include_fields=["title", "authors", "summary"]
+)
+
+# Returns: List[Dict[str, Any]]
+# Example output:
+# [
+#     {
+#         "arxiv_id": "2401.00123",
+#         "title": "Quantum Computing: A Survey",
+#         "authors": ["John Doe", "Jane Smith"],
+#         "summary": "This paper reviews...",
+#         "published": "2024-01-01T00:00:00",
+#         "updated": "2024-01-02T00:00:00"
+#     },
+#     ...
+# ]
+```
+
+### get_arxiv_paper(paper_id: str, include_fields: Optional[List[str]] = None)
+
+Get specific paper details:
+- Direct ID lookup
+- Full paper metadata
+- Customizable fields
+- PDF/Abstract links
+
+```python
+# Get paper by ID
+paper = get_arxiv_paper("2401.00123")
+
+# Get specific fields
+paper = get_arxiv_paper(
+    paper_id="2401.00123",
+    include_fields=["title", "authors", "pdf_url"]
+)
+
+# Returns: Dict[str, Any]
+# Example output:
+# {
+#     "arxiv_id": "2401.00123",
+#     "title": "Quantum Computing: A Survey",
+#     "authors": ["John Doe", "Jane Smith"],
+#     "pdf_url": "https://arxiv.org/pdf/2401.00123",
+#     "abstract_url": "https://arxiv.org/abs/2401.00123",
+#     "published": "2024-01-01T00:00:00",
+#     "updated": "2024-01-02T00:00:00"
+# }
+```
+
+### get_papers_by_author(author: str, max_results: int = 10, sort_by: str = "submittedDate", sort_order: str = "descending", include_fields: Optional[List[str]] = None)
+
+Search papers by author:
+- Author-specific search
+- Publication timeline
+- Sort options
+- Field selection
+
+```python
+# Get author's papers
+papers = get_papers_by_author("Yoshua Bengio")
+
+# Recent papers first
+papers = get_papers_by_author(
+    author="Yoshua Bengio",
+    max_results=5,
+    sort_by="submittedDate",
+    sort_order="descending"
+)
+
+# Returns: List[Dict[str, Any]]
+# Example output:
+# [
+#     {
+#         "arxiv_id": "2401.00124",
+#         "title": "Deep Learning Advances",
+#         "authors": ["Yoshua Bengio", "Other Author"],
+#         "published": "2024-01-01T00:00:00"
+#     },
+#     ...
+# ]
+```
+
+### get_papers_by_category(category: str, max_results: int = 10, sort_by: str = "submittedDate", sort_order: str = "descending", include_fields: Optional[List[str]] = None)
+
+Search papers by category:
+- Category-specific search
+- Latest publications
+- Sort options
+- Field selection
+
+```python
+# Get papers in category
+papers = get_papers_by_category("cs.AI")
+
+# Recent machine learning papers
+papers = get_papers_by_category(
+    category="cs.LG",
+    max_results=5,
+    sort_by="submittedDate",
+    sort_order="descending"
+)
+
+# Returns: List[Dict[str, Any]]
+# Example output:
+# [
+#     {
+#         "arxiv_id": "2401.00125",
+#         "title": "New ML Algorithm",
+#         "categories": ["cs.LG", "cs.AI"],
+#         "published": "2024-01-01T00:00:00"
+#     },
+#     ...
+# ]
+```
+
+## Dependencies
+
+The arXiv tools require the following package:
+- arxiv: For accessing the arXiv API
+
+This will be automatically installed when needed.
+
+## Available Fields
+
+When using `include_fields`, you can select from:
+- title: Paper title
+- authors: List of authors
+- summary: Abstract text
+- comment: Author comments
+- journal_ref: Journal reference
+- doi: Digital Object Identifier
+- primary_category: Main arXiv category
+- categories: All arXiv categories
+- links: PDF and abstract URLs
+
+## Common Use Cases
+
+1. Literature Review:
+```python
+# Search multiple related topics
+topics = ["machine learning", "neural networks", "deep learning"]
+all_papers = []
+for topic in topics:
+    papers = search_arxiv(
+        topic,
+        max_results=5,
+        sort_by="relevance"
+    )
+    all_papers.extend(papers)
+```
+
+2. Author Research:
+```python
+# Get recent papers by multiple authors
+authors = ["Yoshua Bengio", "Geoffrey Hinton", "Yann LeCun"]
+author_papers = {}
+for author in authors:
+    papers = get_papers_by_author(
+        author,
+        max_results=3,
+        sort_by="submittedDate"
+    )
+    author_papers[author] = papers
+```
+
+3. Category Monitoring:
+```python
+# Monitor new papers in AI categories
+categories = ["cs.AI", "cs.LG", "cs.CL"]
+new_papers = {}
+for category in categories:
+    papers = get_papers_by_category(
+        category,
+        max_results=5,
+        sort_by="submittedDate"
+    )
+    new_papers[category] = papers
+```
 
 ## Examples
 
@@ -116,7 +296,7 @@ Use arXiv Tools to search and retrieve scientific papers with AI agents.
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import arxiv
+from praisonaiagents.tools import search_arxiv, get_arxiv_paper, get_papers_by_author, get_papers_by_category
 
 # Create research agent
 research_agent = Agent(
@@ -124,7 +304,7 @@ research_agent = Agent(
     role="Scientific Literature Specialist",
     goal="Find relevant scientific papers on specified topics.",
     backstory="Expert in academic research and literature analysis.",
-    tools=[arxiv],
+    tools=[search_arxiv, get_arxiv_paper, get_papers_by_author, get_papers_by_category],
     self_reflect=False
 )
 
@@ -153,7 +333,7 @@ research_agent = Agent(
     name="Researcher",
     role="Literature Specialist",
     goal="Gather comprehensive scientific literature.",
-    tools=[arxiv],
+    tools=[search_arxiv, get_arxiv_paper, get_papers_by_author, get_papers_by_category],
     self_reflect=False
 )
 
@@ -198,7 +378,7 @@ agents.start()
         name="Researcher",
         role="Literature Specialist",
         goal="Find relevant scientific papers",
-        tools=[arxiv]
+        tools=[search_arxiv, get_arxiv_paper, get_papers_by_author, get_papers_by_category]
     )
     ```
   </Accordion>
@@ -222,7 +402,7 @@ agents.start()
 searcher = Agent(
     name="Searcher",
     role="Literature Specialist",
-    tools=[arxiv]
+    tools=[search_arxiv, get_arxiv_paper, get_papers_by_author, get_papers_by_category]
 )
 
 # Review agent

docs/tools/calculator_tools.mdx

@@ -1,6 +1,6 @@
 ---
-title: "Calculator Tools"
-description: "Mathematical computation tools for AI agents."
+title: "Calculator Agent"
+description: "Mathematical calculation tools for AI agents."
 icon: "calculator"
 ---
 
@@ -8,18 +8,18 @@ icon: "calculator"
   **Prerequisites**
   - Python 3.10 or higher
   - PraisonAI Agents package installed
-  - Basic understanding of mathematical operations
+  - `sympy` and `pint` packages installed
 </Note>
 
-## Quick Start
+## Calculator Tools
 
-Use Calculator Tools to perform mathematical computations with AI agents.
+Use Calculator Tools to perform mathematical calculations with AI agents.
 
 <Steps>
   <Step title="Install Dependencies">
-    First, install the required package:
+    First, install the required packages:
     ```bash
-    pip install praisonaiagents
+    pip install praisonaiagents sympy pint
     ```
   </Step>
 
@@ -27,19 +27,25 @@ Use Calculator Tools to perform mathematical computations with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import calculator
+    from praisonaiagents.tools import (
+        evaluate, solve_equation, convert_units,
+        calculate_statistics, calculate_financial
+    )
     ```
   </Step>
 
   <Step title="Create Agent">
     Create a calculator agent:
     ```python
-    calc_agent = Agent(
-        name="Calculator",
-        role="Mathematical Specialist",
-        goal="Perform mathematical computations accurately.",
-        backstory="Expert in mathematical calculations and analysis.",
-        tools=[calculator],
+    calculator_agent = Agent(
+        name="MathAssistant",
+        role="Mathematical Computation Specialist",
+        goal="Perform accurate mathematical calculations and solve equations.",
+        backstory="Expert in mathematical computations and problem-solving.",
+        tools=[
+            evaluate, solve_equation, convert_units,
+            calculate_statistics, calculate_financial
+        ],
         self_reflect=False
     )
     ```
@@ -49,10 +55,10 @@ Use Calculator Tools to perform mathematical computations with AI agents.
     Define the calculation task:
     ```python
     calc_task = Task(
-        description="Calculate financial metrics for quarterly report.",
-        expected_output="Computed financial metrics with analysis.",
-        agent=calc_agent,
-        name="financial_calculations"
+        description="Calculate the area of a circle with radius 5",
+        expected_output="The area of the circle in square units",
+        agent=calculator_agent,
+        name="circle_area"
     )
     ```
   </Step>
@@ -61,7 +67,7 @@ Use Calculator Tools to perform mathematical computations with AI agents.
     Initialize and run the agent:
     ```python
     agents = PraisonAIAgents(
-        agents=[calc_agent],
+        agents=[calculator_agent],
         tasks=[calc_task],
         process="sequential"
     )
@@ -73,178 +79,138 @@ Use Calculator Tools to perform mathematical computations with AI agents.
 ## Understanding Calculator Tools
 
 <Card title="What are Calculator Tools?" icon="question">
-  Calculator Tools provide mathematical capabilities for AI agents:
-  - Basic arithmetic
-  - Advanced mathematics
-  - Statistical calculations
-  - Financial computations
+  Calculator Tools provide mathematical computation capabilities for AI agents:
+  - Expression evaluation
+  - Equation solving
   - Unit conversions
+  - Support for mathematical functions
+  - Variable substitution
 </Card>
 
 ## Key Components
 
 <CardGroup cols={2}>
-  <Card title="Calculator Agent" icon="user-robot">
-    Create specialized calculator agents:
+  <Card title="Expression Evaluation" icon="function">
+    Evaluate mathematical expressions:
     ```python
-    Agent(tools=[calculator])
+    result = evaluate("2 + 2 * 3")
     ```
   </Card>
-  <Card title="Calculator Task" icon="list-check">
-    Define calculation tasks:
+  <Card title="Equation Solving" icon="equals">
+    Solve mathematical equations:
     ```python
-    Task(description="calculation_query")
+    result = solve_equation("2*x + 3 = 7")
     ```
   </Card>
-  <Card title="Process Types" icon="arrows-split-up-and-left">
-    Sequential or parallel processing:
+  <Card title="Unit Conversions" icon="exchange">
+    Convert between units:
     ```python
-    process="sequential"
+    result = convert_units(100, "meters", "kilometers")
     ```
   </Card>
-  <Card title="Calculation Options" icon="sliders">
-    Customize calculation parameters:
+  <Card title="Statistical Calculations" icon="chart-line">
+    Calculate statistical metrics:
     ```python
-    precision=2, format="decimal"
+    result = calculate_statistics([1, 2, 3, 4, 5])
+    ```
+  </Card>
+  <Card title="Financial Calculations" icon="chart-pie">
+    Calculate financial metrics:
+    ```python
+    result = calculate_financial(1000, 5, 2)
     ```
   </Card>
 </CardGroup>
 
-## Examples
-
-### Basic Calculator Agent
-
-```python
-from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import calculator
-
-# Create calculator agent
-calc_agent = Agent(
-    name="MathExpert",
-    role="Mathematical Specialist",
-    goal="Perform calculations accurately and efficiently.",
-    backstory="Expert in mathematical computations and analysis.",
-    tools=[calculator],
-    self_reflect=False
-)
-
-# Define calculation task
-calc_task = Task(
-    description="Calculate investment returns and compound interest.",
-    expected_output="Detailed investment calculations with analysis.",
-    agent=calc_agent,
-    name="investment_analysis"
-)
-
-# Run agent
-agents = PraisonAIAgents(
-    agents=[calc_agent],
-    tasks=[calc_task],
-    process="sequential"
-)
-agents.start()
-```
-
-### Advanced Calculations with Multiple Agents
-
-```python
-# Create calculation agent
-calculator_agent = Agent(
-    name="Calculator",
-    role="Math Calculator",
-    goal="Perform complex calculations systematically.",
-    tools=[calculator],
-    self_reflect=False
-)
-
-# Create analysis agent
-analysis_agent = Agent(
-    name="Analyzer",
-    role="Data Analyst",
-    goal="Analyze and interpret calculation results.",
-    backstory="Expert in data analysis and interpretation.",
-    self_reflect=False
-)
-
-# Define tasks
-calculation_task = Task(
-    description="Calculate statistical metrics for dataset.",
-    agent=calculator_agent,
-    name="statistical_analysis"
-)
-
-analysis_task = Task(
-    description="Analyze and interpret the statistical results.",
-    agent=analysis_agent,
-    name="result_analysis"
-)
-
-# Run agents
-agents = PraisonAIAgents(
-    agents=[calculator_agent, analysis_agent],
-    tasks=[calculation_task, analysis_task],
-    process="sequential"
-)
-agents.start()
-```
-
-## Best Practices
+## Advanced Usage
 
 <AccordionGroup>
-  <Accordion title="Agent Configuration">
-    Configure agents with clear calculation focus:
+  <Accordion title="Expression Evaluation">
+    Evaluate complex mathematical expressions with variables:
     ```python
-    Agent(
-        name="Calculator",
-        role="Mathematical Specialist",
-        goal="Perform calculations accurately and efficiently",
-        tools=[calculator]
+    # Basic arithmetic
+    result = evaluate("2 + 2 * 3")
+    
+    # With mathematical functions
+    result = evaluate("sin(pi/2) + sqrt(16)")
+    
+    # With variables
+    result = evaluate(
+        "x^2 + y",
+        variables={"x": 3, "y": 4}
     )
     ```
   </Accordion>
-
-  <Accordion title="Task Definition">
-    Define specific calculation objectives:
+  
+  <Accordion title="Equation Solving">
+    Solve different types of equations:
     ```python
-    Task(
-        description="Calculate financial metrics and growth rates",
-        expected_output="Detailed financial analysis"
-    )
+    # Linear equation
+    result = solve_equation("2*x + 3 = 7")
+    
+    # With custom variable
+    result = solve_equation("y^2 = 4", variable="y")
+    ```
+  </Accordion>
+  
+  <Accordion title="Unit Conversions">
+    Convert between different units:
+    ```python
+    # Length conversion
+    result = convert_units(100, "meters", "kilometers")
+    
+    # Temperature conversion
+    result = convert_units(32, "fahrenheit", "celsius")
+    
+    # Time conversion
+    result = convert_units(2.5, "hours", "minutes")
+    ```
+  </Accordion>
+  
+  <Accordion title="Statistical Calculations">
+    Calculate statistical metrics:
+    ```python
+    result = calculate_statistics([1, 2, 3, 4, 5])
+    ```
+  </Accordion>
+  
+  <Accordion title="Financial Calculations">
+    Calculate financial metrics:
+    ```python
+    result = calculate_financial(1000, 5, 2)
     ```
   </Accordion>
 </AccordionGroup>
 
-## Common Patterns
+## Error Handling
 
-### Calculation Pipeline
-```python
-# Calculator agent
-calculator = Agent(
-    name="Calculator",
-    role="Math Calculator",
-    tools=[calculator]
-)
+<Card title="Error Management" icon="shield-check">
+  The tools include comprehensive error handling:
+  ```python
+  # Returns success result
+  {"result": 8.0}
+  
+  # Returns error message
+  {"error": "Invalid expression"}
+  ```
+</Card>
 
-# Analysis agent
-analyzer = Agent(
-    name="Analyzer",
-    role="Result Analyzer"
-)
+## Best Practices
 
-# Define tasks
-calc_task = Task(
-    description="Perform calculations",
-    agent=calculator
-)
-
-analysis_task = Task(
-    description="Analyze results",
-    agent=analyzer
-)
-
-# Run workflow
-agents = PraisonAIAgents(
-    agents=[calculator, analyzer],
-    tasks=[calc_task, analysis_task]
-)
-```
+<CardGroup cols={2}>
+  <Card title="Precision Control" icon="ruler">
+    Control calculation precision:
+    ```python
+    evaluate(
+        "pi",
+        precision=5
+    )
+    ```
+  </Card>
+  <Card title="Safe Execution" icon="shield">
+    Uses safe evaluation environment with:
+    - Restricted builtins
+    - Mathematical functions only
+    - Variable validation
+  </Card>
+</CardGroup>

docs/tools/csv_tools.mdx

@@ -1,5 +1,5 @@
 ---
-title: "CSV Tools"
+title: "CSV Agent"
 description: "CSV file processing tools for AI agents."
 icon: "file-csv"
 ---
@@ -8,12 +8,12 @@ icon: "file-csv"
   **Prerequisites**
   - Python 3.10 or higher
   - PraisonAI Agents package installed
-  - Basic understanding of CSV files
+  - `pandas` package installed
 </Note>
 
-## Quick Start
+## CSV Tools
 
-Use CSV Tools to process and manipulate CSV files with AI agents.
+Use CSV Tools to read, write, and manipulate CSV files with AI agents.
 
 <Steps>
   <Step title="Install Dependencies">
@@ -27,7 +27,7 @@ Use CSV Tools to process and manipulate CSV files with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import csv
+    from praisonaiagents.tools import read_csv, write_csv, merge_csv
     ```
   </Step>
 
@@ -39,7 +39,7 @@ Use CSV Tools to process and manipulate CSV files with AI agents.
         role="CSV Processing Specialist",
         goal="Process CSV files efficiently and accurately.",
         backstory="Expert in CSV file manipulation and analysis.",
-        tools=[csv],
+        tools=[read_csv, write_csv, merge_csv],
         self_reflect=False
     )
     ```
@@ -87,7 +87,7 @@ Use CSV Tools to process and manipulate CSV files with AI agents.
   <Card title="CSV Agent" icon="user-robot">
     Create specialized CSV agents:
     ```python
-    Agent(tools=[csv])
+    Agent(tools=[read_csv, write_csv, merge_csv])
     ```
   </Card>
   <Card title="CSV Task" icon="list-check">
@@ -110,13 +110,148 @@ Use CSV Tools to process and manipulate CSV files with AI agents.
   </Card>
 </CardGroup>
 
+## Available Functions
+
+```python
+from praisonaiagents.tools import read_csv
+from praisonaiagents.tools import write_csv
+from praisonaiagents.tools import merge_csv
+```
+
+## Function Details
+
+### read_csv(filepath: str, encoding: str = 'utf-8', delimiter: str = ',', header: Union[int, List[int], None] = 0, usecols: Optional[List[str]] = None, dtype: Optional[Dict[str, str]] = None, parse_dates: Optional[List[str]] = None, na_values: Optional[List[str]] = None, nrows: Optional[int] = None)
+
+Reads a CSV file with advanced options:
+- Supports multiple encodings (utf-8, ascii, etc.)
+- Configurable column delimiter
+- Flexible header row handling
+- Column selection and data type specification
+- Date parsing
+- Custom NA/NaN value handling
+- Row limit option
+
+```python
+# Basic usage
+data = read_csv("data.csv")
+
+# Advanced usage with options
+data = read_csv(
+    "data.csv",
+    encoding='utf-8',
+    delimiter=',',
+    header=0,
+    usecols=['name', 'age', 'city'],
+    dtype={'age': 'int32'},
+    parse_dates=['birth_date'],
+    na_values=['N/A', 'missing'],
+    nrows=1000
+)
+# Returns: List[Dict[str, Any]]
+# Example: [{"name": "Alice", "age": 25, "city": "New York"}, ...]
+```
+
+### write_csv(filepath: str, data: List[Dict[str, Any]], encoding: str = 'utf-8', delimiter: str = ',', index: bool = False, header: bool = True, float_format: Optional[str] = None, date_format: Optional[str] = None, mode: str = 'w')
+
+Writes data to a CSV file with formatting options:
+- Supports different encodings
+- Configurable delimiter
+- Optional row indices
+- Optional headers
+- Custom float and date formatting
+- Append mode support
+
+```python
+# Basic usage
+data = [
+    {"name": "Alice", "age": 25, "city": "New York"},
+    {"name": "Bob", "age": 30, "city": "San Francisco"}
+]
+success = write_csv("output.csv", data)
+
+# Advanced usage with formatting
+success = write_csv(
+    "output.csv",
+    data,
+    encoding='utf-8',
+    delimiter=',',
+    index=False,
+    header=True,
+    float_format='%.2f',
+    date_format='%Y-%m-%d',
+    mode='w'
+)
+# Returns: bool (True if successful)
+```
+
+### merge_csv(files: List[str], output_file: str, how: str = 'inner', on: Optional[Union[str, List[str]]] = None, suffixes: Optional[tuple] = None)
+
+Merges multiple CSV files with flexible join options:
+- Supports different join types (inner, outer, left, right)
+- Merge on single or multiple columns
+- Custom suffixes for overlapping columns
+- Automatic handling of column name conflicts
+
+```python
+# Merge two files on a common column
+success = merge_csv(
+    files=["employees.csv", "salaries.csv"],
+    output_file="merged.csv",
+    how='inner',
+    on='employee_id'
+)
+
+# Advanced merge with multiple columns and custom suffixes
+success = merge_csv(
+    files=["data1.csv", "data2.csv", "data3.csv"],
+    output_file="merged.csv",
+    how='outer',
+    on=['id', 'department'],
+    suffixes=('_2022', '_2023')
+)
+# Returns: bool (True if successful)
+```
+
+## Dependencies
+
+The CSV tools require the following Python packages:
+- pandas: For advanced CSV operations and data manipulation
+
+These will be automatically installed when needed.
+
+## Example Agent Configuration
+
+```python
+from praisonaiagents import Agent
+from praisonaiagents.tools import read_csv, write_csv, merge_csv
+
+agent = Agent(
+    name="CSVProcessor",
+    description="An agent that processes CSV files",
+    tools=[read_csv, write_csv, merge_csv]
+)
+```
+
+## Error Handling
+
+All functions include comprehensive error handling:
+- File not found errors
+- Permission errors
+- Encoding errors
+- Data format errors
+- Missing dependency errors
+
+Errors are logged and returned in a consistent format:
+- Success cases return the expected data type
+- Error cases return a dict with an "error" key containing the error message
+
 ## Examples
 
 ### Basic CSV Processing Agent
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import csv
+from praisonaiagents.tools import read_csv, write_csv, merge_csv
 
 # Create CSV agent
 csv_agent = Agent(
@@ -124,7 +259,7 @@ csv_agent = Agent(
     role="CSV Processing Specialist",
     goal="Process CSV files efficiently and accurately.",
     backstory="Expert in data processing and analysis.",
-    tools=[csv],
+    tools=[read_csv, write_csv, merge_csv],
     self_reflect=False
 )
 
@@ -153,7 +288,7 @@ processor_agent = Agent(
     name="Processor",
     role="Data Processor",
     goal="Process CSV data systematically.",
-    tools=[csv],
+    tools=[read_csv, write_csv, merge_csv],
     self_reflect=False
 )
 
@@ -198,7 +333,7 @@ agents.start()
         name="CSVProcessor",
         role="CSV Processing Specialist",
         goal="Process CSV files accurately and efficiently",
-        tools=[csv]
+        tools=[read_csv, write_csv, merge_csv]
     )
     ```
   </Accordion>
@@ -222,7 +357,7 @@ agents.start()
 processor = Agent(
     name="Processor",
     role="CSV Processor",
-    tools=[csv]
+    tools=[read_csv, write_csv, merge_csv]
 )
 
 # Analysis agent

docs/tools/duckdb_tools.mdx

@@ -1,5 +1,5 @@
 ---
-title: "DuckDB Tools"
+title: "DuckDB Agent"
 description: "DuckDB database tools for AI agents."
 icon: "database"
 ---
@@ -12,7 +12,7 @@ icon: "database"
   - Basic understanding of SQL and databases
 </Note>
 
-## Quick Start
+## DuckDB Tools
 
 Use DuckDB Tools to manage and query databases with AI agents.
 
@@ -28,7 +28,7 @@ Use DuckDB Tools to manage and query databases with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import duckdb
+    from praisonaiagents.tools import execute_query, load_csv, export_csv
     ```
   </Step>
 
@@ -40,7 +40,7 @@ Use DuckDB Tools to manage and query databases with AI agents.
         role="Database Management Specialist",
         goal="Manage and query databases efficiently.",
         backstory="Expert in database operations and SQL.",
-        tools=[duckdb],
+        tools=[execute_query, load_csv, export_csv],
         self_reflect=False
     )
     ```
@@ -71,6 +71,95 @@ Use DuckDB Tools to manage and query databases with AI agents.
   </Step>
 </Steps>
 
+## Available Functions
+
+```python
+from praisonaiagents.tools import execute_query
+from praisonaiagents.tools import load_csv
+from praisonaiagents.tools import export_csv
+```
+
+## Function Details
+
+### execute_query(query: str, params: Optional[Union[tuple, dict]] = None, return_df: bool = True)
+
+Executes SQL queries with advanced features:
+- Supports parameterized queries
+- Returns results as DataFrame records or raw tuples
+- Full SQL query support (SELECT, INSERT, UPDATE, DELETE, etc.)
+- Automatic connection management
+
+```python
+# Basic SELECT query
+results = execute_query("SELECT * FROM employees")
+
+# Parameterized query
+results = execute_query(
+    "SELECT * FROM employees WHERE department = ? AND salary > ?",
+    params=('Engineering', 75000)
+)
+
+# Named parameters
+results = execute_query(
+    "SELECT * FROM employees WHERE department = :dept",
+    params={'dept': 'Engineering'}
+)
+# Returns: List[Dict[str, Any]]
+# Example: [{"id": 1, "name": "Alice", "department": "Engineering"}, ...]
+```
+
+### load_csv(table_name: str, filepath: str, schema: Optional[Dict[str, str]] = None, if_exists: str = 'replace')
+
+Loads CSV files into DuckDB tables:
+- Optional schema definition
+- Flexible table existence handling
+- Automatic type inference
+- Support for large files
+
+```python
+# Basic usage - auto schema inference
+success = load_csv("employees", "employees.csv")
+
+# With custom schema
+schema = {
+    "id": "INTEGER PRIMARY KEY",
+    "name": "VARCHAR",
+    "salary": "DECIMAL(10,2)",
+    "hire_date": "DATE"
+}
+success = load_csv(
+    "employees",
+    "employees.csv",
+    schema=schema,
+    if_exists='replace'
+)
+# Returns: bool (True if successful)
+```
+
+### export_csv(query: str, filepath: str, params: Optional[Union[tuple, dict]] = None)
+
+Exports query results to CSV files:
+- Supports parameterized queries
+- Automatic header generation
+- Configurable output formatting
+- Large result set handling
+
+```python
+# Export simple query results
+success = export_csv(
+    "SELECT * FROM employees",
+    "exported_employees.csv"
+)
+
+# Export filtered data with parameters
+success = export_csv(
+    "SELECT * FROM employees WHERE department = ? AND year = ?",
+    "eng_2023.csv",
+    params=('Engineering', 2023)
+)
+# Returns: bool (True if successful)
+```
+
 ## Understanding DuckDB Tools
 
 <Card title="What are DuckDB Tools?" icon="question">
@@ -88,7 +177,7 @@ Use DuckDB Tools to manage and query databases with AI agents.
   <Card title="DB Agent" icon="user-robot">
     Create specialized database agents:
     ```python
-    Agent(tools=[duckdb])
+    Agent(tools=[execute_query, load_csv, export_csv])
     ```
   </Card>
   <Card title="DB Task" icon="list-check">
@@ -117,7 +206,7 @@ Use DuckDB Tools to manage and query databases with AI agents.
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import duckdb
+from praisonaiagents.tools import execute_query, load_csv, export_csv
 
 # Create database agent
 db_agent = Agent(
@@ -125,7 +214,7 @@ db_agent = Agent(
     role="Database Specialist",
     goal="Query and analyze data efficiently.",
     backstory="Expert in database management and SQL.",
-    tools=[duckdb],
+    tools=[execute_query, load_csv, export_csv],
     self_reflect=False
 )
 
@@ -154,39 +243,101 @@ query_agent = Agent(
     name="QueryProcessor",
     role="SQL Query Specialist",
     goal="Execute SQL queries efficiently.",
-    tools=[duckdb],
+    tools=[execute_query],
     self_reflect=False
 )
 
-# Create analysis agent
-analysis_agent = Agent(
-    name="DataAnalyst",
-    role="Data Analyst",
-    goal="Analyze query results and generate insights.",
-    backstory="Expert in data analysis and reporting.",
+# Create data import/export agent
+data_agent = Agent(
+    name="DataProcessor",
+    role="Data Import/Export Specialist",
+    goal="Handle data import and export operations efficiently.",
+    tools=[load_csv, export_csv],
     self_reflect=False
 )
+```
 
-# Define tasks
-query_task = Task(
-    description="Execute complex SQL queries.",
-    agent=query_agent,
-    name="query_execution"
-)
+## Dependencies
 
-analysis_task = Task(
-    description="Analyze query results and trends.",
-    agent=analysis_agent,
-    name="result_analysis"
-)
+The DuckDB tools require the following Python packages:
+- duckdb: For database operations
+- pandas: For data manipulation and CSV handling
 
-# Run agents
-agents = PraisonAIAgents(
-    agents=[query_agent, analysis_agent],
-    tasks=[query_task, analysis_task],
-    process="sequential"
+These will be automatically installed when needed.
+
+## Example Agent Configuration
+
+```python
+from praisonaiagents import Agent
+from praisonaiagents.tools import execute_query, load_csv, export_csv
+
+agent = Agent(
+    name="DBProcessor",
+    description="An agent that works with DuckDB databases",
+    tools=[execute_query, load_csv, export_csv]
 )
-agents.start()
+```
+
+## Error Handling
+
+All functions include comprehensive error handling:
+- Database connection errors
+- Query syntax errors
+- File I/O errors
+- Schema validation errors
+- Missing dependency errors
+
+Errors are logged and returned in a consistent format:
+- Success cases return the expected data type
+- Error cases return a dict with an "error" key containing the error message
+
+## Common Use Cases
+
+1. Data Analysis:
+```python
+# Load data
+load_csv("sales", "sales_data.csv")
+
+# Analyze with SQL
+results = execute_query("""
+    SELECT 
+        department,
+        COUNT(*) as count,
+        AVG(salary) as avg_salary
+    FROM employees
+    GROUP BY department
+    HAVING count > 5
+    ORDER BY avg_salary DESC
+""")
+```
+
+2. Data Export:
+```python
+# Export filtered and aggregated data
+export_csv("""
+    SELECT 
+        date_trunc('month', date) as month,
+        SUM(amount) as total_sales
+    FROM sales
+    GROUP BY 1
+    ORDER BY 1
+""", "monthly_sales.csv")
+```
+
+3. Data Transformation:
+```python
+# Load and transform data
+load_csv("raw_data", "input.csv")
+execute_query("""
+    CREATE TABLE transformed AS
+    SELECT 
+        id,
+        UPPER(name) as name,
+        ROUND(amount, 2) as amount,
+        DATE_TRUNC('day', timestamp) as date
+    FROM raw_data
+""")
+export_csv("SELECT * FROM transformed", "transformed.csv")
 ```
 
 ## Best Practices
@@ -199,7 +350,7 @@ agents.start()
         name="DBProcessor",
         role="Database Specialist",
         goal="Process queries accurately and efficiently",
-        tools=[duckdb]
+        tools=[execute_query, load_csv, export_csv]
     )
     ```
   </Accordion>
@@ -223,7 +374,7 @@ agents.start()
 querier = Agent(
     name="Querier",
     role="SQL Specialist",
-    tools=[duckdb]
+    tools=[execute_query]
 )
 
 # Analysis agent

docs/tools/duckduckgo_tools.mdx

@@ -1,5 +1,5 @@
 ---
-title: "DuckDuckGo Tools"
+title: "DuckDuckGo Agent"
 description: "Internet search tools using DuckDuckGo for AI agents."
 icon: "magnifying-glass"
 ---
@@ -11,7 +11,7 @@ icon: "magnifying-glass"
   - `duckduckgo-search` package installed
 </Note>
 
-## Quick Start
+## DuckDuckGo Tools
 
 Use DuckDuckGo Tools to perform internet searches with AI agents.
 

docs/tools/excel_tools.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Excel Tools"
+title: "Excel Agent"
 description: "Excel file processing tools for AI agents."
 icon: "file-excel"
 ---
@@ -12,7 +12,7 @@ icon: "file-excel"
   - Basic understanding of Excel files
 </Note>
 
-## Quick Start
+## Excel Tools
 
 Use Excel Tools to process and manipulate Excel files with AI agents.
 
@@ -28,7 +28,7 @@ Use Excel Tools to process and manipulate Excel files with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import excel
+    from praisonaiagents.tools import read_excel, write_excel, merge_excel
     ```
   </Step>
 
@@ -40,7 +40,7 @@ Use Excel Tools to process and manipulate Excel files with AI agents.
         role="Excel Processing Specialist",
         goal="Process Excel files efficiently and accurately.",
         backstory="Expert in Excel file manipulation and analysis.",
-        tools=[excel],
+        tools=[read_excel, write_excel, merge_excel],
         self_reflect=False
     )
     ```
@@ -88,7 +88,7 @@ Use Excel Tools to process and manipulate Excel files with AI agents.
   <Card title="Excel Agent" icon="user-robot">
     Create specialized Excel agents:
     ```python
-    Agent(tools=[excel])
+    Agent(tools=[read_excel, write_excel, merge_excel])
     ```
   </Card>
   <Card title="Excel Task" icon="list-check">
@@ -111,13 +111,120 @@ Use Excel Tools to process and manipulate Excel files with AI agents.
   </Card>
 </CardGroup>
 
+## Available Functions
+
+```python
+from praisonaiagents.tools import read_excel
+from praisonaiagents.tools import write_excel
+from praisonaiagents.tools import merge_excel
+```
+
+## Function Details
+
+### read_excel(filepath: str, sheet_name: Optional[Union[str, int, List[Union[str, int]]]] = 0, header: Optional[int] = 0, usecols: Optional[List[str]] = None, skiprows: Optional[Union[int, List[int]]] = None, na_values: Optional[List[str]] = None, dtype: Optional[Dict[str, str]] = None)
+
+Reads Excel files with advanced options:
+- Support for multiple sheets
+- Flexible header handling
+- Column selection
+- Row skipping
+- Custom NA values
+- Data type specification
+
+```python
+# Basic usage - read first sheet
+data = read_excel("data.xlsx")
+
+# Read specific sheets
+data = read_excel(
+    "data.xlsx",
+    sheet_name=['Sheet1', 'Sheet2'],
+    header=0,
+    usecols=['A', 'B', 'C'],
+    skiprows=[0, 1],
+    na_values=['NA', 'missing'],
+    dtype={'age': 'int32', 'salary': 'float64'}
+)
+# Returns: Dict[str, List[Dict[str, Any]]] for multiple sheets
+# Example: {
+#   'Sheet1': [{"name": "Alice", "age": 25}, ...],
+#   'Sheet2': [{"dept": "Engineering", "count": 10}, ...]
+# }
+```
+
+### write_excel(filepath: str, data: Union[Dict[str, List[Dict[str, Any]]], List[Dict[str, Any]]], sheet_name: Optional[str] = None, index: bool = False, header: bool = True, mode: str = 'w')
+
+Writes data to Excel files with formatting:
+- Multiple sheet support
+- Append mode for existing files
+- Optional row indices
+- Optional headers
+- Flexible data structure handling
+
+```python
+# Write single sheet
+data = [
+    {"name": "Alice", "age": 25, "city": "New York"},
+    {"name": "Bob", "age": 30, "city": "San Francisco"}
+]
+success = write_excel("output.xlsx", data, sheet_name="Employees")
+
+# Write multiple sheets
+data = {
+    "Employees": [
+        {"name": "Alice", "age": 25},
+        {"name": "Bob", "age": 30}
+    ],
+    "Departments": [
+        {"name": "Engineering", "count": 50},
+        {"name": "Sales", "count": 30}
+    ]
+}
+success = write_excel(
+    "company.xlsx",
+    data,
+    index=False,
+    header=True,
+    mode='w'
+)
+# Returns: bool (True if successful)
+```
+
+### merge_excel(files: List[str], output_file: str, how: str = 'inner', on: Optional[Union[str, List[str]]] = None, suffixes: Optional[Tuple[str, str]] = None)
+
+Merges multiple Excel files:
+- Flexible join operations
+- Multiple key columns support
+- Custom column suffix handling
+- Preserves data types
+
+```python
+# Merge two files on a common column
+success = merge_excel(
+    files=["employees.xlsx", "salaries.xlsx"],
+    output_file="merged.xlsx",
+    how='inner',
+    on='employee_id'
+)
+
+# Advanced merge with multiple keys and custom suffixes
+success = merge_excel(
+    files=["data2022.xlsx", "data2023.xlsx"],
+    output_file="combined.xlsx",
+    how='outer',
+    on=['id', 'department'],
+    suffixes=('_2022', '_2023')
+)
+# Returns: bool (True if successful)
+```
+
 ## Examples
 
 ### Basic Excel Processing Agent
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import excel
+from praisonaiagents.tools import read_excel, write_excel, merge_excel
 
 # Create Excel agent
 excel_agent = Agent(
@@ -125,7 +232,7 @@ excel_agent = Agent(
     role="Excel Processing Specialist",
     goal="Process Excel files efficiently and accurately.",
     backstory="Expert in spreadsheet manipulation and analysis.",
-    tools=[excel],
+    tools=[read_excel, write_excel, merge_excel],
     self_reflect=False
 )
 
@@ -154,7 +261,7 @@ processor_agent = Agent(
     name="Processor",
     role="Data Processor",
     goal="Process Excel data systematically.",
-    tools=[excel],
+    tools=[read_excel, write_excel, merge_excel],
     self_reflect=False
 )
 
@@ -199,7 +306,7 @@ agents.start()
         name="ExcelProcessor",
         role="Excel Processing Specialist",
         goal="Process Excel files accurately and efficiently",
-        tools=[excel]
+        tools=[read_excel, write_excel, merge_excel]
     )
     ```
   </Accordion>
@@ -208,8 +315,7 @@ agents.start()
     Define specific Excel operations:
     ```python
     Task(
-        description="Process sales data and generate reports",
-        expected_output="Sales analysis report"
+        description="Process sales data and generate reports"
     )
     ```
   </Accordion>
@@ -223,7 +329,7 @@ agents.start()
 processor = Agent(
     name="Processor",
     role="Excel Processor",
-    tools=[excel]
+    tools=[read_excel, write_excel, merge_excel]
 )
 
 # Analysis agent
@@ -248,3 +354,89 @@ agents = PraisonAIAgents(
     agents=[processor, analyzer],
     tasks=[process_task, analyze_task]
 )
+
+```
+
+## Dependencies
+
+The Excel tools require the following Python packages:
+- pandas: For data manipulation
+- openpyxl: For Excel file operations
+
+These will be automatically installed when needed.
+
+## Example Agent Configuration
+
+```python
+from praisonaiagents import Agent
+from praisonaiagents.tools import read_excel, write_excel, merge_excel
+
+agent = Agent(
+    name="ExcelProcessor",
+    description="An agent that processes Excel files",
+    tools=[read_excel, write_excel, merge_excel]
+)
+```
+
+## Error Handling
+
+All functions include comprehensive error handling:
+- File not found errors
+- Permission errors
+- Invalid sheet names
+- Data format errors
+- Missing dependency errors
+
+Errors are logged and returned in a consistent format:
+- Success cases return the expected data type
+- Error cases return a dict with an "error" key containing the error message
+
+## Common Use Cases
+
+1. Data Analysis:
+```python
+# Read and analyze employee data
+data = read_excel(
+    "employees.xlsx",
+    sheet_name="Salaries",
+    usecols=["department", "salary"]
+)
+
+# Write summary to new sheet
+summary = [
+    {"department": dept, "avg_salary": sum(d["salary"] for d in dept_data) / len(dept_data)}
+    for dept, dept_data in groupby(data, key=lambda x: x["department"])
+]
+write_excel("summary.xlsx", summary, sheet_name="Salary Summary")
+```
+
+2. Data Consolidation:
+```python
+# Merge monthly reports
+monthly_files = ["jan.xlsx", "feb.xlsx", "mar.xlsx"]
+merge_excel(
+    files=monthly_files,
+    output_file="q1_report.xlsx",
+    how='outer',
+    on='transaction_id'
+)
+```
+
+3. Multi-sheet Processing:
+```python
+# Read multiple sheets
+data = read_excel(
+    "company_data.xlsx",
+    sheet_name=None  # Read all sheets
+)
+
+# Process each sheet
+processed = {
+    sheet: [process_record(record) for record in records]
+    for sheet, records in data.items()
+}
+
+# Write back to new file
+write_excel("processed_data.xlsx", processed)
+
+```

docs/tools/file_tools.mdx

@@ -1,6 +1,6 @@
 ---
-title: "File Tools"
-description: "File system operations and management tools for AI agents."
+title: "File Agent"
+description: "File system operation tools for AI agents."
 icon: "folder"
 ---
 
@@ -11,9 +11,9 @@ icon: "folder"
   - Basic understanding of file operations
 </Note>
 
-## Quick Start
+## File Tools
 
-Use File Tools to manage files and directories with AI agents.
+Use File Tools to perform file system operations with AI agents.
 
 <Steps>
   <Step title="Install Dependencies">
@@ -27,7 +27,7 @@ Use File Tools to manage files and directories with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import file_tools
+    from praisonaiagents.tools import read_file, write_file, list_files, get_file_info, copy_file, move_file, delete_file
     ```
   </Step>
 
@@ -39,7 +39,7 @@ Use File Tools to manage files and directories with AI agents.
         role="File System Specialist",
         goal="Manage files and directories efficiently.",
         backstory="Expert in file system operations and organization.",
-        tools=[file_tools],
+        tools=[read_file, write_file, list_files, get_file_info, copy_file, move_file, delete_file],
         self_reflect=False
     )
     ```
@@ -87,7 +87,7 @@ Use File Tools to manage files and directories with AI agents.
   <Card title="File Agent" icon="user-robot">
     Create specialized file agents:
     ```python
-    Agent(tools=[file_tools])
+    Agent(tools=[read_file, write_file, list_files, get_file_info, copy_file, move_file, delete_file])
     ```
   </Card>
   <Card title="File Task" icon="list-check">
@@ -110,28 +110,249 @@ Use File Tools to manage files and directories with AI agents.
   </Card>
 </CardGroup>
 
+## Available Functions
+
+```python
+from praisonaiagents.tools import read_file
+from praisonaiagents.tools import write_file
+from praisonaiagents.tools import list_files
+from praisonaiagents.tools import get_file_info
+from praisonaiagents.tools import copy_file
+from praisonaiagents.tools import move_file
+from praisonaiagents.tools import delete_file
+```
+
+## Function Details
+
+### read_file(filepath: str, encoding: str = 'utf-8')
+
+Reads content from a file:
+- Supports different encodings
+- Error handling for missing files
+- Automatic encoding detection
+
+```python
+# Basic usage
+content = read_file("example.txt")
+
+# With specific encoding
+content = read_file("data.txt", encoding="latin-1")
+
+# Returns: str (file content)
+# Error case: Returns error message as string
+```
+
+### write_file(filepath: str, content: str, encoding: str = 'utf-8')
+
+Writes content to a file:
+- Creates directories if they don't exist
+- Supports different encodings
+- Overwrites existing files
+
+```python
+# Basic usage
+success = write_file("output.txt", "Hello World")
+
+# With specific encoding and nested path
+success = write_file(
+    "path/to/data/output.txt",
+    "Content with special chars: áéíóú",
+    encoding="utf-8"
+)
+# Returns: bool (True if successful)
+```
+
+### list_files(directory: str, pattern: Optional[str] = None)
+
+Lists files in a directory:
+- Optional pattern matching
+- Detailed file information
+- Recursive directory support
+
+```python
+# List all files
+files = list_files("/path/to/directory")
+
+# With pattern matching
+files = list_files("/path/to/directory", pattern="*.txt")
+
+# Returns: List[Dict[str, Union[str, int]]]
+# Example: [
+#   {
+#     'name': 'example.txt',
+#     'path': '/path/to/directory/example.txt',
+#     'size': 1024,
+#     'modified': 1609459200.0,
+#     'created': 1609459100.0
+#   },
+#   ...
+# ]
+```
+
+### get_file_info(filepath: str)
+
+Gets detailed information about a file:
+- File metadata
+- Size and timestamps
+- Type information
+- Path details
+
+```python
+# Get file information
+info = get_file_info("example.txt")
+
+# Returns: Dict[str, Union[str, int]]
+# Example: {
+#   'name': 'example.txt',
+#   'path': '/absolute/path/to/example.txt',
+#   'size': 1024,
+#   'modified': 1609459200.0,
+#   'created': 1609459100.0,
+#   'is_file': True,
+#   'is_dir': False,
+#   'extension': '.txt',
+#   'parent': '/absolute/path/to'
+# }
+```
+
+### copy_file(src: str, dst: str)
+
+Copies a file with metadata:
+- Preserves timestamps
+- Creates destination directories
+- Handles existing files
+
+```python
+# Basic copy
+success = copy_file("source.txt", "destination.txt")
+
+# Copy to new directory
+success = copy_file(
+    "data.txt",
+    "backup/2023/data_backup.txt"
+)
+# Returns: bool (True if successful)
+```
+
+### move_file(src: str, dst: str)
+
+Moves or renames a file:
+- Creates destination directories
+- Handles existing files
+- Cross-device moves
+
+```python
+# Move file
+success = move_file("old/path/file.txt", "new/path/file.txt")
+
+# Rename file
+success = move_file(
+    "document.txt",
+    "document_v2.txt"
+)
+# Returns: bool (True if successful)
+```
+
+### delete_file(filepath: str)
+
+Deletes a file:
+- Safe deletion
+- Error handling
+- Non-recursive (files only)
+
+```python
+# Delete file
+success = delete_file("unwanted.txt")
+# Returns: bool (True if successful)
+```
+
+## Example Agent Configuration
+
+```python
+from praisonaiagents import Agent
+from praisonaiagents.tools import (
+    read_file, write_file, list_files,
+    get_file_info, copy_file, move_file, delete_file
+)
+
+agent = Agent(
+    name="FileManager",
+    description="An agent that manages files",
+    tools=[
+        read_file, write_file, list_files,
+        get_file_info, copy_file, move_file, delete_file
+    ]
+)
+```
+
+## Error Handling
+
+All functions include comprehensive error handling:
+- File not found errors
+- Permission errors
+- Path errors
+- I/O errors
+- Encoding errors
+
+Errors are handled consistently:
+- File operations return bool for success/failure
+- Information functions return error details in result
+- All errors are logged for debugging
+
+## Common Use Cases
+
+1. File Organization:
+```python
+# List and organize files by extension
+files = list_files("downloads", pattern="*.*")
+for file in files:
+    ext = file['extension']
+    if ext:
+        dst = f"organized/{ext[1:]}/{file['name']}"
+        move_file(file['path'], dst)
+```
+
+2. File Backup:
+```python
+# Create timestamped backups
+import time
+files = list_files("important_data")
+backup_time = time.strftime("%Y%m%d_%H%M%S")
+for file in files:
+    dst = f"backup/{backup_time}/{file['name']}"
+    copy_file(file['path'], dst)
+```
+
+3. File Processing:
+```python
+# Read, process, and write files
+content = read_file("input.txt")
+processed = process_content(content)  # Your processing function
+write_file("output.txt", processed)
+```
+
 ## Examples
 
 ### Basic File Management Agent
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import file_tools
+from praisonaiagents.tools import read_file, write_file, list_files, get_file_info
 
 # Create file management agent
 file_agent = Agent(
-    name="FileOrganizer",
-    role="File System Manager",
-    goal="Organize and manage files efficiently.",
-    backstory="Expert in file organization and system management.",
-    tools=[file_tools],
+    name="FileExpert",
+    role="File Manager",
+    goal="Process and organize files efficiently.",
+    backstory="Expert in file system operations and organization.",
+    tools=[read_file, write_file, list_files, get_file_info],
     self_reflect=False
 )
 
 # Define file task
 file_task = Task(
-    description="Sort documents by type and create backup copies.",
-    expected_output="Organized file structure with backups.",
+    description="Organize and process documents.",
+    expected_output="Organized file structure.",
     agent=file_agent,
     name="file_organization"
 )
@@ -145,44 +366,46 @@ agents = PraisonAIAgents(
 agents.start()
 ```
 
-### Advanced File Management with Multiple Agents
+### Advanced File Operations with Multiple Agents
 
 ```python
-# Create file organization agent
-organizer_agent = Agent(
-    name="Organizer",
-    role="File Organizer",
-    goal="Sort and organize files systematically.",
-    tools=[file_tools],
+# Create file IO agent
+io_agent = Agent(
+    name="FileIO",
+    role="File IO Specialist",
+    goal="Handle file read/write operations efficiently.",
+    tools=[read_file, write_file],
     self_reflect=False
 )
 
-# Create backup agent
-backup_agent = Agent(
-    name="Backup",
-    role="Backup Manager",
-    goal="Create and manage file backups.",
-    backstory="Expert in data backup and recovery.",
+# Create file management agent
+management_agent = Agent(
+    name="FileManager",
+    role="File Management Specialist",
+    goal="Handle file organization and movement.",
+    tools=[list_files, get_file_info, copy_file, move_file, delete_file],
     self_reflect=False
 )
 
 # Define tasks
-organize_task = Task(
-    description="Organize files by type and date.",
-    agent=organizer_agent,
-    name="organize_files"
+io_task = Task(
+    description="Read and write files.",
+    expected_output="File operations completed successfully.",
+    agent=io_agent,
+    name="file_io"
 )
 
-backup_task = Task(
-    description="Create backups of organized files.",
-    agent=backup_agent,
-    name="backup_files"
+management_task = Task(
+    description="Organize and move files.",
+    expected_output="File management completed successfully.",
+    agent=management_agent,
+    name="file_management"
 )
 
 # Run agents
 agents = PraisonAIAgents(
-    agents=[organizer_agent, backup_agent],
-    tasks=[organize_task, backup_task],
+    agents=[io_agent, management_agent],
+    tasks=[io_task, management_task],
     process="sequential"
 )
 agents.start()
@@ -198,7 +421,7 @@ agents.start()
         name="FileManager",
         role="File System Specialist",
         goal="Manage files efficiently and safely",
-        tools=[file_tools]
+        tools=[read_file, write_file, list_files, get_file_info, copy_file, move_file, delete_file]
     )
     ```
   </Accordion>
@@ -222,7 +445,7 @@ agents.start()
 organizer = Agent(
     name="Organizer",
     role="File Organizer",
-    tools=[file_tools]
+    tools=[read_file, write_file, list_files, get_file_info, copy_file, move_file, delete_file]
 )
 
 # Cleanup agent

docs/tools/json_tools.mdx

@@ -1,6 +1,6 @@
 ---
-title: "JSON Tools"
-description: "JSON file processing tools for AI agents."
+title: "JSON Agent"
+description: "JSON data processing tools for AI agents."
 icon: "brackets-curly"
 ---
 
@@ -11,7 +11,7 @@ icon: "brackets-curly"
   - Basic understanding of JSON format
 </Note>
 
-## Quick Start
+## JSON Tools
 
 Use JSON Tools to process and manipulate JSON files with AI agents.
 
@@ -27,7 +27,10 @@ Use JSON Tools to process and manipulate JSON files with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import json
+    from praisonaiagents.tools import (
+        read_json, write_json, merge_json,
+        validate_json, analyze_json, transform_json
+    )
     ```
   </Step>
 
@@ -39,7 +42,10 @@ Use JSON Tools to process and manipulate JSON files with AI agents.
         role="JSON Processing Specialist",
         goal="Process JSON files efficiently and accurately.",
         backstory="Expert in JSON file manipulation and validation.",
-        tools=[json],
+        tools=[
+            read_json, write_json, merge_json,
+            validate_json, analyze_json, transform_json
+        ],
         self_reflect=False
     )
     ```
@@ -74,11 +80,11 @@ Use JSON Tools to process and manipulate JSON files with AI agents.
 
 <Card title="What are JSON Tools?" icon="question">
   JSON Tools provide JSON processing capabilities for AI agents:
-  - JSON parsing
-  - File validation
-  - Data extraction
-  - Structure manipulation
-  - Format conversion
+  - File reading and writing
+  - Data validation
+  - Schema validation
+  - Data transformation
+  - Structure analysis
 </Card>
 
 ## Key Components
@@ -87,7 +93,7 @@ Use JSON Tools to process and manipulate JSON files with AI agents.
   <Card title="JSON Agent" icon="user-robot">
     Create specialized JSON agents:
     ```python
-    Agent(tools=[json])
+    Agent(tools=[read_json, write_json, merge_json, validate_json, analyze_json, transform_json])
     ```
   </Card>
   <Card title="JSON Task" icon="list-check">
@@ -103,9 +109,341 @@ Use JSON Tools to process and manipulate JSON files with AI agents.
     ```
   </Card>
   <Card title="JSON Options" icon="sliders">
-    Customize JSON parameters:
+    Customize JSON operations:
     ```python
-    indent=2, encoding="utf-8"
+    indent=2, sort_keys=True
+    ```
+  </Card>
+</CardGroup>
+
+## Available Functions
+
+```python
+from praisonaiagents.tools import read_json
+from praisonaiagents.tools import write_json
+from praisonaiagents.tools import merge_json
+from praisonaiagents.tools import validate_json
+from praisonaiagents.tools import analyze_json
+from praisonaiagents.tools import transform_json
+```
+
+## Function Details
+
+### read_json(filepath: str, encoding: str = 'utf-8', validate_schema: Optional[Dict[str, Any]] = None)
+
+Reads JSON files with schema validation:
+- Optional schema validation
+- Custom encoding support
+- Error handling
+
+```python
+# Basic usage
+data = read_json("config.json")
+
+# With schema validation
+schema = {
+    "type": "object",
+    "properties": {
+        "name": {"type": "string"},
+        "age": {"type": "integer"}
+    }
+}
+data = read_json(
+    "user.json",
+    encoding="utf-8",
+    validate_schema=schema
+)
+
+# Returns: Dict[str, Any] (JSON data)
+# Error case: Returns dict with 'error' key
+```
+
+### write_json(data: Union[Dict[str, Any], List[Any]], filepath: str, encoding: str = 'utf-8', indent: int = 2, sort_keys: bool = False, ensure_ascii: bool = False)
+
+Writes data to JSON files:
+- Pretty printing with indentation
+- Optional key sorting
+- Unicode support
+- Directory creation
+
+```python
+# Basic usage
+data = {"name": "Alice", "age": 30}
+success = write_json(data, "output.json")
+
+# With formatting options
+data = {
+    "users": [
+        {"name": "Alice", "age": 30},
+        {"name": "Bob", "age": 25}
+    ]
+}
+success = write_json(
+    data,
+    "users.json",
+    indent=4,
+    sort_keys=True,
+    ensure_ascii=False
+)
+# Returns: bool (True if successful)
+```
+
+### merge_json(files: List[str], output_file: str, merge_arrays: bool = True, overwrite_duplicates: bool = True)
+
+Merges multiple JSON files:
+- Deep merging of objects
+- Array handling options
+- Duplicate key handling
+- Nested structure support
+
+```python
+# Merge configuration files
+success = merge_json(
+    files=["config1.json", "config2.json"],
+    output_file="merged_config.json"
+)
+
+# Advanced merge with options
+success = merge_json(
+    files=["base.json", "override.json"],
+    output_file="final.json",
+    merge_arrays=True,
+    overwrite_duplicates=False
+)
+# Returns: bool (True if successful)
+```
+
+### validate_json(data: Union[Dict[str, Any], str], schema: Dict[str, Any])
+
+Validates JSON against a schema:
+- JSON Schema support
+- Detailed error messages
+- File or data validation
+
+```python
+# Validate data
+schema = {
+    "type": "object",
+    "required": ["name", "email"],
+    "properties": {
+        "name": {"type": "string"},
+        "email": {"type": "string", "format": "email"},
+        "age": {"type": "integer", "minimum": 0}
+    }
+}
+
+# Validate data directly
+data = {"name": "Alice", "email": "[email protected]", "age": 25}
+is_valid, error = validate_json(data, schema)
+
+# Validate file
+is_valid, error = validate_json("user.json", schema)
+# Returns: Tuple[bool, Optional[str]]
+```
+
+### analyze_json(data: Union[Dict[str, Any], str], max_depth: int = 10)
+
+Analyzes JSON structure:
+- Type information
+- Size metrics
+- Nested structure analysis
+- Sample data
+
+```python
+# Analyze file
+analysis = analyze_json("data.json", max_depth=5)
+
+# Analyze data structure
+data = {
+    "users": [
+        {"name": "Alice", "scores": [95, 87, 92]},
+        {"name": "Bob", "scores": [88, 85, 90]}
+    ]
+}
+analysis = analyze_json(data)
+
+# Returns: Dict[str, Any]
+# Example output:
+# {
+#   'analysis_time': '2023-01-01T12:00:00',
+#   'structure': {
+#     'type': 'dict',
+#     'size': 1,
+#     'keys': ['users'],
+#     'children': {
+#       'users': {
+#         'type': 'list',
+#         'length': 2,
+#         'element_types': ['dict'],
+#         'sample_elements': [...]
+#       }
+#     }
+#   }
+# }
+```
+
+### transform_json(data: Union[Dict[str, Any], str], transformations: List[Dict[str, Any]])
+
+Transforms JSON data:
+- Multiple operations
+- Path-based modifications
+- Nested transformations
+- Operation types: set, delete, rename, move
+
+```python
+# Transform data
+transformations = [
+    {
+        "operation": "set",
+        "path": "user.settings.theme",
+        "value": "dark"
+    },
+    {
+        "operation": "move",
+        "path": "old.config",
+        "value": "new.config"
+    },
+    {
+        "operation": "delete",
+        "path": "temporary.data"
+    }
+]
+
+# Transform file
+result = transform_json("config.json", transformations)
+
+# Transform data directly
+data = {"user": {"name": "Alice"}}
+result = transform_json(data, transformations)
+# Returns: Dict[str, Any] (transformed data)
+```
+
+## Example Agent Configuration
+
+```python
+from praisonaiagents import Agent
+from praisonaiagents.tools import (
+    read_json, write_json, merge_json,
+    validate_json, analyze_json, transform_json
+)
+
+agent = Agent(
+    name="JSONProcessor",
+    description="An agent that processes JSON data",
+    tools=[
+        read_json, write_json, merge_json,
+        validate_json, analyze_json, transform_json
+    ]
+)
+```
+
+## Dependencies
+
+The JSON tools require the following Python packages:
+- jsonschema: For JSON schema validation
+
+These will be automatically installed when needed.
+
+## Error Handling
+
+All functions include comprehensive error handling:
+- File I/O errors
+- JSON parsing errors
+- Schema validation errors
+- Transformation errors
+
+Errors are handled consistently:
+- File operations return bool for success/failure
+- Data operations return error details in result
+- All errors are logged for debugging
+
+## Common Use Cases
+
+1. Configuration Management:
+```python
+# Merge multiple config files
+success = merge_json(
+    ["base_config.json", "env_config.json", "user_config.json"],
+    "final_config.json",
+    merge_arrays=True,
+    overwrite_duplicates=True
+)
+
+# Validate configuration
+schema = {
+    "type": "object",
+    "required": ["database", "api"],
+    "properties": {
+        "database": {
+            "type": "object",
+            "required": ["host", "port"]
+        },
+        "api": {
+            "type": "object",
+            "required": ["key"]
+        }
+    }
+}
+is_valid, error = validate_json("final_config.json", schema)
+```
+
+2. Data Analysis:
+```python
+# Analyze data structure
+analysis = analyze_json("large_dataset.json", max_depth=3)
+print(f"Dataset size: {analysis['structure']['size']} entries")
+print(f"Available fields: {analysis['structure']['keys']}")
+```
+
+3. Data Transformation:
+```python
+# Transform data format
+transformations = [
+    {"operation": "rename", "path": "firstName", "value": "first_name"},
+    {"operation": "rename", "path": "lastName", "value": "last_name"},
+    {"operation": "move", "path": "address.zip", "value": "address.postal_code"},
+    {"operation": "delete", "path": "temporary_data"}
+]
+result = transform_json("user_data.json", transformations)
+write_json(result, "transformed_data.json")
+```
+
+## Understanding JSON Tools
+
+<Card title="What are JSON Tools?" icon="question">
+  JSON Tools provide JSON processing capabilities for AI agents:
+  - File reading and writing
+  - Data validation
+  - Schema validation
+  - Data transformation
+  - Structure analysis
+</Card>
+
+## Key Components
+
+<CardGroup cols={2}>
+  <Card title="JSON Agent" icon="user-robot">
+    Create specialized JSON agents:
+    ```python
+    Agent(tools=[read_json, write_json, merge_json, validate_json, analyze_json, transform_json])
+    ```
+  </Card>
+  <Card title="JSON Task" icon="list-check">
+    Define JSON tasks:
+    ```python
+    Task(description="json_operation")
+    ```
+  </Card>
+  <Card title="Process Types" icon="arrows-split-up-and-left">
+    Sequential or parallel processing:
+    ```python
+    process="sequential"
+    ```
+  </Card>
+  <Card title="JSON Options" icon="sliders">
+    Customize JSON operations:
+    ```python
+    indent=2, sort_keys=True
     ```
   </Card>
 </CardGroup>
@@ -116,24 +454,24 @@ Use JSON Tools to process and manipulate JSON files with AI agents.
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import json
+from praisonaiagents.tools import read_json, write_json, validate_json
 
-# Create JSON agent
+# Create JSON processing agent
 json_agent = Agent(
     name="JSONExpert",
-    role="JSON Processing Specialist",
-    goal="Process JSON files efficiently and accurately.",
-    backstory="Expert in JSON file handling and validation.",
-    tools=[json],
+    role="JSON Processor",
+    goal="Process and validate JSON data efficiently.",
+    backstory="Expert in JSON processing and validation.",
+    tools=[read_json, write_json, validate_json],
     self_reflect=False
 )
 
 # Define JSON task
 json_task = Task(
-    description="Parse and validate API configurations.",
-    expected_output="Processed and validated JSON data.",
+    description="Process and validate configuration files.",
+    expected_output="Validated JSON configuration.",
     agent=json_agent,
-    name="config_processing"
+    name="config_validation"
 )
 
 # Run agent
@@ -145,44 +483,44 @@ agents = PraisonAIAgents(
 agents.start()
 ```
 
-### Advanced JSON Processing with Multiple Agents
+### Advanced JSON Operations with Multiple Agents
 
 ```python
-# Create JSON processing agent
-processor_agent = Agent(
-    name="Processor",
-    role="JSON Processor",
-    goal="Process JSON files systematically.",
-    tools=[json],
+# Create JSON validation agent
+validation_agent = Agent(
+    name="Validator",
+    role="JSON Validation Specialist",
+    goal="Ensure JSON data integrity and schema compliance.",
+    tools=[validate_json, analyze_json],
     self_reflect=False
 )
 
-# Create validation agent
-validator_agent = Agent(
-    name="Validator",
-    role="Data Validator",
-    goal="Validate JSON structure and content.",
-    backstory="Expert in data validation and verification.",
+# Create JSON transformation agent
+transform_agent = Agent(
+    name="Transformer",
+    role="JSON Transformation Specialist",
+    goal="Transform and merge JSON data structures.",
+    tools=[transform_json, merge_json],
     self_reflect=False
 )
 
 # Define tasks
-processing_task = Task(
-    description="Process and transform JSON configurations.",
-    agent=processor_agent,
-    name="json_processing"
-)
-
 validation_task = Task(
-    description="Validate processed JSON data.",
-    agent=validator_agent,
-    name="data_validation"
-)
+    description="Validate JSON data",
+    agent=validation_agent,
+    name="json_validation"
+)   
+
+transform_task = Task(
+    description="Transform JSON data",
+    agent=transform_agent,
+    name="json_transformation"
+)   
 
 # Run agents
 agents = PraisonAIAgents(
-    agents=[processor_agent, validator_agent],
-    tasks=[processing_task, validation_task],
+    agents=[validation_agent, transform_agent],
+    tasks=[validation_task, transform_task],
     process="sequential"
 )
 agents.start()
@@ -198,7 +536,7 @@ agents.start()
         name="JSONProcessor",
         role="JSON Processing Specialist",
         goal="Process JSON files accurately and safely",
-        tools=[json]
+        tools=[read_json, write_json, merge_json, validate_json, analyze_json, transform_json]
     )
     ```
   </Accordion>
@@ -222,7 +560,7 @@ agents.start()
 processor = Agent(
     name="Processor",
     role="JSON Processor",
-    tools=[json]
+    tools=[read_json, write_json, merge_json, validate_json, analyze_json, transform_json]
 )
 
 # Validation agent
@@ -247,4 +585,3 @@ agents = PraisonAIAgents(
     agents=[processor, validator],
     tasks=[process_task, validate_task]
 )
-```

docs/tools/newspaper_tools.mdx

@@ -1,6 +1,6 @@
 ---
-title: "Newspaper Tools"
-description: "News article scraping and analysis tools for AI agents."
+title: "Newspaper Agent"
+description: "News article extraction tools for AI agents."
 icon: "newspaper"
 ---
 
@@ -11,9 +11,9 @@ icon: "newspaper"
   - `newspaper3k` package installed
 </Note>
 
-## Quick Start
+## Newspaper Tools
 
-Use Newspaper Tools to scrape and analyze news articles with AI agents.
+Use Newspaper Tools to extract and analyze news articles with AI agents.
 
 <Steps>
   <Step title="Install Dependencies">
@@ -27,7 +27,7 @@ Use Newspaper Tools to scrape and analyze news articles with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import newspaper
+    from praisonaiagents.tools import get_article, get_news_sources, get_articles_from_source, get_trending_topics
     ```
   </Step>
 
@@ -39,7 +39,7 @@ Use Newspaper Tools to scrape and analyze news articles with AI agents.
         role="News Analyst",
         goal="Collect and analyze news articles from various sources.",
         backstory="Expert in news gathering and content analysis.",
-        tools=[newspaper],
+        tools=[get_article, get_news_sources, get_articles_from_source, get_trending_topics],
         self_reflect=False
     )
     ```
@@ -87,7 +87,7 @@ Use Newspaper Tools to scrape and analyze news articles with AI agents.
   <Card title="News Agent" icon="user-robot">
     Create specialized news agents:
     ```python
-    Agent(tools=[newspaper])
+    Agent(tools=[get_article, get_news_sources, get_articles_from_source, get_trending_topics])
     ```
   </Card>
   <Card title="News Task" icon="list-check">
@@ -110,30 +110,161 @@ Use Newspaper Tools to scrape and analyze news articles with AI agents.
   </Card>
 </CardGroup>
 
+## Available Functions
+
+```python
+from praisonaiagents.tools import get_article
+from praisonaiagents.tools import get_news_sources
+from praisonaiagents.tools import get_articles_from_source
+from praisonaiagents.tools import get_trending_topics
+```
+
+## Function Details
+
+### get_article(url: str, language: str = 'en')
+
+Extracts and parses news articles:
+- Full text extraction
+- Author detection
+- Date parsing
+- Image extraction
+- NLP processing
+
+```python
+# Basic usage
+article = get_article("https://example.com/article")
+
+# With language specification
+article = get_article(
+    "https://lemonde.fr/article",
+    language="fr"
+)
+
+# Returns: Dict[str, Any]
+# Example output:
+# {
+#   "url": "https://example.com/article",
+#   "title": "Breaking News Story",
+#   "text": "Full article text...",
+#   "authors": ["John Doe", "Jane Smith"],
+#   "publish_date": "2025-01-07T05:31:38",
+#   "top_image": "https://example.com/image.jpg",
+#   "images": ["https://example.com/image1.jpg", ...],
+#   "movies": ["https://example.com/video1.mp4", ...],
+#   "source_domain": "example.com",
+#   "keywords": ["technology", "ai", ...],
+#   "summary": "Article summary..."
+# }
+```
+
+### get_news_sources(category: Optional[str] = None, language: str = 'en', country: Optional[str] = None)
+
+Gets news sources by category:
+- Category filtering
+- Language support
+- Country filtering
+- Domain information
+
+```python
+# Get all sources
+sources = get_news_sources()
+
+# Get technology news sources
+tech_sources = get_news_sources(
+    category="technology",
+    language="en",
+    country="us"
+)
+
+# Returns: List[Dict[str, str]]
+# Example output:
+# [
+#   {
+#     "url": "https://techcrunch.com",
+#     "domain": "techcrunch.com",
+#     "name": "TechCrunch",
+#     "category": "technology"
+#   },
+#   ...
+# ]
+```
+
+### get_articles_from_source(source_url: str, limit: int = 10, language: str = 'en')
+
+Gets recent articles from a source:
+- Configurable limit
+- Language support
+- Full article parsing
+- Error handling
+
+```python
+# Get latest articles
+articles = get_articles_from_source(
+    "https://techcrunch.com",
+    limit=5
+)
+
+# Get articles in specific language
+articles = get_articles_from_source(
+    "https://lemonde.fr",
+    limit=10,
+    language="fr"
+)
+
+# Returns: List[Dict[str, Any]]
+# Each article has the same structure as get_article()
+```
+
+### get_trending_topics(sources: Optional[List[str]] = None, limit: int = 10, language: str = 'en')
+
+Analyzes trending topics:
+- Cross-source analysis
+- Keyword extraction
+- Customizable sources
+- Topic ranking
+
+```python
+# Get trending topics from default sources
+topics = get_trending_topics(limit=5)
+
+# Get topics from specific sources
+topics = get_trending_topics(
+    sources=[
+        "https://techcrunch.com",
+        "https://wired.com"
+    ],
+    limit=10,
+    language="en"
+)
+
+# Returns: List[str]
+# Example: ["artificial intelligence", "climate change", ...]
+```
+
 ## Examples
 
 ### Basic News Agent
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import newspaper
+from praisonaiagents.tools import get_article, get_news_sources, get_articles_from_source, get_trending_topics
 
 # Create news agent
 news_agent = Agent(
-    name="NewsCollector",
+    name="NewsExpert",
     role="News Analyst",
-    goal="Collect and analyze news articles on specific topics.",
-    backstory="Expert in news gathering and content analysis.",
-    tools=[newspaper],
+    goal="Gather and analyze news content efficiently.",
+    backstory="Expert in news analysis and content curation.",
+    tools=[get_article, get_news_sources, get_articles_from_source, get_trending_topics],
     self_reflect=False
 )
 
 # Define news task
 news_task = Task(
-    description="Analyze recent tech news articles about 'artificial intelligence'.",
-    expected_output="Summary of key AI developments with source articles.",
+    description="Analyze tech news trends.",
+    expected_output="Tech news analysis report.",
     agent=news_agent,
-    name="tech_news"
+    name="tech_news_analysis"
 )
 
 # Run agent
@@ -153,7 +284,7 @@ collector_agent = Agent(
     name="Collector",
     role="News Collector",
     goal="Gather comprehensive news coverage.",
-    tools=[newspaper],
+    tools=[get_article, get_news_sources, get_articles_from_source, get_trending_topics],
     self_reflect=False
 )
 
@@ -198,7 +329,7 @@ agents.start()
         name="NewsAnalyst",
         role="News Specialist",
         goal="Analyze news content effectively",
-        tools=[newspaper]
+        tools=[get_article, get_news_sources, get_articles_from_source, get_trending_topics]
     )
     ```
   </Accordion>
@@ -222,7 +353,7 @@ agents.start()
 monitor = Agent(
     name="Monitor",
     role="News Monitor",
-    tools=[newspaper]
+    tools=[get_article, get_news_sources, get_articles_from_source, get_trending_topics]
 )
 
 # Analysis agent
@@ -247,3 +378,87 @@ agents = PraisonAIAgents(
     agents=[monitor, analyst],
     tasks=[monitor_task, analysis_task]
 )
+
+```
+
+## Example Agent Configuration
+
+```python
+from praisonaiagents import Agent
+from praisonaiagents.tools import (
+    get_article, get_news_sources,
+    get_articles_from_source, get_trending_topics
+)
+
+agent = Agent(
+    name="NewsAnalyzer",
+    description="An agent that analyzes news articles",
+    tools=[
+        get_article, get_news_sources,
+        get_articles_from_source, get_trending_topics
+    ]
+)
+```
+
+## Dependencies
+
+The newspaper tools require the following Python packages:
+- newspaper3k: For article extraction and parsing
+- nltk: For NLP processing (automatically installed with newspaper3k)
+
+These will be automatically installed when needed.
+
+## Error Handling
+
+All functions include comprehensive error handling:
+- Network errors
+- Parsing errors
+- Language errors
+- Source availability errors
+
+Errors are handled consistently:
+- Success cases return the expected data type
+- Error cases return a dict with an "error" key
+- All errors are logged for debugging
+
+## Common Use Cases
+
+1. News Monitoring:
+```python
+# Monitor tech news
+sources = get_news_sources(category="technology")
+for source in sources:
+    articles = get_articles_from_source(
+        source["url"],
+        limit=5
+    )
+    for article in articles:
+        if "ai" in article.get("keywords", []):
+            print(f"AI article found: {article['title']}")
+```
+
+2. Trend Analysis:
+```python
+# Analyze trending topics
+topics = get_trending_topics(limit=10)
+print("Current hot topics:")
+for i, topic in enumerate(topics, 1):
+    print(f"{i}. {topic}")
+```
+
+3. Content Aggregation:
+```python
+# Aggregate news from multiple sources
+def aggregate_news(categories):
+    all_articles = []
+    for category in categories:
+        sources = get_news_sources(category=category)
+        for source in sources[:3]:  # Top 3 sources per category
+            articles = get_articles_from_source(
+                source["url"],
+                limit=3
+            )
+            all_articles.extend(articles)
+    return all_articles
+
+news = aggregate_news(["technology", "business", "science"])

docs/tools/pandas_tools.mdx

@@ -1,6 +1,6 @@
 ---
-title: "Pandas Tools"
-description: "Data manipulation and analysis tools for AI agents using pandas."
+title: "Pandas Agent"
+description: "Pandas data manipulation tools for AI agents."
 icon: "table"
 ---
 
@@ -11,7 +11,7 @@ icon: "table"
   - `pandas` package installed
 </Note>
 
-## Quick Start
+## Pandas Tools
 
 Use Pandas Tools to manipulate and analyze data with AI agents.
 
@@ -27,7 +27,7 @@ Use Pandas Tools to manipulate and analyze data with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import pandas_tools
+    from praisonaiagents.tools import read_csv, read_excel, write_csv, write_excel, filter_data, get_summary, group_by, pivot_table
     ```
   </Step>
 
@@ -39,7 +39,7 @@ Use Pandas Tools to manipulate and analyze data with AI agents.
         role="Data Analysis Specialist",
         goal="Analyze and transform data efficiently.",
         backstory="Expert in data manipulation and statistical analysis.",
-        tools=[pandas_tools],
+        tools=[read_csv, read_excel, write_csv, write_excel, filter_data, get_summary, group_by, pivot_table],
         self_reflect=False
     )
     ```
@@ -87,7 +87,7 @@ Use Pandas Tools to manipulate and analyze data with AI agents.
   <Card title="Data Agent" icon="user-robot">
     Create specialized data agents:
     ```python
-    Agent(tools=[pandas_tools])
+    Agent(tools=[read_csv, read_excel, write_csv, write_excel, filter_data, get_summary, group_by, pivot_table])
     ```
   </Card>
   <Card title="Analysis Task" icon="list-check">
@@ -110,30 +110,365 @@ Use Pandas Tools to manipulate and analyze data with AI agents.
   </Card>
 </CardGroup>
 
+## Available Functions
+
+```python
+from praisonaiagents.tools import read_csv
+from praisonaiagents.tools import read_excel
+from praisonaiagents.tools import write_csv
+from praisonaiagents.tools import write_excel
+from praisonaiagents.tools import filter_data
+from praisonaiagents.tools import get_summary
+from praisonaiagents.tools import group_by
+from praisonaiagents.tools import pivot_table
+```
+
+## Function Details
+
+### read_csv(filepath: str, **kwargs)
+
+Reads CSV files into pandas DataFrames:
+- Flexible data import
+- Error handling
+- Additional pandas options
+
+```python
+# Basic usage
+df = read_csv("data.csv")
+
+# With additional options
+df = read_csv(
+    "data.csv",
+    encoding="utf-8",
+    sep=",",
+    header=0,
+    usecols=["name", "age", "salary"]
+)
+
+# Returns: pd.DataFrame
+# Error case: Returns dict with 'error' key
+```
+
+### read_excel(filepath: str, **kwargs)
+
+Reads Excel files into pandas DataFrames:
+- Multiple sheet support
+- Error handling
+- Additional pandas options
+
+```python
+# Basic usage
+df = read_excel("data.xlsx")
+
+# With sheet specification
+df = read_excel(
+    "data.xlsx",
+    sheet_name="Sheet1",
+    header=0,
+    usecols="A:D"
+)
+
+# Returns: pd.DataFrame
+# Error case: Returns dict with 'error' key
+```
+
+### write_csv(df: pd.DataFrame, filepath: str, **kwargs)
+
+Writes DataFrames to CSV files:
+- Directory creation
+- Error handling
+- Formatting options
+
+```python
+# Basic usage
+success = write_csv(df, "output.csv")
+
+# With formatting options
+success = write_csv(
+    df,
+    "output.csv",
+    index=False,
+    encoding="utf-8",
+    sep=",",
+    date_format="%Y-%m-%d"
+)
+# Returns: bool (True if successful)
+```
+
+### write_excel(df: pd.DataFrame, filepath: str, **kwargs)
+
+Writes DataFrames to Excel files:
+- Directory creation
+- Error handling
+- Excel-specific options
+
+```python
+# Basic usage
+success = write_excel(df, "output.xlsx")
+
+# With formatting options
+success = write_excel(
+    df,
+    "output.xlsx",
+    sheet_name="Data",
+    index=False,
+    freeze_panes=(1,0)
+)
+# Returns: bool (True if successful)
+```
+
+### filter_data(df: pd.DataFrame, query: str)
+
+Filters DataFrames using query strings:
+- SQL-like syntax
+- Complex conditions
+- Efficient filtering
+
+```python
+# Basic filtering
+filtered_df = filter_data(df, "age > 25")
+
+# Complex conditions
+filtered_df = filter_data(
+    df,
+    "age > 25 and salary >= 50000 and city == 'New York'"
+)
+
+# Returns: pd.DataFrame
+# Error case: Returns dict with 'error' key
+```
+
+### get_summary(df: pd.DataFrame)
+
+Generates comprehensive data summaries:
+- Basic statistics
+- Data types
+- Memory usage
+- Null counts
+
+```python
+# Get data summary
+summary = get_summary(df)
+
+# Returns: Dict[str, Any]
+# Example output:
+# {
+#   "shape": [1000, 5],
+#   "columns": ["name", "age", "salary", "city"],
+#   "dtypes": {
+#     "name": "object",
+#     "age": "int64",
+#     "salary": "float64",
+#     "city": "object"
+#   },
+#   "null_counts": {
+#     "name": 0,
+#     "age": 2,
+#     "salary": 1,
+#     "city": 0
+#   },
+#   "numeric_summary": {
+#     "age": {
+#       "count": 998,
+#       "mean": 35.5,
+#       "std": 12.3,
+#       "min": 18,
+#       "25%": 28,
+#       "50%": 35,
+#       "75%": 45,
+#       "max": 65
+#     },
+#     ...
+#   },
+#   "memory_usage": 40960
+# }
+```
+
+### group_by(df: pd.DataFrame, columns: Union[str, List[str]], agg_dict: Dict[str, Union[str, List[str]]])
+
+Groups and aggregates data:
+- Multiple grouping columns
+- Multiple aggregations
+- Custom functions
+
+```python
+# Basic grouping
+grouped_df = group_by(
+    df,
+    columns="city",
+    agg_dict={"salary": "mean"}
+)
+
+# Complex grouping
+grouped_df = group_by(
+    df,
+    columns=["city", "department"],
+    agg_dict={
+        "salary": ["mean", "sum", "count"],
+        "age": ["min", "max", "mean"]
+    }
+)
+
+# Returns: pd.DataFrame
+# Error case: Returns dict with 'error' key
+```
+
+### pivot_table(df: pd.DataFrame, index: Union[str, List[str]], columns: Optional[Union[str, List[str]]] = None, values: Optional[Union[str, List[str]]] = None, aggfunc: str = "mean")
+
+Creates pivot tables:
+- Multiple index levels
+- Column pivoting
+- Custom aggregations
+- Flexible reshaping
+
+```python
+# Basic pivot
+pivot_df = pivot_table(
+    df,
+    index="city",
+    columns="department",
+    values="salary"
+)
+
+# Complex pivot
+pivot_df = pivot_table(
+    df,
+    index=["city", "department"],
+    columns="year",
+    values=["salary", "headcount"],
+    aggfunc={
+        "salary": "mean",
+        "headcount": "sum"
+    }
+)
+
+# Returns: pd.DataFrame
+# Error case: Returns dict with 'error' key
+```
+
+## Example Agent Configuration
+
+```python
+from praisonaiagents import Agent
+from praisonaiagents.tools import (
+    read_csv, read_excel, write_csv, write_excel,
+    filter_data, get_summary, group_by, pivot_table
+)
+
+agent = Agent(
+    name="DataAnalyzer",
+    description="An agent that analyzes data using pandas",
+    tools=[
+        read_csv, read_excel, write_csv, write_excel,
+        filter_data, get_summary, group_by, pivot_table
+    ]
+)
+```
+
+## Dependencies
+
+The pandas tools require the following Python packages:
+- pandas: For data manipulation and analysis
+- numpy: For numerical operations (automatically installed with pandas)
+- openpyxl: For Excel file support (optional)
+
+These will be automatically installed when needed.
+
+## Error Handling
+
+All functions include comprehensive error handling:
+- File I/O errors
+- Data format errors
+- Query syntax errors
+- Memory errors
+
+Errors are handled consistently:
+- File operations return bool for success/failure
+- Data operations return error details in result
+- All errors are logged for debugging
+
+## Common Use Cases
+
+1. Data Analysis:
+```python
+# Load and analyze sales data
+df = read_csv("sales_data.csv")
+summary = get_summary(df)
+print(f"Total records: {summary['shape'][0]}")
+print(f"Missing values: {summary['null_counts']}")
+
+# Filter high-value transactions
+high_value = filter_data(df, "amount > 10000")
+write_excel(high_value, "high_value_sales.xlsx")
+```
+
+2. Sales Reporting:
+```python
+# Create sales summary by region and product
+sales_summary = group_by(
+    df,
+    columns=["region", "product"],
+    agg_dict={
+        "amount": ["sum", "mean", "count"],
+        "profit": ["sum", "mean"]
+    }
+)
+
+# Create pivot table for quarterly analysis
+quarterly_sales = pivot_table(
+    df,
+    index="product",
+    columns="quarter",
+    values="amount",
+    aggfunc="sum"
+)
+```
+
+3. Data Transformation:
+```python
+# Load and clean customer data
+customers = read_excel("customers.xlsx")
+filtered = filter_data(
+    customers,
+    "age >= 18 and status == 'active'"
+)
+
+# Group by demographics
+demographics = group_by(
+    filtered,
+    columns=["age_group", "region"],
+    agg_dict={
+        "spending": ["mean", "sum"],
+        "visits": "count"
+    }
+)
+write_csv(demographics, "demographic_analysis.csv")
+```
+
 ## Examples
 
 ### Basic Data Analysis Agent
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import pandas_tools
+from praisonaiagents.tools import read_csv, filter_data, get_summary, group_by
 
 # Create data analysis agent
 data_agent = Agent(
-    name="DataAnalyst",
-    role="Data Analysis Specialist",
-    goal="Perform comprehensive data analysis.",
-    backstory="Expert in statistical analysis and data visualization.",
-    tools=[pandas_tools],
+    name="DataExpert",
+    role="Data Analyst",
+    goal="Process and analyze data efficiently.",
+    backstory="Expert in data analysis and statistical methods.",
+    tools=[read_csv, filter_data, get_summary, group_by],
     self_reflect=False
 )
 
 # Define analysis task
 analysis_task = Task(
-    description="Analyze customer demographics and purchase patterns.",
-    expected_output="Customer segmentation analysis with insights.",
+    description="Analyze sales performance data.",
+    expected_output="Sales analysis report.",
     agent=data_agent,
-    name="customer_analysis"
+    name="sales_analysis"
 )
 
 # Run agent
@@ -145,44 +480,44 @@ agents = PraisonAIAgents(
 agents.start()
 ```
 
-### Advanced Analysis with Multiple Agents
+### Advanced Data Operations with Multiple Agents
 
 ```python
-# Create data preparation agent
-prep_agent = Agent(
-    name="DataPrep",
-    role="Data Preparation Specialist",
-    goal="Clean and prepare data for analysis.",
-    tools=[pandas_tools],
+# Create data import/export agent
+io_agent = Agent(
+    name="DataIO",
+    role="Data IO Specialist",
+    goal="Handle data import and export operations.",
+    tools=[read_csv, read_excel, write_csv, write_excel],
     self_reflect=False
 )
 
 # Create analysis agent
 analysis_agent = Agent(
     name="Analyzer",
-    role="Statistical Analyst",
-    goal="Perform advanced statistical analysis.",
-    backstory="Expert in statistical modeling and interpretation.",
+    role="Data Analysis Specialist",
+    goal="Perform complex data analysis.",
+    tools=[filter_data, get_summary, group_by, pivot_table],
     self_reflect=False
 )
 
 # Define tasks
-prep_task = Task(
-    description="Clean and prepare sales data for analysis.",
-    agent=prep_agent,
-    name="data_prep"
+io_task = Task(
+    description="Import and export data",
+    agent=io_agent,
+    name="data_io"
 )
 
 analysis_task = Task(
-    description="Perform statistical analysis and generate insights.",
+    description="Analyze data",
     agent=analysis_agent,
-    name="statistical_analysis"
-)
+    name="data_analysis"
+)   
 
 # Run agents
 agents = PraisonAIAgents(
-    agents=[prep_agent, analysis_agent],
-    tasks=[prep_task, analysis_task],
+    agents=[io_agent, analysis_agent],
+    tasks=[io_task, analysis_task],
     process="sequential"
 )
 agents.start()
@@ -198,7 +533,7 @@ agents.start()
         name="DataScientist",
         role="Data Analysis Specialist",
         goal="Extract meaningful insights from data",
-        tools=[pandas_tools]
+        tools=[read_csv, read_excel, write_csv, write_excel, filter_data, get_summary, group_by, pivot_table]
     )
     ```
   </Accordion>
@@ -222,7 +557,7 @@ agents.start()
 prep_agent = Agent(
     name="Preparer",
     role="Data Preparation",
-    tools=[pandas_tools]
+    tools=[read_csv, read_excel, write_csv, write_excel, filter_data, get_summary, group_by, pivot_table]
 )
 
 # Analysis agent
@@ -247,4 +582,3 @@ agents = PraisonAIAgents(
     agents=[prep_agent, analyst],
     tasks=[prep_task, analysis_task]
 )
-```

docs/tools/python_tools.mdx

@@ -1,7 +1,7 @@
 ---
-title: "Python Tools"
+title: "Python Agent"
 description: "Python code execution tools for AI agents."
-icon: "python"
+icon: "code"
 ---
 
 <Note>
@@ -11,7 +11,7 @@ icon: "python"
   - Basic understanding of Python programming
 </Note>
 
-## Quick Start
+## Python Tools
 
 Use Python Tools to execute and manage Python code with AI agents.
 
@@ -27,7 +27,10 @@ Use Python Tools to execute and manage Python code with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import python
+    from praisonaiagents.tools import (
+        execute_code, analyze_code, format_code,
+        lint_code, disassemble_code
+    )
     ```
   </Step>
 
@@ -39,7 +42,10 @@ Use Python Tools to execute and manage Python code with AI agents.
         role="Python Code Specialist",
         goal="Execute Python code efficiently and safely.",
         backstory="Expert in Python programming and code execution.",
-        tools=[python],
+        tools=[
+            execute_code, analyze_code, format_code,
+            lint_code, disassemble_code
+        ],
         self_reflect=False
     )
     ```
@@ -70,6 +76,293 @@ Use Python Tools to execute and manage Python code with AI agents.
   </Step>
 </Steps>
 
+## Available Functions
+
+```python
+from praisonaiagents.tools import execute_code
+from praisonaiagents.tools import analyze_code
+from praisonaiagents.tools import format_code
+from praisonaiagents.tools import lint_code
+from praisonaiagents.tools import disassemble_code
+```
+
+## Function Details
+
+### execute_code(code: str, globals_dict: Optional[Dict[str, Any]] = None, locals_dict: Optional[Dict[str, Any]] = None, timeout: int = 30, max_output_size: int = 10000)
+
+Safely executes Python code:
+- Isolated execution environment
+- Output capture
+- Error handling
+- Timeout protection
+- Output size limits
+
+```python
+# Basic execution
+result = execute_code("print('Hello, World!')")
+
+# With custom environment
+result = execute_code(
+    """
+    x = 10
+    y = 20
+    print(f'Sum: {x + y}')
+    """,
+    globals_dict={'__builtins__': __builtins__},
+    timeout=5
+)
+
+# Returns: Dict[str, Any]
+# Example output:
+# {
+#     'result': None,
+#     'stdout': 'Hello, World!\n',
+#     'stderr': '',
+#     'success': True
+# }
+```
+
+### analyze_code(code: str)
+
+Analyzes Python code structure:
+- Import statements
+- Function definitions
+- Class definitions
+- Variable usage
+- Code complexity
+
+```python
+# Analyze code structure
+analysis = analyze_code("""
+def greet(name):
+    return f"Hello, {name}!"
+
+class Person:
+    def __init__(self, name):
+        self.name = name
+""")
+
+# Returns: Dict[str, Any]
+# Example output:
+# {
+#     'imports': [],
+#     'functions': [
+#         {
+#             'name': 'greet',
+#             'args': ['name'],
+#             'decorators': []
+#         }
+#     ],
+#     'classes': [
+#         {
+#             'name': 'Person',
+#             'bases': [],
+#             'decorators': []
+#         }
+#     ],
+#     'variables': ['name'],
+#     'complexity': {
+#         'lines': 6,
+#         'functions': 2,
+#         'classes': 1,
+#         'branches': 0
+#     }
+# }
+```
+
+### format_code(code: str, style: str = 'black', line_length: int = 88)
+
+Formats Python code:
+- Multiple style options
+- Line length control
+- PEP 8 compliance
+- Consistent formatting
+
+```python
+# Format with black
+formatted = format_code("""
+def messy_function(x,y,   z):
+    if x>0:
+     return y+z
+    else:
+     return y-z
+""")
+
+# Format with PEP 8
+formatted = format_code(
+    """
+    def messy_function(x,y,   z):
+        if x>0:
+         return y+z
+        else:
+         return y-z
+    """,
+    style='pep8',
+    line_length=79
+)
+
+# Returns: str
+# Example output:
+# def messy_function(x, y, z):
+#     if x > 0:
+#         return y + z
+#     else:
+#         return y - z
+```
+
+### lint_code(code: str)
+
+Lints Python code for issues:
+- Code quality checks
+- Style violations
+- Potential bugs
+- Best practices
+
+```python
+# Lint code for issues
+results = lint_code("""
+def bad_function():
+    unused_var = 42
+    return 'result'
+""")
+
+# Returns: Dict[str, List[Dict[str, Any]]]
+# Example output:
+# {
+#     'errors': [],
+#     'warnings': [
+#         {
+#             'type': 'warning',
+#             'module': 'bad_function',
+#             'obj': 'unused_var',
+#             'line': 2,
+#             'column': 4,
+#             'path': '<string>',
+#             'symbol': 'unused-variable',
+#             'message': 'Unused variable "unused_var"',
+#             'message-id': 'W0612'
+#         }
+#     ],
+#     'conventions': []
+# }
+```
+
+### disassemble_code(code: str)
+
+Disassembles Python code to bytecode:
+- Bytecode inspection
+- Performance analysis
+- Code optimization
+- Debugging support
+
+```python
+# Disassemble code to bytecode
+bytecode = disassemble_code("""
+def add(a, b):
+    return a + b
+""")
+
+# Returns: str
+# Example output:
+#  1           0 LOAD_CONST               0 (<code object add at ...>)
+#              2 LOAD_CONST               1 ('add')
+#              4 MAKE_FUNCTION            0
+#              6 STORE_NAME               0 (add)
+#              8 LOAD_CONST               2 (None)
+#             10 RETURN_VALUE
+```
+
+## Example Agent Configuration
+
+```python
+from praisonaiagents import Agent
+from praisonaiagents.tools import (
+    execute_code, analyze_code, format_code,
+    lint_code, disassemble_code
+)
+
+agent = Agent(
+    name="PythonDeveloper",
+    description="An agent that helps with Python development",
+    tools=[
+        execute_code, analyze_code, format_code,
+        lint_code, disassemble_code
+    ]
+)
+```
+
+## Dependencies
+
+The Python tools require the following packages:
+- black: For code formatting (black style)
+- autopep8: For code formatting (PEP 8 style)
+- pylint: For code linting
+
+These will be automatically installed when needed.
+
+## Error Handling
+
+All functions include comprehensive error handling:
+- Code execution errors
+- Syntax errors
+- Import errors
+- Timeout errors
+- Memory errors
+
+Errors are handled consistently:
+- Success cases return expected data type
+- Error cases return None or error details
+- All errors are logged for debugging
+
+## Common Use Cases
+
+1. Code Testing:
+```python
+# Test code execution
+test_code = """
+def factorial(n):
+    return 1 if n <= 1 else n * factorial(n - 1)
+
+result = factorial(5)
+print(f"Factorial: {result}")
+"""
+result = execute_code(test_code)
+print(f"Output: {result['stdout']}")
+```
+
+2. Code Quality:
+```python
+# Check code quality
+code = """
+def process_data(data):
+    processed = []
+    for item in data:
+        if item > 0:
+            processed.append(item * 2)
+    return processed
+"""
+analysis = analyze_code(code)
+lint_results = lint_code(code)
+formatted = format_code(code)
+```
+
+3. Code Analysis:
+```python
+# Analyze code structure
+code = """
+class DataProcessor:
+    def __init__(self, data):
+        self.data = data
+    
+    def process(self):
+        return [x * 2 for x in self.data]
+"""
+structure = analyze_code(code)
+bytecode = disassemble_code(code)
+print(f"Classes: {structure['classes']}")
+print(f"Functions: {structure['functions']}")
+```
+
 ## Understanding Python Tools
 
 <Card title="What are Python Tools?" icon="question">
@@ -81,42 +374,16 @@ Use Python Tools to execute and manage Python code with AI agents.
   - Environment control
 </Card>
 
-## Key Components
-
-<CardGroup cols={2}>
-  <Card title="Python Agent" icon="user-robot">
-    Create specialized Python agents:
-    ```python
-    Agent(tools=[python])
-    ```
-  </Card>
-  <Card title="Python Task" icon="list-check">
-    Define Python tasks:
-    ```python
-    Task(description="python_operation")
-    ```
-  </Card>
-  <Card title="Process Types" icon="arrows-split-up-and-left">
-    Sequential or parallel processing:
-    ```python
-    process="sequential"
-    ```
-  </Card>
-  <Card title="Python Options" icon="sliders">
-    Customize execution parameters:
-    ```python
-    timeout=30, capture_output=True
-    ```
-  </Card>
-</CardGroup>
-
 ## Examples
 
 ### Basic Python Execution Agent
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import python
+from praisonaiagents.tools import (
+    execute_code, analyze_code, format_code,
+    lint_code, disassemble_code
+)
 
 # Create Python agent
 python_agent = Agent(
@@ -124,7 +391,10 @@ python_agent = Agent(
     role="Code Execution Specialist",
     goal="Execute Python code efficiently and safely.",
     backstory="Expert in Python programming and execution.",
-    tools=[python],
+    tools=[
+        execute_code, analyze_code, format_code,
+        lint_code, disassemble_code
+    ],
     self_reflect=False
 )
 
@@ -153,7 +423,10 @@ executor_agent = Agent(
     name="CodeExecutor",
     role="Code Execution Specialist",
     goal="Execute Python code efficiently.",
-    tools=[python],
+    tools=[
+        execute_code, analyze_code, format_code,
+        lint_code, disassemble_code
+    ],
     self_reflect=False
 )
 
@@ -198,7 +471,10 @@ agents.start()
         name="PythonExecutor",
         role="Code Execution Specialist",
         goal="Execute code safely and efficiently",
-        tools=[python]
+        tools=[
+            execute_code, analyze_code, format_code,
+            lint_code, disassemble_code
+        ]
     )
     ```
   </Accordion>
@@ -222,7 +498,10 @@ agents.start()
 executor = Agent(
     name="Executor",
     role="Code Executor",
-    tools=[python]
+    tools=[
+        execute_code, analyze_code, format_code,
+        lint_code, disassemble_code
+    ]
 )
 
 # Monitor agent

docs/tools/shell_tools.mdx

@@ -1,6 +1,6 @@
 ---
-title: "Shell Tools"
-description: "Command-line interface tools for AI agents."
+title: "Shell Agent"
+description: "Shell command execution tools for AI agents."
 icon: "terminal"
 ---
 
@@ -11,9 +11,9 @@ icon: "terminal"
   - Basic understanding of shell commands
 </Note>
 
-## Quick Start
+## Shell Tools
 
-Use Shell Tools to execute and manage shell commands with AI agents.
+Use Shell Tools to execute shell commands with AI agents.
 
 <Steps>
   <Step title="Install Dependencies">
@@ -27,7 +27,7 @@ Use Shell Tools to execute and manage shell commands with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import shell
+    from praisonaiagents.tools import execute_command, list_processes, kill_process, get_system_info
     ```
   </Step>
 
@@ -39,7 +39,7 @@ Use Shell Tools to execute and manage shell commands with AI agents.
         role="Shell Command Specialist",
         goal="Execute shell commands efficiently and safely.",
         backstory="Expert in command-line operations and automation.",
-        tools=[shell],
+        tools=[execute_command, list_processes, kill_process, get_system_info],
         self_reflect=False
     )
     ```
@@ -87,13 +87,13 @@ Use Shell Tools to execute and manage shell commands with AI agents.
   <Card title="Shell Agent" icon="user-robot">
     Create specialized shell agents:
     ```python
-    Agent(tools=[shell])
+    Agent(tools=[execute_command, list_processes, kill_process, get_system_info])
     ```
   </Card>
   <Card title="Shell Task" icon="list-check">
     Define shell tasks:
     ```python
-    Task(description="shell_command")
+    Task(description="shell_operation")
     ```
   </Card>
   <Card title="Process Types" icon="arrows-split-up-and-left">
@@ -103,20 +103,16 @@ Use Shell Tools to execute and manage shell commands with AI agents.
     ```
   </Card>
   <Card title="Shell Options" icon="sliders">
-    Customize shell parameters:
+    Customize shell operations:
     ```python
     timeout=30, shell=True
     ```
   </Card>
 </CardGroup>
 
-## Examples
-
-### Basic Shell Command Agent
-
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import shell
+from praisonaiagents.tools import execute_command, list_processes, kill_process, get_system_info
 
 # Create shell agent
 shell_agent = Agent(
@@ -124,7 +120,7 @@ shell_agent = Agent(
     role="Shell Command Specialist",
     goal="Execute shell commands efficiently and safely.",
     backstory="Expert in command-line operations and scripting.",
-    tools=[shell],
+    tools=[execute_command, list_processes, kill_process, get_system_info],
     self_reflect=False
 )
 
@@ -153,7 +149,7 @@ command_agent = Agent(
     name="Commander",
     role="Command Executor",
     goal="Execute shell commands systematically.",
-    tools=[shell],
+    tools=[execute_command, list_processes, kill_process, get_system_info],
     self_reflect=False
 )
 
@@ -188,6 +184,249 @@ agents = PraisonAIAgents(
 agents.start()
 ```
 
+## Available Functions
+
+```python
+from praisonaiagents.tools import execute_command
+from praisonaiagents.tools import list_processes
+from praisonaiagents.tools import kill_process
+from praisonaiagents.tools import get_system_info
+```
+
+## Function Details
+
+### execute_command(command: str, cwd: Optional[str] = None, timeout: int = 30, shell: bool = False, env: Optional[Dict[str, str]] = None, max_output_size: int = 10000)
+
+Safely executes shell commands:
+- Timeout protection
+- Output capture
+- Error handling
+- Environment control
+- Working directory control
+
+```python
+# Basic command execution
+result = execute_command("ls -la")
+
+# Advanced execution
+result = execute_command(
+    "python script.py",
+    cwd="/path/to/scripts",
+    timeout=60,
+    env={"PYTHONPATH": "/custom/path"},
+    shell=True
+)
+
+# Returns: Dict[str, Union[str, int, bool]]
+# Example output:
+# {
+#     'stdout': 'command output...',
+#     'stderr': 'error output if any',
+#     'exit_code': 0,
+#     'success': True,
+#     'execution_time': 0.123
+# }
+```
+
+### list_processes()
+
+Lists running system processes:
+- Process details
+- Resource usage
+- User information
+- Performance metrics
+
+```python
+# Get list of running processes
+processes = list_processes()
+
+# Sort by CPU usage
+cpu_intensive = sorted(
+    processes,
+    key=lambda x: x['cpu_percent'],
+    reverse=True
+)[:5]
+
+# Returns: List[Dict[str, Union[int, str, float]]]
+# Example output:
+# [
+#     {
+#         'pid': 1234,
+#         'name': 'python',
+#         'username': 'user',
+#         'memory_percent': 2.5,
+#         'cpu_percent': 15.3
+#     },
+#     ...
+# ]
+```
+
+### kill_process(pid: int, force: bool = False)
+
+Terminates system processes:
+- Graceful termination
+- Force kill option
+- Error handling
+- Access control
+
+```python
+# Graceful termination
+result = kill_process(1234)
+
+# Force kill
+result = kill_process(
+    pid=1234,
+    force=True  # Use SIGKILL
+)
+
+# Returns: Dict[str, Union[bool, str]]
+# Example output:
+# {
+#     'success': True,
+#     'message': 'Process 1234 killed successfully'
+# }
+# or
+# {
+#     'success': False,
+#     'message': 'Access denied to kill process 1234'
+# }
+```
+
+### get_system_info()
+
+Retrieves system information:
+- CPU statistics
+- Memory usage
+- Disk space
+- Platform details
+- Boot time
+
+```python
+# Get system information
+info = get_system_info()
+
+# Access specific metrics
+print(f"CPU Usage: {info['cpu']['percent']}%")
+print(f"Memory Free: {info['memory']['free']} bytes")
+
+# Returns: Dict[str, Union[float, int, str, Dict]]
+# Example output:
+# {
+#     'cpu': {
+#         'percent': 45.2,
+#         'cores': 8,
+#         'physical_cores': 4
+#     },
+#     'memory': {
+#         'total': 16000000000,
+#         'available': 8000000000,
+#         'percent': 50.0,
+#         'used': 8000000000,
+#         'free': 4000000000
+#     },
+#     'disk': {
+#         'total': 500000000000,
+#         'used': 250000000000,
+#         'free': 250000000000,
+#         'percent': 50.0
+#     },
+#     'boot_time': 1641544800,
+#     'platform': 'Darwin'
+# }
+```
+
+## Example Agent Configuration
+
+```python
+from praisonaiagents import Agent
+from praisonaiagents.tools import (
+    execute_command, list_processes,
+    kill_process, get_system_info
+)
+
+agent = Agent(
+    name="SystemManager",
+    description="An agent that manages system processes and executes commands",
+    tools=[
+        execute_command, list_processes,
+        kill_process, get_system_info
+    ]
+)
+```
+
+## Dependencies
+
+The shell tools require the following package:
+- psutil: For system and process information
+
+This will be automatically installed when needed.
+
+## Error Handling
+
+All functions include comprehensive error handling:
+- Command execution errors
+- Process access errors
+- Permission errors
+- Timeout errors
+- Resource errors
+
+Errors are handled consistently:
+- Success cases return expected data type
+- Error cases return error details in result
+- All errors are logged for debugging
+
+## Common Use Cases
+
+1. System Monitoring:
+```python
+# Monitor system resources
+info = get_system_info()
+if info['cpu']['percent'] > 90:
+    print("High CPU usage detected!")
+if info['memory']['percent'] > 80:
+    print("Low memory warning!")
+
+# List resource-intensive processes
+processes = sorted(
+    list_processes(),
+    key=lambda x: x['memory_percent'],
+    reverse=True
+)[:5]
+print("Top memory users:", processes)
+```
+
+2. Process Management:
+```python
+# Find and kill zombie processes
+for process in list_processes():
+    if process['name'] == 'zombie_process':
+        result = kill_process(
+            process['pid'],
+            force=True
+        )
+        print(f"Kill result: {result['message']}")
+```
+
+3. Command Execution:
+```python
+# Run a series of maintenance commands
+commands = [
+    "apt-get update",
+    "apt-get upgrade -y",
+    "apt-get autoremove -y"
+]
+for cmd in commands:
+    result = execute_command(
+        cmd,
+        timeout=300,
+        shell=True
+    )
+    if result['success']:
+        print(f"Command succeeded: {cmd}")
+    else:
+        print(f"Command failed: {result['stderr']}")
+```
+
 ## Best Practices
 
 <AccordionGroup>
@@ -198,7 +437,7 @@ agents.start()
         name="ShellManager",
         role="Command Line Specialist",
         goal="Execute shell commands safely and efficiently",
-        tools=[shell]
+        tools=[execute_command, list_processes, kill_process, get_system_info]
     )
     ```
   </Accordion>
@@ -222,7 +461,7 @@ agents.start()
 commander = Agent(
     name="Commander",
     role="Shell Commander",
-    tools=[shell]
+    tools=[execute_command]
 )
 
 # Monitor agent

docs/tools/spider_tools.mdx

@@ -1,6 +1,6 @@
 ---
-title: "Spider Tools"
-description: "Web scraping and crawling tools for AI agents."
+title: "Spider Agent"
+description: "Web scraping tools for AI agents."
 icon: "spider"
 ---
 
@@ -8,19 +8,18 @@ icon: "spider"
   **Prerequisites**
   - Python 3.10 or higher
   - PraisonAI Agents package installed
-  - `beautifulsoup4` package installed
-  - `requests` package installed
+  - `scrapy` package installed
 </Note>
 
-## Quick Start
+## Spider Tools
 
-Use Spider Tools to scrape and crawl web content with AI agents.
+Use Spider Tools to crawl and scrape web content with AI agents.
 
 <Steps>
   <Step title="Install Dependencies">
     First, install the required packages:
     ```bash
-    pip install praisonaiagents beautifulsoup4 requests
+    pip install praisonaiagents scrapy
     ```
   </Step>
 
@@ -28,7 +27,7 @@ Use Spider Tools to scrape and crawl web content with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import spider
+    from praisonaiagents.tools import scrape_page, extract_links, crawl, extract_text
     ```
   </Step>
 
@@ -40,7 +39,7 @@ Use Spider Tools to scrape and crawl web content with AI agents.
         role="Web Scraping Specialist",
         goal="Extract and analyze web content efficiently.",
         backstory="Expert in web scraping and content extraction.",
-        tools=[spider],
+        tools=[scrape_page, extract_links, crawl, extract_text],
         self_reflect=False
     )
     ```
@@ -75,11 +74,11 @@ Use Spider Tools to scrape and crawl web content with AI agents.
 
 <Card title="What are Spider Tools?" icon="question">
   Spider Tools provide web scraping capabilities for AI agents:
-  - Web page scraping
-  - Content extraction
-  - Link crawling
-  - HTML parsing
-  - Data structuring
+  - Page scraping and downloading
+  - Content extraction and filtering
+  - Link discovery and crawling
+  - HTML parsing and cleaning
+  - Data structuring and formatting
 </Card>
 
 ## Key Components
@@ -88,7 +87,7 @@ Use Spider Tools to scrape and crawl web content with AI agents.
   <Card title="Spider Agent" icon="user-robot">
     Create specialized scraping agents:
     ```python
-    Agent(tools=[spider])
+    Agent(tools=[scrape_page, extract_content, crawl_links, parse_html, structure_data])
     ```
   </Card>
   <Card title="Spider Task" icon="list-check">
@@ -117,30 +116,30 @@ Use Spider Tools to scrape and crawl web content with AI agents.
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import spider
+from praisonaiagents.tools import scrape_page, extract_links, crawl, extract_text
 
-# Create scraping agent
-spider_agent = Agent(
+# Create search agent
+agent = Agent(
     name="WebCrawler",
     role="Web Scraping Specialist",
-    goal="Extract web content efficiently and ethically.",
-    backstory="Expert in web crawling and data extraction.",
-    tools=[spider],
+    goal="Extract and analyze web content efficiently.",
+    backstory="Expert in web scraping and content extraction.",
+    tools=[scrape_page, extract_links, crawl, extract_text],
     self_reflect=False
 )
 
-# Define scraping task
-scraping_task = Task(
-    description="Extract article content from news websites.",
-    expected_output="Structured article data with text and metadata.",
-    agent=spider_agent,
-    name="news_scraping"
+# Define task
+task = Task(
+    description="Scrape and analyze the content from 'https://example.com'",
+    expected_output="Extracted content with links and text analysis",
+    agent=agent,
+    name="web_scraping"
 )
 
 # Run agent
 agents = PraisonAIAgents(
-    agents=[spider_agent],
-    tasks=[scraping_task],
+    agents=[agent],
+    tasks=[task],
     process="sequential"
 )
 agents.start()
@@ -154,7 +153,7 @@ scraper_agent = Agent(
     name="Scraper",
     role="Content Scraper",
     goal="Extract web content systematically.",
-    tools=[spider],
+    tools=[scrape_page, crawl_links, parse_html],
     self_reflect=False
 )
 
@@ -164,6 +163,7 @@ analysis_agent = Agent(
     role="Content Analyst",
     goal="Analyze and structure scraped content.",
     backstory="Expert in data analysis and organization.",
+    tools=[extract_content, structure_data],
     self_reflect=False
 )
 
@@ -199,7 +199,7 @@ agents.start()
         name="WebScraper",
         role="Content Extraction Specialist",
         goal="Extract web content ethically and efficiently",
-        tools=[spider]
+        tools=[scrape_page, extract_content, crawl_links, parse_html, structure_data]
     )
     ```
   </Accordion>
@@ -223,13 +223,14 @@ agents.start()
 scraper = Agent(
     name="Scraper",
     role="Web Scraper",
-    tools=[spider]
+    tools=[scrape_page, crawl_links, parse_html]
 )
 
 # Processing agent
 processor = Agent(
     name="Processor",
-    role="Data Processor"
+    role="Data Processor",
+    tools=[extract_content, structure_data]
 )
 
 # Define tasks
@@ -247,4 +248,4 @@ process_task = Task(
 agents = PraisonAIAgents(
     agents=[scraper, processor],
     tasks=[scrape_task, process_task]
-)
+)

docs/tools/wikipedia_tools.mdx

@@ -1,5 +1,5 @@
 ---
-title: "Wikipedia Tools"
+title: "Wikipedia Agent"
 description: "Wikipedia data retrieval tools for AI agents."
 icon: "book"
 ---
@@ -12,7 +12,7 @@ icon: "book"
   - Basic understanding of Wikipedia APIs
 </Note>
 
-## Quick Start
+## Wikipedia Tools
 
 Use Wikipedia Tools to retrieve and analyze Wikipedia content with AI agents.
 
@@ -28,7 +28,7 @@ Use Wikipedia Tools to retrieve and analyze Wikipedia content with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import wikipedia
+    from praisonaiagents.tools import wiki_search, wiki_summary, wiki_page, wiki_random, wiki_language
     ```
   </Step>
 
@@ -40,7 +40,7 @@ Use Wikipedia Tools to retrieve and analyze Wikipedia content with AI agents.
         role="Wikipedia Research Specialist",
         goal="Research and analyze Wikipedia content efficiently.",
         backstory="Expert in information retrieval and content analysis.",
-        tools=[wikipedia],
+        tools=[wiki_search, wiki_summary, wiki_page, wiki_random, wiki_language],
         self_reflect=False
     )
     ```
@@ -75,11 +75,11 @@ Use Wikipedia Tools to retrieve and analyze Wikipedia content with AI agents.
 
 <Card title="What are Wikipedia Tools?" icon="question">
   Wikipedia Tools provide research capabilities for AI agents:
-  - Article retrieval
-  - Content search
-  - Information extraction
-  - Summary generation
-  - Reference collection
+  - Article search and retrieval
+  - Content summary generation
+  - Full page information access
+  - Random article discovery
+  - Multi-language support
 </Card>
 
 ## Key Components
@@ -88,7 +88,7 @@ Use Wikipedia Tools to retrieve and analyze Wikipedia content with AI agents.
   <Card title="Wiki Agent" icon="user-robot">
     Create specialized research agents:
     ```python
-    Agent(tools=[wikipedia])
+    Agent(tools=[wiki_search, wiki_summary, wiki_page, wiki_random, wiki_language])
     ```
   </Card>
   <Card title="Wiki Task" icon="list-check">
@@ -117,7 +117,7 @@ Use Wikipedia Tools to retrieve and analyze Wikipedia content with AI agents.
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import wikipedia
+from praisonaiagents.tools import wiki_search, wiki_summary, wiki_page, wiki_random, wiki_language
 
 # Create Wikipedia agent
 wiki_agent = Agent(
@@ -125,7 +125,7 @@ wiki_agent = Agent(
     role="Research Specialist",
     goal="Research topics efficiently and accurately.",
     backstory="Expert in information gathering and analysis.",
-    tools=[wikipedia],
+    tools=[wiki_search, wiki_summary, wiki_page, wiki_random, wiki_language],
     self_reflect=False
 )
 
@@ -144,6 +144,7 @@ agents = PraisonAIAgents(
     process="sequential"
 )
 agents.start()
+
 ```
 
 ### Advanced Research with Multiple Agents
@@ -154,7 +155,7 @@ researcher_agent = Agent(
     name="Researcher",
     role="Content Researcher",
     goal="Research topics systematically.",
-    tools=[wikipedia],
+    tools=[wiki_search, wiki_summary, wiki_page],
     self_reflect=False
 )
 
@@ -164,6 +165,7 @@ analysis_agent = Agent(
     role="Content Analyst",
     goal="Analyze and summarize research findings.",
     backstory="Expert in content analysis and synthesis.",
+    tools=[wiki_summary, wiki_page],
     self_reflect=False
 )
 
@@ -199,7 +201,7 @@ agents.start()
         name="WikiResearcher",
         role="Research Specialist",
         goal="Research topics accurately and efficiently",
-        tools=[wikipedia]
+        tools=[wiki_search, wiki_summary, wiki_page, wiki_random, wiki_language]
     )
     ```
   </Accordion>
@@ -223,13 +225,14 @@ agents.start()
 researcher = Agent(
     name="Researcher",
     role="Wiki Researcher",
-    tools=[wikipedia]
+    tools=[wiki_search, wiki_summary, wiki_page]
 )
 
 # Analysis agent
 analyzer = Agent(
     name="Analyzer",
-    role="Content Analyzer"
+    role="Content Analyzer",
+    tools=[wiki_summary, wiki_page]
 )
 
 # Define tasks
@@ -247,4 +250,4 @@ analyze_task = Task(
 agents = PraisonAIAgents(
     agents=[researcher, analyzer],
     tasks=[research_task, analyze_task]
-)
+)

docs/tools/xml_tools.mdx

@@ -1,6 +1,6 @@
 ---
-title: "XML Tools"
-description: "XML file processing tools for AI agents."
+title: "XML Agent"
+description: "XML data processing tools for AI agents."
 icon: "code"
 ---
 
@@ -8,12 +8,12 @@ icon: "code"
   **Prerequisites**
   - Python 3.10 or higher
   - PraisonAI Agents package installed
-  - Basic understanding of XML format
+  - `lxml` package installed
 </Note>
 
-## Quick Start
+## XML Tools
 
-Use XML Tools to process and manipulate XML files with AI agents.
+Use XML Tools to read, write, and manipulate XML data with AI agents.
 
 <Steps>
   <Step title="Install Dependencies">
@@ -27,7 +27,7 @@ Use XML Tools to process and manipulate XML files with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import xml
+    from praisonaiagents.tools import read_xml, write_xml, transform_xml, validate_xml, xml_to_dict, dict_to_xml
     ```
   </Step>
 
@@ -39,7 +39,7 @@ Use XML Tools to process and manipulate XML files with AI agents.
         role="XML Processing Specialist",
         goal="Process XML files efficiently and accurately.",
         backstory="Expert in XML file manipulation and validation.",
-        tools=[xml],
+        tools=[read_xml, write_xml, transform_xml, validate_xml, xml_to_dict, dict_to_xml],
         self_reflect=False
     )
     ```
@@ -74,11 +74,11 @@ Use XML Tools to process and manipulate XML files with AI agents.
 
 <Card title="What are XML Tools?" icon="question">
   XML Tools provide XML processing capabilities for AI agents:
-  - XML parsing
-  - File validation
-  - Data extraction
+  - XML parsing and reading
+  - File writing and validation
+  - Data transformation
+  - Dictionary conversion
   - Structure manipulation
-  - Format conversion
 </Card>
 
 ## Key Components
@@ -87,7 +87,7 @@ Use XML Tools to process and manipulate XML files with AI agents.
   <Card title="XML Agent" icon="user-robot">
     Create specialized XML agents:
     ```python
-    Agent(tools=[xml])
+    Agent(tools=[read_xml, write_xml, transform_xml, validate_xml, xml_to_dict, dict_to_xml])
     ```
   </Card>
   <Card title="XML Task" icon="list-check">
@@ -116,7 +116,7 @@ Use XML Tools to process and manipulate XML files with AI agents.
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import xml
+from praisonaiagents.tools import read_xml, write_xml, transform_xml, validate_xml, xml_to_dict, dict_to_xml
 
 # Create XML agent
 xml_agent = Agent(
@@ -124,7 +124,7 @@ xml_agent = Agent(
     role="XML Processing Specialist",
     goal="Process XML files efficiently and accurately.",
     backstory="Expert in XML file handling and validation.",
-    tools=[xml],
+    tools=[read_xml, write_xml, transform_xml, validate_xml, xml_to_dict, dict_to_xml],
     self_reflect=False
 )
 
@@ -153,7 +153,7 @@ processor_agent = Agent(
     name="Processor",
     role="XML Processor",
     goal="Process XML files systematically.",
-    tools=[xml],
+    tools=[read_xml, write_xml, transform_xml],
     self_reflect=False
 )
 
@@ -163,6 +163,7 @@ validator_agent = Agent(
     role="Data Validator",
     goal="Validate XML structure and content.",
     backstory="Expert in data validation and verification.",
+    tools=[validate_xml, xml_to_dict, dict_to_xml],
     self_reflect=False
 )
 
@@ -198,7 +199,7 @@ agents.start()
         name="XMLProcessor",
         role="XML Processing Specialist",
         goal="Process XML files accurately and safely",
-        tools=[xml]
+        tools=[read_xml, write_xml, transform_xml, validate_xml, xml_to_dict, dict_to_xml]
     )
     ```
   </Accordion>
@@ -222,13 +223,14 @@ agents.start()
 processor = Agent(
     name="Processor",
     role="XML Processor",
-    tools=[xml]
+    tools=[read_xml, write_xml, transform_xml]
 )
 
 # Validation agent
 validator = Agent(
     name="Validator",
-    role="Data Validator"
+    role="Data Validator",
+    tools=[validate_xml, xml_to_dict, dict_to_xml]
 )
 
 # Define tasks
@@ -246,4 +248,4 @@ validate_task = Task(
 agents = PraisonAIAgents(
     agents=[processor, validator],
     tasks=[process_task, validate_task]
-)
+)

docs/tools/yaml_tools.mdx

@@ -1,7 +1,7 @@
 ---
-title: "YAML Tools"
-description: "YAML file processing tools for AI agents."
-icon: "file-code"
+title: "YAML Agent"
+description: "YAML data processing tools for AI agents."
+icon: "code"
 ---
 
 <Note>
@@ -12,7 +12,7 @@ icon: "file-code"
   - Basic understanding of YAML format
 </Note>
 
-## Quick Start
+## YAML Tools
 
 Use YAML Tools to process and manipulate YAML files with AI agents.
 
@@ -28,7 +28,7 @@ Use YAML Tools to process and manipulate YAML files with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import yaml
+    from praisonaiagents.tools import read_yaml, write_yaml, validate_yaml, merge_yaml, convert_yaml
     ```
   </Step>
 
@@ -40,7 +40,7 @@ Use YAML Tools to process and manipulate YAML files with AI agents.
         role="YAML Processing Specialist",
         goal="Process YAML files efficiently and accurately.",
         backstory="Expert in YAML file manipulation and validation.",
-        tools=[yaml],
+        tools=[read_yaml, write_yaml, validate_yaml, merge_yaml, convert_yaml],
         self_reflect=False
     )
     ```
@@ -75,11 +75,11 @@ Use YAML Tools to process and manipulate YAML files with AI agents.
 
 <Card title="What are YAML Tools?" icon="question">
   YAML Tools provide YAML processing capabilities for AI agents:
-  - YAML parsing
-  - File validation
-  - Data extraction
-  - Structure manipulation
-  - Format conversion
+  - Reading YAML files
+  - Writing YAML data
+  - Validating YAML structure
+  - Merging YAML files
+  - Converting between formats
 </Card>
 
 ## Key Components
@@ -88,7 +88,7 @@ Use YAML Tools to process and manipulate YAML files with AI agents.
   <Card title="YAML Agent" icon="user-robot">
     Create specialized YAML agents:
     ```python
-    Agent(tools=[yaml])
+    Agent(tools=[read_yaml, write_yaml, validate_yaml, merge_yaml, convert_yaml])
     ```
   </Card>
   <Card title="YAML Task" icon="list-check">
@@ -117,7 +117,7 @@ Use YAML Tools to process and manipulate YAML files with AI agents.
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import yaml
+from praisonaiagents.tools import read_yaml, write_yaml, validate_yaml, merge_yaml, convert_yaml
 
 # Create YAML agent
 yaml_agent = Agent(
@@ -125,7 +125,7 @@ yaml_agent = Agent(
     role="YAML Processing Specialist",
     goal="Process YAML files efficiently and accurately.",
     backstory="Expert in YAML file handling and validation.",
-    tools=[yaml],
+    tools=[read_yaml, write_yaml, validate_yaml, merge_yaml, convert_yaml],
     self_reflect=False
 )
 
@@ -154,7 +154,7 @@ processor_agent = Agent(
     name="Processor",
     role="YAML Processor",
     goal="Process YAML files systematically.",
-    tools=[yaml],
+    tools=[read_yaml, write_yaml, convert_yaml],
     self_reflect=False
 )
 
@@ -164,6 +164,7 @@ validator_agent = Agent(
     role="Data Validator",
     goal="Validate YAML structure and content.",
     backstory="Expert in data validation and verification.",
+    tools=[validate_yaml, merge_yaml],
     self_reflect=False
 )
 
@@ -199,7 +200,7 @@ agents.start()
         name="YAMLProcessor",
         role="YAML Processing Specialist",
         goal="Process YAML files accurately and safely",
-        tools=[yaml]
+        tools=[read_yaml, write_yaml, validate_yaml, merge_yaml, convert_yaml]
     )
     ```
   </Accordion>
@@ -223,13 +224,14 @@ agents.start()
 processor = Agent(
     name="Processor",
     role="YAML Processor",
-    tools=[yaml]
+    tools=[read_yaml, write_yaml, convert_yaml]
 )
 
 # Validation agent
 validator = Agent(
     name="Validator",
-    role="Data Validator"
+    role="Data Validator",
+    tools=[validate_yaml, merge_yaml]
 )
 
 # Define tasks
@@ -247,4 +249,4 @@ validate_task = Task(
 agents = PraisonAIAgents(
     agents=[processor, validator],
     tasks=[process_task, validate_task]
-)
+)

docs/tools/yfinance_tools.mdx

@@ -1,5 +1,5 @@
 ---
-title: "YFinance Tools"
+title: "YFinance Agent"
 description: "Yahoo Finance data retrieval tools for AI agents."
 icon: "chart-line"
 ---
@@ -12,7 +12,7 @@ icon: "chart-line"
   - Basic understanding of financial data
 </Note>
 
-## Quick Start
+## YFinance Tools
 
 Use YFinance Tools to retrieve and analyze financial data with AI agents.
 
@@ -28,7 +28,7 @@ Use YFinance Tools to retrieve and analyze financial data with AI agents.
     Import the necessary components:
     ```python
     from praisonaiagents import Agent, Task, PraisonAIAgents
-    from praisonaiagents.tools import yfinance
+    from praisonaiagents.tools import get_stock_price, get_stock_info, get_historical_data
     ```
   </Step>
 
@@ -40,7 +40,7 @@ Use YFinance Tools to retrieve and analyze financial data with AI agents.
         role="Financial Data Specialist",
         goal="Retrieve and analyze financial data efficiently.",
         backstory="Expert in financial data analysis and market research.",
-        tools=[yfinance],
+        tools=[get_stock_price, get_stock_info, get_historical_data],
         self_reflect=False
     )
     ```
@@ -75,11 +75,11 @@ Use YFinance Tools to retrieve and analyze financial data with AI agents.
 
 <Card title="What are YFinance Tools?" icon="question">
   YFinance Tools provide financial data capabilities for AI agents:
-  - Stock data retrieval
-  - Market analysis
-  - Historical data
-  - Company information
-  - Financial metrics
+  - Real-time stock prices
+  - Detailed company information
+  - Historical market data
+  - Financial metrics and ratios
+  - Market performance analysis
 </Card>
 
 ## Key Components
@@ -88,7 +88,7 @@ Use YFinance Tools to retrieve and analyze financial data with AI agents.
   <Card title="Finance Agent" icon="user-robot">
     Create specialized finance agents:
     ```python
-    Agent(tools=[yfinance])
+    Agent(tools=[get_stock_price, get_stock_info, get_historical_data])
     ```
   </Card>
   <Card title="Finance Task" icon="list-check">
@@ -117,7 +117,7 @@ Use YFinance Tools to retrieve and analyze financial data with AI agents.
 
 ```python
 from praisonaiagents import Agent, Task, PraisonAIAgents
-from praisonaiagents.tools import yfinance
+from praisonaiagents.tools import get_stock_price, get_stock_info, get_historical_data
 
 # Create finance agent
 finance_agent = Agent(
@@ -125,7 +125,7 @@ finance_agent = Agent(
     role="Financial Data Specialist",
     goal="Analyze market data efficiently and accurately.",
     backstory="Expert in financial analysis and market research.",
-    tools=[yfinance],
+    tools=[get_stock_price, get_stock_info, get_historical_data],
     self_reflect=False
 )
 
@@ -154,7 +154,7 @@ data_agent = Agent(
     name="DataCollector",
     role="Market Data Collector",
     goal="Retrieve financial data systematically.",
-    tools=[yfinance],
+    tools=[get_stock_price, get_historical_data],
     self_reflect=False
 )
 
@@ -164,6 +164,7 @@ analysis_agent = Agent(
     role="Market Analyst",
     goal="Analyze market trends and patterns.",
     backstory="Expert in financial market analysis.",
+    tools=[get_stock_info],
     self_reflect=False
 )
 
@@ -199,7 +200,7 @@ agents.start()
         name="FinanceAnalyst",
         role="Market Analysis Specialist",
         goal="Analyze financial data accurately and efficiently",
-        tools=[yfinance]
+        tools=[get_stock_price, get_stock_info, get_historical_data]
     )
     ```
   </Accordion>
@@ -223,13 +224,14 @@ agents.start()
 collector = Agent(
     name="Collector",
     role="Data Collector",
-    tools=[yfinance]
+    tools=[get_stock_price, get_historical_data]
 )
 
 # Analysis agent
 analyst = Agent(
     name="Analyst",
-    role="Market Analyst"
+    role="Market Analyst",
+    tools=[get_stock_info]
 )
 
 # Define tasks
@@ -247,4 +249,4 @@ analyze_task = Task(
 agents = PraisonAIAgents(
     agents=[collector, analyst],
     tasks=[collect_task, analyze_task]
-)
+)

praisonai.rb

@@ -3,7 +3,7 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/2.0.33.tar.gz"
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/2.0.41.tar.gz"
     sha256 "1828fb9227d10f991522c3f24f061943a254b667196b40b1a3e4a54a8d30ce32"  # Replace with actual SHA256 checksum
     license "MIT"
   

praisonai/agents_generator.py

@@ -212,9 +212,9 @@ class AgentsGenerator:
         try:
             # Try to import tools.py from current directory
             spec = importlib.util.spec_from_file_location("tools", "tools.py")
-            self.logger.info(f"Spec: {spec}")
+            self.logger.debug(f"Spec: {spec}")
             if spec is None:
-                self.logger.info("tools.py not found in current directory")
+                self.logger.debug("tools.py not found in current directory")
                 return tools_list
 
             module = importlib.util.module_from_spec(spec)
@@ -229,11 +229,13 @@ class AgentsGenerator:
                     globals()[name] = obj
                     # Add to tools list
                     tools_list.append(obj)
-                    self.logger.info(f"Loaded and globalized tool function: {name}")
+                    self.logger.debug(f"Loaded and globalized tool function: {name}")
 
-            self.logger.info(f"Loaded {len(tools_list)} tool functions from tools.py")
-            self.logger.info(f"Tools list: {tools_list}")
+            self.logger.debug(f"Loaded {len(tools_list)} tool functions from tools.py")
+            self.logger.debug(f"Tools list: {tools_list}")
             
+        except FileNotFoundError:
+            self.logger.debug("tools.py not found in current directory")
         except Exception as e:
             self.logger.warning(f"Error loading tools from tools.py: {e}")
             
@@ -539,7 +541,7 @@ class AgentsGenerator:
 
         # Load tools once at the beginning
         tools_list = self.load_tools_from_tools_py()
-        self.logger.info(f"Loaded tools: {tools_list}")
+        self.logger.debug(f"Loaded tools: {tools_list}")
 
         # Create agents from config
         for role, details in config['roles'].items():
@@ -574,7 +576,7 @@ class AgentsGenerator:
                 agent.step_callback = self.agent_callback
 
             agents[role] = agent
-            self.logger.info(f"Created agent {role_filled} with tools: {agent.tools}")
+            self.logger.debug(f"Created agent {role_filled} with tools: {agent.tools}")
 
             # Create tasks for the agent
             for task_name, task_details in details.get('tasks', {}).items():
@@ -596,7 +598,7 @@ class AgentsGenerator:
                     create_directory=task_details.get('create_directory', False)
                 )
 
-                self.logger.info(f"Created task {task_name} with tools: {task.tools}")
+                self.logger.debug(f"Created task {task_name} with tools: {task.tools}")
                 
                 if self.task_callback:
                     task.callback = self.task_callback
@@ -613,6 +615,8 @@ class AgentsGenerator:
                 task.context = context_tasks
 
         # Create and run the PraisonAI agents
+        memory = config.get('memory', False)
+        self.logger.debug(f"Memory: {memory}")
         if config.get('process') == 'hierarchical':
             agents = PraisonAIAgents(
                 agents=list(agents.values()),
@@ -620,12 +624,14 @@ class AgentsGenerator:
                 verbose=True,
                 process="hierarchical",
                 manager_llm=config.get('manager_llm', 'gpt-4o'),
+                memory=memory
             )
         else:
             agents = PraisonAIAgents(
                 agents=list(agents.values()),
                 tasks=tasks,
-                verbose=2
+                verbose=2,
+                memory=memory
             )
 
         self.logger.debug("Final Configuration:")

praisonai/api/call.py

@@ -50,7 +50,7 @@ logger.handlers = []
 # Try to import tools from the root directory
 tools = []
 tools_path = os.path.join(os.getcwd(), 'tools.py')
-logger.info(f"Tools path: {tools_path}")
+logger.debug(f"Tools path: {tools_path}")
 
 def import_tools_from_file(file_path):
     spec = importlib.util.spec_from_file_location("custom_tools", file_path)
@@ -63,9 +63,9 @@ try:
     if os.path.exists(tools_path):
         # tools.py exists in the root directory, import from file
         custom_tools_module = import_tools_from_file(tools_path)
-        logger.info("Successfully imported custom tools from root tools.py")
+        logger.debug("Successfully imported custom tools from root tools.py")
     else:
-        logger.info("No custom tools.py file found in the root directory")
+        logger.debug("No custom tools.py file found in the root directory")
         custom_tools_module = None
 
     if custom_tools_module:

praisonai/cli.py

@@ -73,6 +73,12 @@ except ImportError:
     pass
 
 logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO'), format='%(asctime)s - %(levelname)s - %(message)s')
+logging.getLogger('alembic').setLevel(logging.ERROR)
+logging.getLogger('gradio').setLevel(logging.ERROR)
+logging.getLogger('gradio').setLevel(os.environ.get('GRADIO_LOGLEVEL', 'WARNING'))
+logging.getLogger('rust_logger').setLevel(logging.WARNING)
+logging.getLogger('duckduckgo').setLevel(logging.ERROR)
+logging.getLogger('_client').setLevel(logging.ERROR)
 
 def stream_subprocess(command, env=None):
     """

praisonai/deploy.py

@@ -56,7 +56,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.0.33 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.0.41 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

praisonai/ui/realtime.py

@@ -186,11 +186,42 @@ try:
     if custom_tools_module:
         # Update the tools list with custom tools
         if hasattr(custom_tools_module, 'tools') and isinstance(custom_tools_module.tools, list):
-            tools.extend(custom_tools_module.tools)
+            # Only add tools that have proper function definitions
+            for tool in custom_tools_module.tools:
+                if isinstance(tool, tuple) and len(tool) == 2:
+                    tool_def, handler = tool
+                    if isinstance(tool_def, dict) and "type" in tool_def and tool_def["type"] == "function":
+                        # Convert class/function to proper tool definition
+                        if "function" in tool_def:
+                            func = tool_def["function"]
+                            if hasattr(func, "__name__"):
+                                tool_def = {
+                                    "name": func.__name__,
+                                    "description": func.__doc__ or f"Execute {func.__name__}",
+                                    "parameters": {
+                                        "type": "object",
+                                        "properties": {},
+                                        "required": []
+                                    }
+                                }
+                                tools.append((tool_def, handler))
+                    else:
+                        # Tool definition is already properly formatted
+                        tools.append(tool)
         else:
+            # Process individual functions/classes
             for name, obj in custom_tools_module.__dict__.items():
                 if callable(obj) and not name.startswith("__"):
-                    tools.append(({"type": "function", "function": obj}, obj))
+                    tool_def = {
+                        "name": name,
+                        "description": obj.__doc__ or f"Execute {name}",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {},
+                            "required": []
+                        }
+                    }
+                    tools.append((tool_def, obj))
 
 except Exception as e:
     logger.warning(f"Error importing custom tools: {str(e)}. Continuing without custom tools.")
@@ -287,14 +318,30 @@ async def setup_openai_realtime():
         logger.error(event)
         await cl.Message(content=f"Error: {event}", author="System").send()
 
+    # Register event handlers
     openai_realtime.on('conversation.updated', handle_conversation_updated)
     openai_realtime.on('conversation.item.completed', handle_item_completed)
     openai_realtime.on('conversation.interrupted', handle_conversation_interrupt)
     openai_realtime.on('error', handle_error)
 
     cl.user_session.set("openai_realtime", openai_realtime)
-    coros = [openai_realtime.add_tool(tool_def, tool_handler) for tool_def, tool_handler in tools]
-    await asyncio.gather(*coros)
+    
+    # Filter out invalid tools and add valid ones
+    valid_tools = []
+    for tool_def, tool_handler in tools:
+        try:
+            if isinstance(tool_def, dict) and "name" in tool_def:
+                valid_tools.append((tool_def, tool_handler))
+            else:
+                logger.warning(f"Skipping invalid tool definition: {tool_def}")
+        except Exception as e:
+            logger.warning(f"Error processing tool: {e}")
+    
+    if valid_tools:
+        coros = [openai_realtime.add_tool(tool_def, tool_handler) for tool_def, tool_handler in valid_tools]
+        await asyncio.gather(*coros)
+    else:
+        logger.warning("No valid tools found to add")
 
 @cl.on_settings_update
 async def setup_agent(settings):
@@ -330,11 +377,19 @@ async def setup_agent(settings):
 async def on_audio_start():
     try:
         openai_realtime: RealtimeClient = cl.user_session.get("openai_realtime")
-        await openai_realtime.connect()
+        if not openai_realtime:
+            await setup_openai_realtime()
+            openai_realtime = cl.user_session.get("openai_realtime")
+        
+        if not openai_realtime.is_connected():
+            await openai_realtime.connect()
+            
         logger.info("Connected to OpenAI realtime")
         return True
     except Exception as e:
-        await cl.ErrorMessage(content=f"Failed to connect to OpenAI realtime: {e}").send()
+        error_msg = f"Failed to connect to OpenAI realtime: {str(e)}"
+        logger.error(error_msg)
+        await cl.ErrorMessage(content=error_msg).send()
         return False
 
 @cl.on_audio_chunk

praisonai/ui/sql_alchemy.py

@@ -9,7 +9,8 @@ import os
 import aiofiles
 import aiohttp
 
-from chainlit.data.base import BaseDataLayer, BaseStorageClient
+from chainlit.data.base import BaseDataLayer
+from chainlit.data.storage_clients.base import EXPIRY_TIME, BaseStorageClient
 from chainlit.data.utils import queue_until_user_message
 from chainlit.element import ElementDict
 from chainlit.logger import logger

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.0.33"
+version = "2.0.41"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human–agent collaboration."
 readme = "README.md"
 license = ""
@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.24",
+    "praisonaiagents>=0.0.31",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",
@@ -20,7 +20,7 @@ dependencies = [
 
 [project.optional-dependencies]
 ui = [
-    "chainlit==1.3.2",
+    "chainlit==2.0.1",
     "sqlalchemy>=2.0.36",
     "aiosqlite>=0.20.0",
     "greenlet>=3.0.3",
@@ -34,7 +34,7 @@ openai = ["langchain-openai>=0.1.7"]
 anthropic = ["langchain-anthropic>=0.1.13"]
 cohere = ["langchain-cohere>=0.1.4"]
 chat = [
-    "chainlit==1.3.2",
+    "chainlit==2.0.1",
     "litellm>=1.41.8",
     "aiosqlite>=0.20.0",
     "greenlet>=3.0.3",
@@ -46,7 +46,7 @@ chat = [
     "pydantic<=2.10.1"
 ]
 code = [
-    "chainlit==1.3.2",
+    "chainlit==2.0.1",
     "litellm>=1.41.8",
     "aiosqlite>=0.20.0",
     "greenlet>=3.0.3",
@@ -57,7 +57,7 @@ code = [
     "pydantic<=2.10.1"
 ]
 realtime = [
-    "chainlit==1.3.2",
+    "chainlit==2.0.1",
     "litellm>=1.41.8",
     "aiosqlite>=0.20.0",
     "greenlet>=3.0.3",
@@ -84,7 +84,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.7", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.0.33"
+version = "2.0.41"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human–agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
@@ -102,7 +102,7 @@ python = ">=3.10,<3.13"
 rich = ">=13.7"
 markdown = ">=3.5"
 pyparsing = ">=3.0.0"
-praisonaiagents = ">=0.0.24"
+praisonaiagents = ">=0.0.31"
 python-dotenv = ">=0.19.0"
 instructor = ">=1.3.3"
 PyYAML = ">=6.0"

uv.lock

@@ -482,7 +482,7 @@ wheels = [
 
 [[package]]
 name = "chainlit"
-version = "1.3.2"
+version = "2.0.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiofiles" },
@@ -495,7 +495,6 @@ dependencies = [
     { name = "lazify" },
     { name = "literalai" },
     { name = "nest-asyncio" },
-    { name = "numpy" },
     { name = "packaging" },
     { name = "pydantic" },
     { name = "pyjwt" },
@@ -509,9 +508,9 @@ dependencies = [
     { name = "uvicorn" },
     { name = "watchfiles" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6a/57/8c3c354b3e82fae0791b58304634b356aeea8791dd0b6f817a8d8787cad6/chainlit-1.3.2.tar.gz", hash = "sha256:5562246ca42c858a42e86efdd5a46c27fd93481706f6fe47416109c47ac41b77", size = 4271845 }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/15/26dc5f957c6344813b2ae8c6f52cc820a7074088509ea947da0cf76ffc5f/chainlit-2.0.1.tar.gz", hash = "sha256:9fb7728aa5704e823c5b5d51f570dcfabafdcc97c23a73e6047f65eb72c938e7", size = 4637433 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ca/d8/2a0c00b2236c93f31df429642de6414c56510d39392101b1b102074520d0/chainlit-1.3.2-py3-none-any.whl", hash = "sha256:c0926e8b157a67aede511a8220307889d04e9458ff3f94176e004fe533662d74", size = 4332216 },
+    { url = "https://files.pythonhosted.org/packages/ca/99/c63fa2e1d7b949c034b7fc838a0c00de22cd2cec30245e379c9dd15dedfd/chainlit-2.0.1-py3-none-any.whl", hash = "sha256:84982902c6f42a91ac341ea9b6d52e6b1348e53a60ee49b4ffe0e5e5be02f4ba", size = 4703745 },
 ]
 
 [[package]]
@@ -3061,7 +3060,7 @@ wheels = [
 
 [[package]]
 name = "praisonai"
-version = "2.0.33"
+version = "2.0.41"
 source = { editable = "." }
 dependencies = [
     { name = "instructor" },
@@ -3165,10 +3164,10 @@ requires-dist = [
     { name = "aiosqlite", marker = "extra == 'code'", specifier = ">=0.20.0" },
     { name = "aiosqlite", marker = "extra == 'realtime'", specifier = ">=0.20.0" },
     { name = "aiosqlite", marker = "extra == 'ui'", specifier = ">=0.20.0" },
-    { name = "chainlit", marker = "extra == 'chat'", specifier = "==1.3.2" },
-    { name = "chainlit", marker = "extra == 'code'", specifier = "==1.3.2" },
-    { name = "chainlit", marker = "extra == 'realtime'", specifier = "==1.3.2" },
-    { name = "chainlit", marker = "extra == 'ui'", specifier = "==1.3.2" },
+    { name = "chainlit", marker = "extra == 'chat'", specifier = "==2.0.1" },
+    { name = "chainlit", marker = "extra == 'code'", specifier = "==2.0.1" },
+    { name = "chainlit", marker = "extra == 'realtime'", specifier = "==2.0.1" },
+    { name = "chainlit", marker = "extra == 'ui'", specifier = "==2.0.1" },
     { name = "crawl4ai", marker = "extra == 'chat'", specifier = "==0.3.4" },
     { name = "crawl4ai", marker = "extra == 'code'", specifier = "==0.3.4" },
     { name = "crawl4ai", marker = "extra == 'realtime'", specifier = "==0.3.4" },
@@ -3198,7 +3197,7 @@ requires-dist = [
     { name = "plotly", marker = "extra == 'realtime'", specifier = ">=5.24.0" },
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.7" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.7" },
-    { name = "praisonaiagents", specifier = ">=0.0.23" },
+    { name = "praisonaiagents", specifier = ">=0.0.31" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = ">=0.2.19" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -3251,16 +3250,16 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.23"
+version = "0.0.31"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "openai" },
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a8/87/08ff2ac7c365251fa07973fded3e68c2edc1173d8514e6fd90fc8ee7b131/praisonaiagents-0.0.23.tar.gz", hash = "sha256:1814d537b2625a5c7d4b61d07f5d5bd043f0ad8afc31fe9d4eb99a5ca54101bf", size = 25375 }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/33/3dbf92fd64ee405b9382e79f688cef390ff9164d72ead030f4246fb9d2d1/praisonaiagents-0.0.31.tar.gz", hash = "sha256:9c372c51c741a0365c1186b087b3a72f4371e6ae2c203fa072b7a89a400e2560", size = 68508 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/56/75/c3a1cf2adaf0811ab538029054fa993e82caffba2853546f41766b7e0aab/praisonaiagents-0.0.23-py3-none-any.whl", hash = "sha256:d6aaa406fc993ccd0a763aa426b7139c955e1cd99e6b204b06817ebc1a5855e3", size = 31734 },
+    { url = "https://files.pythonhosted.org/packages/91/7e/6eea88722770bd5f2691d8a0669cc46746961db969ea58d1380ce9e31648/praisonaiagents-0.0.31-py3-none-any.whl", hash = "sha256:41445ca9ab38d26f01df0873837bf8436e7013020474808312eff06894f2ce8e", size = 85455 },
 ]
 
 [[package]]
@@ -3839,11 +3838,11 @@ wheels = [
 
 [[package]]
 name = "python-multipart"
-version = "0.0.9"
+version = "0.0.18"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5c/0f/9c55ac6c84c0336e22a26fa84ca6c51d58d7ac3a2d78b0dfa8748826c883/python_multipart-0.0.9.tar.gz", hash = "sha256:03f54688c663f1b7977105f021043b0793151e4cb1c1a9d4a11fc13d622c4026", size = 31516 }
+sdist = { url = "https://files.pythonhosted.org/packages/b4/86/b6b38677dec2e2e7898fc5b6f7e42c2d011919a92d25339451892f27b89c/python_multipart-0.0.18.tar.gz", hash = "sha256:7a68db60c8bfb82e460637fa4750727b45af1d5e2ed215593f917f64694d34fe", size = 36622 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3d/47/444768600d9e0ebc82f8e347775d24aef8f6348cf00e9fa0e81910814e6d/python_multipart-0.0.9-py3-none-any.whl", hash = "sha256:97ca7b8ea7b05f977dc3849c3ba99d51689822fab725c3703af7c866a0c2b215", size = 22299 },
+    { url = "https://files.pythonhosted.org/packages/13/6b/b60f47101ba2cac66b4a83246630e68ae9bbe2e614cbae5f4465f46dee13/python_multipart-0.0.18-py3-none-any.whl", hash = "sha256:efe91480f485f6a361427a541db4796f9e1591afc0fb8e7a4ba06bfbc6708996", size = 24389 },
 ]
 
 [[package]]