Merge pull request #302 from MervinPraison/develop

Develop

.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.39 gunicorn markdown
+RUN pip install flask praisonai==2.0.48 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/autonomous-agent.py

@@ -0,0 +1,114 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import time
+
+def get_environment_state():
+    """Simulates getting current environment state"""
+    current_time = int(time.time())
+    states = ["normal", "critical", "optimal"]
+    state = states[current_time % 3]
+    print(f"Environment state: {state}")
+    return state
+
+def perform_action(state: str):
+    """Simulates performing an action based on state"""
+    actions = {
+        "normal": "maintain",
+        "critical": "fix",
+        "optimal": "enhance"
+    }
+    action = actions.get(state, "observe")
+    print(f"Performing action: {action} for state: {state}")
+    return action
+
+def get_feedback():
+    """Simulates environment feedback"""
+    current_time = int(time.time())
+    feedback = "positive" if current_time % 2 == 0 else "negative"
+    print(f"Feedback received: {feedback}")
+    return feedback
+
+# Create specialized agents
+llm_caller = Agent(
+    name="Environment Monitor",
+    role="State analyzer",
+    goal="Monitor environment and analyze state",
+    instructions="Check environment state and provide analysis",
+    tools=[get_environment_state]
+)
+
+action_agent = Agent(
+    name="Action Executor",
+    role="Action performer",
+    goal="Execute appropriate actions based on state",
+    instructions="Determine and perform actions based on environment state",
+    tools=[perform_action]
+)
+
+feedback_agent = Agent(
+    name="Feedback Processor",
+    role="Feedback analyzer",
+    goal="Process environment feedback and adapt strategy",
+    instructions="Analyze feedback and provide adaptation recommendations",
+    tools=[get_feedback]
+)
+
+# Create tasks for autonomous workflow
+monitor_task = Task(
+    name="monitor_environment",
+    description="Monitor and analyze environment state",
+    expected_output="Current environment state analysis",
+    agent=llm_caller,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["execute_action"],
+    condition={
+        "normal": ["execute_action"],
+        "critical": ["execute_action"],
+        "optimal": "exit"
+    }
+)
+
+action_task = Task(
+    name="execute_action",
+    description="Execute appropriate action based on state",
+    expected_output="Action execution result",
+    agent=action_agent,
+    next_tasks=["process_feedback"]
+)
+
+feedback_task = Task(
+    name="process_feedback",
+    description="Process feedback and adapt strategy",
+    expected_output="Strategy adaptation based on feedback",
+    agent=feedback_agent,
+    next_tasks=["monitor_environment"],  # Create feedback loop
+    context=[monitor_task, action_task]  # Access to previous states and actions
+)
+
+# Create workflow manager
+workflow = PraisonAIAgents(
+    agents=[llm_caller, action_agent, feedback_agent],
+    tasks=[monitor_task, action_task, feedback_task],
+    process="workflow",
+    verbose=True
+)
+
+def main():
+    print("\nStarting Autonomous Agent Workflow...")
+    print("=" * 50)
+    
+    # Run autonomous workflow
+    results = workflow.start()
+    
+    # Print results
+    print("\nAutonomous Agent Results:")
+    print("=" * 50)
+    for task_id, result in results["task_results"].items():
+        if result:
+            task_name = result.description
+            print(f"\nTask: {task_name}")
+            print(f"Result: {result.raw}")
+            print("-" * 50)
+
+if __name__ == "__main__":
+    main()

agents/chunking-direct-test.py

@@ -0,0 +1,14 @@
+from praisonaiagents.knowledge import Chunking
+
+# No heavy imports or initialization happens here
+chunking = Chunking(chunker_type='token')
+
+# Chunker is only initialized when first used
+chunks = chunking.chunk("Your text here")
+
+# Embedding model is only loaded if using semantic chunking
+semantic_chunking = Chunking(chunker_type='recursive')
+# Embedding model and chunker are loaded here on first use
+semantic_chunks = semantic_chunking.chunk("Your text here")
+
+print(semantic_chunks)

agents/code_review.py

@@ -0,0 +1,108 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import time
+from typing import List, Dict
+
+def analyze_code_changes():
+    """Simulates code analysis"""
+    issues = [
+        {"type": "style", "severity": "low", "file": "main.py"},
+        {"type": "security", "severity": "high", "file": "auth.py"},
+        {"type": "performance", "severity": "medium", "file": "data.py"}
+    ]
+    return issues[int(time.time()) % 3]
+
+def suggest_fixes(issue: Dict):
+    """Simulates fix suggestions"""
+    fixes = {
+        "style": "Apply PEP 8 formatting",
+        "security": "Implement input validation",
+        "performance": "Use list comprehension"
+    }
+    return fixes.get(issue["type"], "Review manually")
+
+def apply_automated_fix(fix: str):
+    """Simulates applying automated fixes"""
+    success = int(time.time()) % 2 == 0
+    return "fixed" if success else "manual_review"
+
+# Create specialized agents
+analyzer = Agent(
+    name="Code Analyzer",
+    role="Code analysis",
+    goal="Analyze code changes and identify issues",
+    instructions="Review code changes and report issues",
+    tools=[analyze_code_changes]
+)
+
+fix_suggester = Agent(
+    name="Fix Suggester",
+    role="Solution provider",
+    goal="Suggest fixes for identified issues",
+    instructions="Provide appropriate fix suggestions",
+    tools=[suggest_fixes]
+)
+
+fix_applier = Agent(
+    name="Fix Applier",
+    role="Fix implementation",
+    goal="Apply suggested fixes automatically when possible",
+    instructions="Implement suggested fixes and report results",
+    tools=[apply_automated_fix]
+)
+
+# Create workflow tasks
+analysis_task = Task(
+    name="analyze_code",
+    description="Analyze code changes for issues",
+    expected_output="Identified code issues",
+    agent=analyzer,
+    is_start=True,
+    next_tasks=["suggest_fixes"]
+)
+
+suggestion_task = Task(
+    name="suggest_fixes",
+    description="Suggest fixes for identified issues",
+    expected_output="Fix suggestions",
+    agent=fix_suggester,
+    next_tasks=["apply_fixes"]
+)
+
+fix_task = Task(
+    name="apply_fixes",
+    description="Apply suggested fixes",
+    expected_output="Fix application status",
+    agent=fix_applier,
+    task_type="decision",
+    condition={
+        "fixed": "",
+        "manual_review": ["suggest_fixes"]  # Loop back for manual review
+    }
+)
+
+# Create workflow
+workflow = PraisonAIAgents(
+    agents=[analyzer, fix_suggester, fix_applier],
+    tasks=[analysis_task, suggestion_task, fix_task],
+    process="workflow",
+    verbose=True
+)
+
+def main():
+    print("\nStarting Code Review Workflow...")
+    print("=" * 50)
+    
+    # Run workflow
+    results = workflow.start()
+    
+    # Print results
+    print("\nCode Review Results:")
+    print("=" * 50)
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"\nTask: {task_id}")
+            print(f"Result: {result.raw}")
+            print("-" * 50)
+
+if __name__ == "__main__":
+    main()

agents/data-analyst-agent.py

@@ -0,0 +1,10 @@
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import read_csv, read_excel, write_csv, write_excel, filter_data, get_summary, group_by, pivot_table
+import os
+
+agent = Agent(instructions="You are a Data Analyst Agent", tools=[read_csv, read_excel, write_csv, write_excel, filter_data, get_summary, group_by, pivot_table])
+agent.start(f"""
+    Read the data from the csv file {os.path.join(os.path.dirname(__file__), "tesla-stock-price.csv")}
+    Analyse the data and give me the insights
+    read_csv to read the file
+""")

agents/document.txt

@@ -0,0 +1,3 @@
+I am Mervin Praison, a software engineer and entrepreneur.
+
+I am the founder of Praison AI, a company that is building AI agents to help people with their daily tasks.

agents/evaluator-optimiser.py

@@ -0,0 +1,70 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create generator and evaluator agents
+generator = Agent(
+    name="Generator",
+    role="Solution generator",
+    goal="Generate initial solutions and incorporate feedback",
+    instructions=(
+        "1. Look at the context from previous tasks.\n"
+        "2. If you see that you have already produced 2 points, then add another 2 new points "
+        "   so that the total becomes 10.\n"
+        "3. Otherwise, just produce the first 2 points.\n"
+        "4. Return only the final list of points, with no extra explanation."
+    )
+)
+
+evaluator = Agent(
+    name="Evaluator",
+    role="Solution evaluator",
+    goal="Evaluate solutions and provide improvement feedback",
+    instructions=(
+        "1. Count how many lines in the response start with a number and a period (like '1. ' or '2. ').\n"
+        "2. If there are 10 or more, respond with 'done'.\n"
+        "3. Otherwise, respond with 'more'.\n"
+        "4. Return only the single word: 'done' or 'more'."
+    )
+)
+
+
+# Create tasks for the feedback loop
+generate_task = Task(
+    name="generate",
+    description="Write 2 points about AI incuding if anything exiting from previous points",
+    expected_output="2 points",
+    agent=generator,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["evaluate"]
+)
+
+evaluate_task = Task(
+    name="evaluate",
+    description="Check if there are 10 points about AI",
+    expected_output="more or done",
+    agent=evaluator,
+    next_tasks=["generate"],
+    context=[generate_task],
+    task_type="decision",
+    condition={
+        "more": ["generate"],  # Continue to generate
+        "done": [""]  # Exit when optimization complete
+    }
+)
+
+# Create workflow manager
+workflow = PraisonAIAgents(
+    agents=[generator, evaluator],
+    tasks=[generate_task, evaluate_task],
+    process="workflow",
+    verbose=True
+)
+
+# Run optimization workflow
+results = workflow.start()
+
+# Print results
+print("\nEvaluator-Optimizer Results:")
+for task_id, result in results["task_results"].items():
+    if result:
+        print(f"Task {task_id}: {result.raw}")

agents/finance-agent.py

@@ -0,0 +1,5 @@
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import get_stock_price, get_stock_info, get_historical_data
+
+agent = Agent(instructions="You are a Research Agent", tools=[get_stock_price, get_stock_info, get_historical_data])
+agent.start("Understand current stock price and historical data of Apple and Google. Tell me if I can invest in them")

agents/gradio-agents.py

@@ -0,0 +1,34 @@
+import gradio as gr
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+def research(query):
+    agent = Agent(instructions="You are a Research Agent", tools=[duckduckgo])
+    result = agent.start(query)
+    # Format the result with enhanced markdown
+    formatted_result = f"""
+{result}
+----
+*Generated by PraisonAI Research Assistant*
+    """
+    return formatted_result
+
+# Create a simple Gradio interface
+demo = gr.Interface(
+    fn=research,
+    inputs=gr.Textbox(
+        label="Research Query",
+        placeholder="Enter your research topic...",
+        lines=2
+    ),
+    outputs=gr.Markdown(
+        show_copy_button=True,
+        height=500,
+        container=True
+    ),
+    title="AI Research Assistant",
+    description="Enter your research query below to get started!",
+)
+
+if __name__ == "__main__":
+    demo.launch()

agents/image-agent.py

@@ -0,0 +1,47 @@
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Image Analysis Agent", tools=[duckduckgo])
+agent.start("I want to go London next week, find me a good hotel and flight")
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create Image Analysis Agent
+image_agent = Agent(
+    name="ImageAnalyst",
+    role="Image Analysis 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
+)
+
+# 1. Task with Image URL
+task1 = 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=image_agent,
+    images=["https://upload.wikimedia.org/wikipedia/commons/b/bf/Krakow_-_Kosciol_Mariacki.jpg"]
+)
+
+# 2. Task with Local Image File
+task2 = Task(
+    name="analyze_local_image",
+    description="What objects can you see in this image? Describe their arrangement.",
+    expected_output="Detailed description of objects and their spatial relationships",
+    agent=image_agent,
+    images=["image.jpg"] 
+)
+
+# Create PraisonAIAgents instance
+agents = PraisonAIAgents(
+    agents=[image_agent],
+    tasks=[task1, task2],
+    process="sequential",
+    verbose=1
+)
+
+# Run all tasks
+agents.start()

agents/image-to-text-agent.py

@@ -0,0 +1,47 @@
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Image Analysis Agent", tools=[duckduckgo])
+agent.start("I want to go London next week, find me a good hotel and flight")
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create Image Analysis Agent
+image_agent = Agent(
+    name="ImageAnalyst",
+    role="Image Analysis 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
+)
+
+# 1. Task with Image URL
+task1 = 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=image_agent,
+    images=["https://upload.wikimedia.org/wikipedia/commons/b/bf/Krakow_-_Kosciol_Mariacki.jpg"]
+)
+
+# 2. Task with Local Image File
+task2 = Task(
+    name="analyze_local_image",
+    description="What objects can you see in this image? Describe their arrangement.",
+    expected_output="Detailed description of objects and their spatial relationships",
+    agent=image_agent,
+    images=["image.jpg"] 
+)
+
+# Create PraisonAIAgents instance
+agents = PraisonAIAgents(
+    agents=[image_agent],
+    tasks=[task1, task2],
+    process="sequential",
+    verbose=1
+)
+
+# Run all tasks
+agents.start()

agents/knowledge-agents-task.py

@@ -0,0 +1,48 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import logging
+import os
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Define the configuration for the Knowledge instance
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "knowledge_test",
+            "path": ".praison",
+        }
+    }
+}
+
+# Create an agent with knowledge capabilities
+knowledge_agent = Agent(
+    name="KnowledgeAgent",
+    role="Information Specialist",
+    goal="Store and retrieve knowledge efficiently",
+    backstory="Expert in managing and utilizing stored knowledge",
+    knowledge=["sample.pdf"],
+    knowledge_config=config,
+    verbose=True
+)
+
+# Define a task for the agent
+knowledge_task = Task(
+    name="knowledge_task",
+    description="Who is Mervin Praison?",
+    expected_output="Answer to the question",
+    agent=knowledge_agent
+)
+
+# Create and start the agents
+agents = PraisonAIAgents(
+    agents=[knowledge_agent],
+    tasks=[knowledge_task],
+    process="sequential",
+    user_id="user1"
+)
+
+# Start execution
+result = agents.start()

agents/knowledge-agents.py

@@ -0,0 +1,20 @@
+from praisonaiagents import Agent
+
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "custom_knowledge",
+            "path": ".praison",
+        }
+    }
+}
+
+agent = Agent(
+    name="Knowledge Agent",
+    instructions="You answer questions based on the provided knowledge.",
+    knowledge=["large.pdf"],
+    knowledge_config=config
+)
+
+agent.start("What is KAG in one line?")

agents/knowledge-direct-test.py

@@ -0,0 +1,171 @@
+import logging
+from praisonaiagents.knowledge import Knowledge
+import os
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "test",
+            "path": ".praison",
+        }
+    }
+}
+
+knowledge = Knowledge(config)
+
+# Store memories
+logger.info("Storing memories...")
+cricket_memory = knowledge.store("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+logger.info(f"Stored cricket memory: {cricket_memory}")
+tennis_memory = knowledge.store("Enjoys playing tennis with friends", user_id="alice", metadata={"category": "hobbies"})
+logger.info(f"Stored tennis memory: {tennis_memory}")
+work_memory = knowledge.store("Works as a software engineer", user_id="alice", metadata={"category": "work"})
+logger.info(f"Stored work memory: {work_memory}")
+
+print("Stored memories:")
+print(cricket_memory)
+print(tennis_memory)
+print(work_memory)
+
+# Retrieve all memories for a user
+logger.info("Retrieving all memories for Alice...")
+alice_memories = knowledge.get_all(user_id="alice")
+logger.info(f"Retrieved memories for Alice: {alice_memories}")
+print("\nAll memories for Alice:")
+for memory in alice_memories:
+    print(memory)
+
+# Retrieve a specific memory by ID
+logger.info(f"Retrieving memory with ID: {cricket_memory['results'][0]['id']}")
+retrieved_memory = knowledge.get(cricket_memory['results'][0]["id"])
+logger.info(f"Retrieved memory: {retrieved_memory}")
+print("\nRetrieved memory:")
+print(retrieved_memory)
+
+# Search for memories based on a query
+query = "What are Alice's hobbies?"
+logger.info(f"Searching for memories with query: {query}")
+search_results = knowledge.search(query, user_id="alice")
+logger.info(f"Search results: {search_results}")
+print(f"\nSearch results for '{query}':")
+for memory in search_results:
+    print(memory)
+
+# Update a memory
+logger.info(f"Updating memory with ID: {tennis_memory['results'][0]['id']}")
+updated_memory = knowledge.update(memory_id=tennis_memory['results'][0]["id"], data="Loves playing tennis on weekends")
+logger.info(f"Updated memory: {updated_memory}")
+print("\nUpdated memory:")
+print(updated_memory)
+
+# Get memory history
+logger.info(f"Retrieving memory history for ID: {tennis_memory['results'][0]['id']}")
+memory_history = knowledge.history(memory_id=tennis_memory['results'][0]["id"])
+logger.info(f"Memory history: {memory_history}")
+print("\nMemory history:")
+for entry in memory_history:
+    print(entry)
+
+# Delete a memory
+logger.info(f"Deleting memory with ID: {work_memory['results'][0]['id']}")
+knowledge.delete(memory_id=work_memory['results'][0]["id"])
+logger.info("Memory deleted")
+print("\nDeleted memory")
+
+# Retrieve memories after deletion
+logger.info("Retrieving memories after deletion...")
+alice_memories = knowledge.get_all(user_id="alice")
+logger.info(f"Retrieved memories after deletion: {alice_memories}")
+print("\nMemories after deletion:")
+for memory in alice_memories:
+    print(memory)
+
+# Delete all memories for a user
+logger.info("Deleting all memories for Alice...")
+knowledge.delete_all(user_id="alice")
+logger.info("All memories for Alice deleted")
+print("\nAll memories for Alice deleted")
+
+# Retrieve memories after deleting all
+logger.info("Retrieving memories after deleting all...")
+alice_memories = knowledge.get_all(user_id="alice")
+logger.info(f"Retrieved memories after deleting all: {alice_memories}")
+print("\nMemories after deleting all:")
+print(alice_memories)
+
+# Reset all memories
+logger.info("Resetting all memories...")
+knowledge.reset()
+logger.info("All memories reset")
+print("\nAll memories reset")
+
+# Test file handling
+logger.info("Testing file handling...")
+
+try:
+    # Get absolute path to test files
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    pdf_file = os.path.join(current_dir, "small.pdf")
+    txt_file = os.path.join(current_dir, "sample.txt")
+
+    # Test text file
+    logger.info(f"Testing text file: {txt_file}")
+    # Read and display content
+    with open(txt_file, 'r') as file:
+        txt_content = file.read()
+        print("\nText file content:")
+        print(txt_content)
+    # Store the text file using add
+    txt_memory = knowledge.add(txt_file, user_id="bob", metadata={"type": "text"})
+    logger.info(f"Stored text file: {txt_memory}")
+    print("\nStored text content:")
+    if txt_memory and 'results' in txt_memory and txt_memory['results']:
+        for mem in txt_memory['results']:
+            print(mem)
+    else:
+        print("No valid memories were stored from the text file")
+
+    # Verify text memories are stored
+    if txt_memory and 'results' in txt_memory and txt_memory['results']:
+        logger.info("Verifying text memories...")
+        for mem in txt_memory['results']:
+            if isinstance(mem, dict) and 'id' in mem:
+                stored = knowledge.get(mem['id'])
+                logger.info(f"Verified text memory: {stored}")
+            else:
+                logger.warning(f"Unexpected memory format: {mem}")
+    else:
+        logger.warning("No valid memories were stored from the text file")
+
+    # Test pdf file
+    logger.info(f"Testing pdf file: {pdf_file}")
+    pdf_memory = knowledge.add(pdf_file, user_id="bob", metadata={"type": "pdf"})
+    logger.info(f"Stored pdf file: {pdf_memory}")
+    print("\nStored pdf content:")
+    if pdf_memory and 'results' in pdf_memory and pdf_memory['results']:
+        for mem in pdf_memory['results']:
+            print(mem)
+    else:
+        print("No valid memories were stored from the PDF file")
+
+    # Verify stored content
+    if pdf_memory and 'results' in pdf_memory and pdf_memory['results']:
+        for memory in pdf_memory['results']:
+            if isinstance(memory, dict) and 'id' in memory:
+                stored_memory = knowledge.get(memory['id'])
+                logger.info(f"Verified stored memory: {stored_memory}")
+                print("\nVerified content:")
+                print(stored_memory)
+            else:
+                logger.warning(f"Unexpected memory format: {memory}")
+    else:
+        logger.warning("No valid memories were stored from the PDF file")
+
+except Exception as e:
+    logger.error(f"Error during file handling test: {str(e)}")
+    raise
+

agents/knowledge-large-pdf-test.py

@@ -0,0 +1,40 @@
+import logging
+from praisonaiagents.knowledge import Knowledge
+import os
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+knowledge = Knowledge()
+try:
+    # Get absolute path to test files
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    pdf_file = os.path.join(current_dir, "large.pdf")
+
+    # Test pdf file
+    logger.info(f"Testing pdf file: {pdf_file}")
+    pdf_memory = knowledge.add(pdf_file, user_id="bob", metadata={"type": "pdf"})
+    logger.info(f"Stored pdf file: {pdf_memory}")
+    print("\nStored pdf content:")
+    if pdf_memory and 'results' in pdf_memory and pdf_memory['results']:
+        for mem in pdf_memory['results']:
+            print(mem)
+    else:
+        print("No valid memories were stored from the PDF file")
+
+    # Verify stored content
+    if pdf_memory and 'results' in pdf_memory and pdf_memory['results']:
+        for memory in pdf_memory['results']:
+            if isinstance(memory, dict) and 'id' in memory:
+                stored_memory = knowledge.get(memory['id'])
+                logger.info(f"Verified stored memory: {stored_memory}")
+                print("\nVerified content:")
+                print(stored_memory)
+            else:
+                logger.warning(f"Unexpected memory format: {memory}")
+    else:
+        logger.warning("No valid memories were stored from the PDF file")
+
+except Exception as e:
+    logger.error(f"Error during file handling test: {str(e)}")
+    raise

agents/markdown-agent.py

@@ -0,0 +1,4 @@
+from praisonaiagents import Agent
+
+agent = Agent(instructions="You are a Markdown Agent, output in markdown format")
+agent.start("Write a blog post about AI")

agents/md.py

@@ -0,0 +1,5 @@
+from markitdown import MarkItDown
+
+md = MarkItDown()
+result = md.convert("sample.txt")
+print(result.text_content)

agents/multimodal.py

@@ -51,9 +51,4 @@ agents = PraisonAIAgents(
 )
 
 # Run all tasks
-result = agents.start()
-
-# Print results
-for task_id, task_result in result["task_results"].items():
-    print(f"\nTask {task_id} Result:")
-    print(task_result.raw)
+agents.start()

agents/orchestrator-workers.py

@@ -0,0 +1,110 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import time
+
+def get_time_check():
+    current_time = int(time.time())
+    if current_time % 3 == 0:
+        result = 1
+    elif current_time % 3 == 1:
+        result = 2
+    else:
+        result = 3
+    print(f"Time: {current_time}, Result: {result}")
+    return result
+
+# Create orchestrator and worker agents
+router = Agent(
+    name="Router",
+    role="Task router",
+    goal="Distribute tasks to based on response from get_time_check",
+    tools=[get_time_check]
+)
+
+worker1 = Agent(
+    name="Worker 1",
+    role="Specialized worker",
+    goal="Handle specific subtask type 1",
+)
+
+worker2 = Agent(
+    name="Worker 2",
+    role="Specialized worker",
+    goal="Handle specific subtask type 2",
+)
+
+worker3 = Agent(
+    name="Worker 3",
+    role="Specialized worker",
+    goal="Handle specific subtask type 3",
+)
+
+synthesizer = Agent(
+    name="Synthesizer",
+    role="Result synthesizer",
+    goal="Combine and synthesize worker outputs",
+)
+
+# Create orchestrated workflow tasks
+router_task = Task(
+    name="route_task",
+    description="Analyze input from get_time_check and route to appropriate workers",
+    expected_output="Task routing decision, 1 , 2 or 3",
+    agent=router,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["worker1_task", "worker2_task", "worker3_task"],
+    condition={
+        "1": ["worker1_task"],
+        "2": ["worker2_task"],
+        "3": ["worker3_task"]
+    }
+)
+
+worker1_task = Task(
+    name="worker1_task",
+    description="Process type 1 operation",
+    expected_output="Worker 1 result",
+    agent=worker1,
+    next_tasks=["synthesize_task"]
+)
+
+worker2_task = Task(
+    name="worker2_task",
+    description="Process type 2 operation",
+    expected_output="Worker 2 result",
+    agent=worker2,
+    next_tasks=["synthesize_task"]
+)
+
+worker3_task = Task(
+    name="worker3_task",
+    description="Process type 3 operation",
+    expected_output="Worker 3 result",
+    agent=worker3,
+    next_tasks=["synthesize_task"]
+)
+
+synthesize_task = Task(
+    name="synthesize_task",
+    description="Synthesize worker results into final output",
+    expected_output="Final synthesized result",
+    agent=synthesizer,
+    context=[worker1_task, worker2_task, worker3_task]
+)
+
+# Create workflow manager
+workflow = PraisonAIAgents(
+    agents=[router, worker1, worker2, worker3, synthesizer],
+    tasks=[router_task, worker1_task, worker2_task, worker3_task, synthesize_task],
+    process="workflow",
+    verbose=True
+)
+
+# Run orchestrated workflow
+results = workflow.start()
+
+# Print results
+print("\nOrchestrator-Workers Results:")
+for task_id, result in results["task_results"].items():
+    if result:
+        print(f"Task {task_id}: {result.raw}")

agents/parallelisation.py

@@ -0,0 +1,95 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from datetime import datetime
+import asyncio
+
+def process_time():
+    """Simulate processing"""
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"Processing at: {current_time}")
+    return f"Processed at {current_time}"
+
+# Create parallel processing agents
+agent1 = Agent(
+    name="Processor 1",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+agent2 = Agent(
+    name="Processor 2",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+agent3 = Agent(
+    name="Processor 3",
+    role="Time collector",
+    goal="Get the time and return it",
+    tools=[process_time]
+)
+
+aggregator = Agent(
+    name="Aggregator",
+    role="Result aggregator",
+    goal="Collect all the processed time from all tasks"
+)
+
+# Create parallel tasks with memory disabled
+task1 = Task(
+    name="process_1",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent1,
+    is_start=True,
+    async_execution=True
+)
+
+task2 = Task(
+    name="process_2",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent2,
+    is_start=True,
+    async_execution=True
+)
+
+task3 = Task(
+    name="process_3",
+    description="Use process_time tool to get the time",
+    expected_output="processed time",
+    agent=agent3,
+    is_start=True,
+    async_execution=True
+)
+
+aggregate_task = Task(
+    name="aggregate",
+    description="Collect all the processed time from all tasks",
+    expected_output="Output all the processed time from all tasks and just the time",
+    agent=aggregator,
+    context=[task1, task2, task3]
+)
+
+async def main():
+
+    # Create workflow manager
+    workflow = PraisonAIAgents(
+        agents=[agent1, agent2, agent3, aggregator],
+        tasks=[task1, task2, task3, aggregate_task],
+        process="workflow"
+    )
+
+    # Run parallel workflow
+    results = await workflow.astart()
+
+    # Print results
+    print("\nParallel Processing Results:")
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"Task {task_id}: {result.raw}")
+
+# Run the async main function
+if __name__ == "__main__":
+    asyncio.run(main())

agents/pdf_agents_example.py

@@ -0,0 +1,41 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create PDF Analysis Agent
+pdf_agent = Agent(
+    name="PDFAnalyst",
+    role="PDF Document Specialist",
+    goal="Analyze PDF documents to extract meaningful information",
+    backstory="""You are an expert in PDF document analysis and text extraction.
+    You excel at understanding document structure, extracting content, and analyzing textual information.""",
+    llm="gpt-4o-mini",
+    self_reflect=False
+)
+
+# 1. Task with PDF URL
+task1 = Task(
+    name="analyze_pdf_url",
+    description="Extract and analyze content from this PDF document.",
+    expected_output="Detailed analysis of the PDF content and structure",
+    agent=pdf_agent,
+    input=["https://example.com/document.pdf"]
+)
+
+# 2. Task with Local PDF File
+task2 = Task(
+    name="analyze_local_pdf",
+    description="What information can you extract from this PDF? Analyze its content.",
+    expected_output="Detailed analysis of the PDF content and structure",
+    agent=pdf_agent,
+    input=["document.pdf"] 
+)
+
+# Create PraisonAIAgents instance
+agents = PraisonAIAgents(
+    agents=[pdf_agent],
+    tasks=[task1, task2],
+    process="sequential",
+    verbose=1
+)
+
+# Run all tasks
+agents.start()

agents/planning-agent.py

@@ -0,0 +1,5 @@
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Planning Agent", tools=[duckduckgo])
+agent.start("I want to go London next week, find me a good hotel and flight")

agents/praisonaiagents/__init__.py

@@ -7,6 +7,8 @@ from .agents.agents import PraisonAIAgents
 from .task.task import Task
 from .tools.tools import Tools
 from .agents.autoagents import AutoAgents
+from .knowledge.knowledge import Knowledge
+from .knowledge.chunking import Chunking
 from .memory.memory import Memory
 from .main import (
     TaskOutput,
@@ -48,4 +50,6 @@ __all__ = [
     'register_display_callback',
     'sync_display_callbacks',
     'async_display_callbacks',
+    'Knowledge',
+    'Chunking'
 ] 

agents/praisonaiagents/agent/agent.py

@@ -16,9 +16,11 @@ from ..main import (
     display_self_reflection,
     ReflectionOutput,
     client,
-    error_logs
+    error_logs,
+    adisplay_instruction
 )
 import inspect
+import uuid
 
 if TYPE_CHECKING:
     from ..task.task import Task
@@ -175,13 +177,15 @@ class Agent:
         respect_context_window: bool = True,
         code_execution_mode: Literal["safe", "unsafe"] = "safe",
         embedder_config: Optional[Dict[str, Any]] = None,
-        knowledge_sources: Optional[List[Any]] = None,
+        knowledge: Optional[List[str]] = None,
+        knowledge_config: Optional[Dict[str, Any]] = None,
         use_system_prompt: Optional[bool] = True,
         markdown: bool = True,
         self_reflect: bool = False,
         max_reflect: int = 3,
         min_reflect: int = 1,
-        reflect_llm: Optional[str] = None
+        reflect_llm: Optional[str] = None,
+        user_id: Optional[str] = None
     ):
         # Handle backward compatibility for required fields
         if all(x is None for x in [name, role, goal, backstory, instructions]):
@@ -225,7 +229,7 @@ class Agent:
         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.knowledge = knowledge
         self.use_system_prompt = use_system_prompt
         self.chat_history = []
         self.markdown = markdown
@@ -241,6 +245,36 @@ Your Role: {self.role}\n
 Your Goal: {self.goal}
         """
 
+        # Generate unique IDs
+        self.agent_id = str(uuid.uuid4())
+
+        # Store user_id
+        self.user_id = user_id
+
+        # Initialize Knowledge with provided or default config
+        from praisonaiagents.knowledge import Knowledge
+        self.knowledge = Knowledge(knowledge_config or None)
+
+        # Handle knowledge
+        if knowledge:
+            for source in knowledge:
+                self._process_knowledge(source)
+
+    def _process_knowledge(self, knowledge_item):
+        """Process and store knowledge from a file path, URL, or string."""
+        try:
+            if os.path.exists(knowledge_item):
+                # It's a file path
+                self.knowledge.add(knowledge_item, user_id=self.user_id, agent_id=self.agent_id)
+            elif knowledge_item.startswith("http://") or knowledge_item.startswith("https://"):
+                # It's a URL
+                pass
+            else:
+                # It's a string content
+                self.knowledge.store(knowledge_item, user_id=self.user_id, agent_id=self.agent_id)
+        except Exception as e:
+            logging.error(f"Error processing knowledge item: {knowledge_item}, error: {e}")
+
     def generate_task(self) -> 'Task':
         """Generate a Task object from the agent's instructions"""
         from ..task.task import Task
@@ -417,6 +451,21 @@ Your Goal: {self.goal}
             return None
 
     def chat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None):
+        # Search for existing knowledge if any knowledge is provided
+        if self.knowledge:
+            search_results = self.knowledge.search(prompt, agent_id=self.agent_id)
+            if search_results:
+                # Check if search_results is a list of dictionaries or strings
+                if isinstance(search_results, dict) and 'results' in search_results:
+                    # Extract memory content from the results
+                    knowledge_content = "\n".join([result['memory'] for result in search_results['results']])
+                else:
+                    # If search_results is a list of strings, join them directly
+                    knowledge_content = "\n".join(search_results)
+                
+                # Append found knowledge to the prompt
+                prompt = f"{prompt}\n\nKnowledge: {knowledge_content}"
+
         if self.use_system_prompt:
             system_prompt = f"""{self.backstory}\n
 Your Role: {self.role}\n
@@ -761,4 +810,8 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
 
     def run(self):
         """Alias for start() method"""
-        return self.start() 
+        return self.start() 
+
+    def start(self, prompt: str, **kwargs):
+        """Start the agent with a prompt. This is a convenience method that wraps chat()."""
+        return self.chat(prompt, **kwargs) 

agents/praisonaiagents/agents/agents.py

@@ -12,6 +12,7 @@ from ..agent.agent import Agent
 from ..task.task import Task
 from ..process.process import Process, LoopItems
 import asyncio
+import uuid
 
 # Set up logger
 logger = logging.getLogger(__name__)
@@ -44,10 +45,17 @@ 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, memory=False, memory_config=None, embedder=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, user_id=None):
         if not agents:
             raise ValueError("At least one agent must be provided")
-            
+        
+        self.run_id = str(uuid.uuid4())  # Auto-generate run_id
+        self.user_id = user_id  # Optional user_id
+
+        # Pass user_id to each agent
+        for agent in agents:
+            agent.user_id = self.user_id
+
         self.agents = agents
         self.tasks = {}
         if max_retries < 3:
@@ -211,6 +219,11 @@ class PraisonAIAgents:
 
         executor_agent = task.agent
 
+        # Ensure tools are available from both task and agent
+        tools = task.tools or []
+        if executor_agent and executor_agent.tools:
+            tools.extend(executor_agent.tools)
+
         task_prompt = f"""
 You need to do the following task: {task.description}.
 Expected Output: {task.expected_output}.
@@ -267,14 +280,14 @@ Here are the results of previous tasks that might be useful:\n
 
             agent_output = await executor_agent.achat(
                 _get_multimodal_message(task_prompt, task.images),
-                tools=task.tools,
+                tools=tools,
                 output_json=task.output_json,
                 output_pydantic=task.output_pydantic
             )
         else:
             agent_output = await executor_agent.achat(
                 task_prompt,
-                tools=task.tools,
+                tools=tools,
                 output_json=task.output_json,
                 output_pydantic=task.output_pydantic
             )
@@ -380,11 +393,25 @@ Here are the results of previous tasks that might be useful:\n
         )
         
         if self.process == "workflow":
+            # Collect all tasks that should run in parallel
+            parallel_tasks = []
             async for task_id in process.aworkflow():
-                if self.tasks[task_id].async_execution:
-                    await self.arun_task(task_id)
-                else:
-                    self.run_task(task_id)
+                if self.tasks[task_id].async_execution and self.tasks[task_id].is_start:
+                    parallel_tasks.append(task_id)
+                elif parallel_tasks:
+                    # Execute collected parallel tasks
+                    await asyncio.gather(*[self.arun_task(t) for t in parallel_tasks])
+                    parallel_tasks = []
+                    # Run the current non-parallel task
+                    if self.tasks[task_id].async_execution:
+                        await self.arun_task(task_id)
+                    else:
+                        self.run_task(task_id)
+            
+            # Execute any remaining parallel tasks
+            if parallel_tasks:
+                await asyncio.gather(*[self.arun_task(t) for t in parallel_tasks])
+                
         elif self.process == "sequential":
             async for task_id in process.asequential():
                 if self.tasks[task_id].async_execution:
@@ -596,8 +623,12 @@ Here are the results of previous tasks that might be useful:\n
                     task.status = "completed"
                     # Run execute_callback for memory operations
                     try:
-                        loop = asyncio.get_event_loop()
-                        loop.run_until_complete(task.execute_callback(task_output))
+                        if asyncio.get_event_loop().is_running():
+                            asyncio.create_task(task.execute_callback(task_output))
+                        else:
+                            loop = asyncio.new_event_loop()
+                            asyncio.set_event_loop(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)
@@ -606,7 +637,12 @@ Here are the results of previous tasks that might be useful:\n
                     if task.callback:
                         try:
                             if asyncio.iscoroutinefunction(task.callback):
-                                loop.run_until_complete(task.callback(task_output))
+                                if asyncio.get_event_loop().is_running():
+                                    asyncio.create_task(task.callback(task_output))
+                                else:
+                                    loop = asyncio.new_event_loop()
+                                    asyncio.set_event_loop(loop)
+                                    loop.run_until_complete(task.callback(task_output))
                             else:
                                 task.callback(task_output)
                         except Exception as e:

agents/praisonaiagents/knowledge/__init__.py

@@ -0,0 +1,8 @@
+"""
+PraisonAI Knowledge - Advanced knowledge management system with configurable features
+"""
+
+from praisonaiagents.knowledge.knowledge import Knowledge
+from praisonaiagents.knowledge.chunking import Chunking
+
+__all__ = ["Knowledge", "Chunking"] 

agents/praisonaiagents/knowledge/chunking.py

@@ -0,0 +1,182 @@
+from typing import List, Union, Optional, Dict, Any
+from functools import cached_property
+import importlib
+
+class Chunking:
+    """A unified class for text chunking with various chunking strategies."""
+    
+    CHUNKER_PARAMS = {
+        'token': ['chunk_size', 'chunk_overlap', 'tokenizer'],
+        'word': ['chunk_size', 'chunk_overlap', 'tokenizer'],
+        'sentence': ['chunk_size', 'chunk_overlap', 'tokenizer'],
+        'semantic': ['chunk_size', 'embedding_model', 'tokenizer'],
+        'sdpm': ['chunk_size', 'embedding_model', 'tokenizer'],
+        'late': ['chunk_size', 'embedding_model', 'tokenizer'],
+        'recursive': ['chunk_size', 'tokenizer']
+    }
+    
+    @cached_property
+    def SUPPORTED_CHUNKERS(self) -> Dict[str, Any]:
+        """Lazy load chunker classes."""
+        try:
+            from chonkie.chunker import (
+                TokenChunker,
+                WordChunker,
+                SentenceChunker,
+                SemanticChunker,
+                SDPMChunker,
+                LateChunker,
+                RecursiveChunker
+            )
+        except ImportError:
+            raise ImportError(
+                "chonkie package not found. Please install it using: pip install 'praisonaiagents[knowledge]'"
+            )
+            
+        return {
+            'token': TokenChunker,
+            'word': WordChunker,
+            'sentence': SentenceChunker,
+            'semantic': SemanticChunker,
+            'sdpm': SDPMChunker,
+            'late': LateChunker,
+            'recursive': RecursiveChunker
+        }
+
+    def __init__(
+        self,
+        chunker_type: str = 'token',
+        chunk_size: int = 512,
+        chunk_overlap: int = 128,
+        tokenizer: str = "gpt2",
+        embedding_model: Optional[Union[str, Any]] = None,
+        **kwargs
+    ):
+        """Initialize the Chunking class."""
+        if chunker_type not in self.CHUNKER_PARAMS:
+            raise ValueError(
+                f"Unsupported chunker type: {chunker_type}. "
+                f"Must be one of: {list(self.CHUNKER_PARAMS.keys())}"
+            )
+        
+        self.chunker_type = chunker_type
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+        self.tokenizer = tokenizer
+        self._embedding_model = embedding_model
+        self.kwargs = kwargs
+        
+        # Initialize these as None for lazy loading
+        self._chunker = None
+        self._embeddings = None
+        
+    @cached_property
+    def embedding_model(self):
+        """Lazy load the embedding model."""
+        if self._embedding_model is None and self.chunker_type in ['semantic', 'sdpm', 'late']:
+            from chonkie.embeddings import AutoEmbeddings
+            return AutoEmbeddings.get_embeddings("all-MiniLM-L6-v2")
+        elif isinstance(self._embedding_model, str):
+            from chonkie.embeddings import AutoEmbeddings
+            return AutoEmbeddings.get_embeddings(self._embedding_model)
+        return self._embedding_model
+
+    def _get_chunker_params(self) -> Dict[str, Any]:
+        """Get the appropriate parameters for the current chunker type."""
+        allowed_params = self.CHUNKER_PARAMS[self.chunker_type]
+        params = {'chunk_size': self.chunk_size}
+        
+        if 'chunk_overlap' in allowed_params:
+            params['chunk_overlap'] = self.chunk_overlap
+            
+        if 'tokenizer' in allowed_params:
+            if self.chunker_type in ['semantic', 'sdpm', 'late']:
+                params['tokenizer'] = self.embedding_model.get_tokenizer_or_token_counter()
+            else:
+                params['tokenizer'] = self.tokenizer
+                
+        if 'embedding_model' in allowed_params:
+            params['embedding_model'] = self.embedding_model
+            
+        # Add any additional kwargs that are in allowed_params
+        for key, value in self.kwargs.items():
+            if key in allowed_params:
+                params[key] = value
+                
+        return params
+
+    @cached_property
+    def chunker(self):
+        """Lazy load the chunker instance."""
+        if self._chunker is None:
+            chunker_cls = self.SUPPORTED_CHUNKERS[self.chunker_type]
+            common_params = self._get_chunker_params()
+            self._chunker = chunker_cls(**common_params)
+        
+        return self._chunker
+    
+    def _get_overlap_refinery(self, context_size: Optional[int] = None, **kwargs):
+        """Lazy load the overlap refinery."""
+        try:
+            from chonkie.refinery import OverlapRefinery
+        except ImportError:
+            raise ImportError("Failed to import OverlapRefinery from chonkie.refinery")
+            
+        if context_size is None:
+            context_size = self.chunk_overlap
+            
+        return OverlapRefinery(
+            context_size=context_size,
+            tokenizer=self.chunker.tokenizer,
+            **kwargs
+        )
+    
+    def add_overlap_context(
+        self,
+        chunks: List[Any],
+        context_size: int = None,
+        mode: str = "suffix",
+        merge_context: bool = True
+    ) -> List[Any]:
+        """Add overlap context to chunks using OverlapRefinery."""
+        refinery = self._get_overlap_refinery(
+            context_size=context_size,
+            mode=mode,
+            merge_context=merge_context
+        )
+        return refinery.refine(chunks)
+    
+    def chunk(
+        self,
+        text: Union[str, List[str]],
+        add_context: bool = False,
+        context_params: Optional[Dict[str, Any]] = None
+    ) -> Union[List[Any], List[List[Any]]]:
+        """Chunk text using the configured chunking strategy."""
+        chunks = self.chunker(text)
+        
+        if add_context:
+            context_params = context_params or {}
+            if isinstance(text, str):
+                chunks = self.add_overlap_context(chunks, **context_params)
+            else:
+                chunks = [self.add_overlap_context(c, **context_params) for c in chunks]
+                
+        return chunks
+    
+    def __call__(
+        self,
+        text: Union[str, List[str]],
+        add_context: bool = False,
+        context_params: Optional[Dict[str, Any]] = None
+    ) -> Union[List[Any], List[List[Any]]]:
+        """Make the Chunking instance callable."""
+        return self.chunk(text, add_context, context_params)
+    
+    def __repr__(self) -> str:
+        """String representation of the Chunking instance."""
+        return (
+            f"Chunking(chunker_type='{self.chunker_type}', "
+            f"chunk_size={self.chunk_size}, "
+            f"chunk_overlap={self.chunk_overlap})"
+        )

agents/praisonaiagents/knowledge/knowledge.py

@@ -0,0 +1,303 @@
+import os
+import logging
+import uuid
+import time
+from .chunking import Chunking
+from functools import cached_property
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+
+logger = logging.getLogger(__name__)
+
+class CustomMemory:
+    @classmethod
+    def from_config(cls, config):
+        from mem0 import Memory
+        return type('CustomMemory', (Memory,), {
+            '_add_to_vector_store': cls._add_to_vector_store
+        }).from_config(config)
+
+    @staticmethod
+    def _add_to_vector_store(self, messages, metadata, filters):
+        # Custom implementation that doesn't use LLM
+        parsed_messages = "\n".join([msg["content"] for msg in messages])
+        
+        # Create a simple fact without using LLM
+        new_retrieved_facts = [parsed_messages]
+        
+        # Process embeddings and continue with vector store operations
+        new_message_embeddings = {}
+        for new_mem in new_retrieved_facts:
+            messages_embeddings = self.embedding_model.embed(new_mem)
+            new_message_embeddings[new_mem] = messages_embeddings
+            
+        # Create the memory
+        memory_id = self._create_memory(
+            data=parsed_messages,
+            existing_embeddings=new_message_embeddings,
+            metadata=metadata
+        )
+        
+        return [{
+            "id": memory_id,
+            "memory": parsed_messages,
+            "event": "ADD"
+        }]
+
+class Knowledge:
+    def __init__(self, config=None, verbose=None):
+        self._config = config
+        self._verbose = verbose or 0
+        os.environ['ANONYMIZED_TELEMETRY'] = 'False'  # Chromadb
+        
+        # Configure logging levels based on verbose setting
+        if not self._verbose:
+            # Suppress logs from all relevant dependencies
+            for logger_name in [
+                'mem0', 
+                'chromadb', 
+                'local_persistent_hnsw',
+                '_client',
+                'main'
+            ]:
+                logging.getLogger(logger_name).setLevel(logging.WARNING)
+            
+            # Disable OpenAI API request logging
+            logging.getLogger('openai').setLevel(logging.WARNING)
+            
+            # Set root logger to warning to catch any uncategorized logs
+            logging.getLogger().setLevel(logging.WARNING)
+
+    @cached_property
+    def _deps(self):
+        try:
+            from markitdown import MarkItDown
+            import chromadb
+            return {
+                'chromadb': chromadb,
+                'markdown': MarkItDown()
+            }
+        except ImportError:
+            raise ImportError(
+                "Required packages not installed. Please install using: "
+                'pip install "praisonaiagents[knowledge]"'
+            )
+
+    @cached_property
+    def config(self):
+        # Generate unique collection name for each instance
+        collection_name = f"test_{int(time.time())}_{str(uuid.uuid4())[:8]}"
+        persist_dir = ".praison"
+
+        # Create persistent client config
+        base_config = {
+            "vector_store": {
+                "provider": "chroma",
+                "config": {
+                    "collection_name": collection_name,
+                    "path": persist_dir,
+                    "client": self._deps['chromadb'].PersistentClient(path=persist_dir)
+                }
+            },
+            "version": "v1.1",
+            "custom_prompt": "Return {{\"facts\": [text]}} where text is the exact input provided and json response"
+        }
+
+        # If config is provided, merge it with base config
+        if self._config:
+            if "vector_store" in self._config and "config" in self._config["vector_store"]:
+                config_copy = self._config["vector_store"]["config"].copy()
+                for key in ["collection_name", "client"]:
+                    if key in config_copy:
+                        del config_copy[key]
+                base_config["vector_store"]["config"].update(config_copy)
+
+        return base_config
+
+    @cached_property
+    def memory(self):
+        try:
+            return CustomMemory.from_config(self.config)
+        except (NotImplementedError, ValueError) as e:
+            if "list_collections" in str(e) or "Extra fields not allowed" in str(e):
+                # Keep only allowed fields
+                vector_store_config = {
+                    "collection_name": self.config["vector_store"]["config"]["collection_name"],
+                    "path": self.config["vector_store"]["config"]["path"]
+                }
+                self.config["vector_store"]["config"] = vector_store_config
+                from mem0 import Memory
+                return Memory.from_config(self.config)
+            raise
+
+    @cached_property
+    def markdown(self):
+        return self._deps['markdown']
+
+    @cached_property
+    def chunker(self):
+        return Chunking(
+            chunker_type='recursive',
+            chunk_size=512,
+            chunk_overlap=50
+        )
+
+    def _log(self, message, level=2):
+        """Internal logging helper"""
+        if self._verbose and self._verbose >= level:
+            logger.info(message)
+
+    def store(self, content, user_id=None, agent_id=None, run_id=None, metadata=None):
+        """Store a memory."""
+        try:
+            if isinstance(content, str):
+                if any(content.lower().endswith(ext) for ext in ['.pdf', '.doc', '.docx', '.txt']):
+                    self._log(f"Content appears to be a file path, processing file: {content}")
+                    return self.add(content, user_id=user_id, agent_id=agent_id, run_id=run_id, metadata=metadata)
+                
+                content = content.strip()
+                if not content:
+                    return []
+                
+            result = self.memory.add(content, user_id=user_id, agent_id=agent_id, run_id=run_id, metadata=metadata)
+            self._log(f"Store operation result: {result}")
+            return result
+        except Exception as e:
+            logger.error(f"Error storing content: {str(e)}")
+            return []
+
+    def get_all(self, user_id=None, agent_id=None, run_id=None):
+        """Retrieve all memories."""
+        return self.memory.get_all(user_id=user_id, agent_id=agent_id, run_id=run_id)
+
+    def get(self, memory_id):
+        """Retrieve a specific memory by ID."""
+        return self.memory.get(memory_id)
+
+    def search(self, query, user_id=None, agent_id=None, run_id=None):
+        """Search for memories related to a query."""
+        return self.memory.search(query, user_id=user_id, agent_id=agent_id, run_id=run_id)
+
+    def update(self, memory_id, data):
+        """Update a memory."""
+        return self.memory.update(memory_id, data)
+
+    def history(self, memory_id):
+        """Get the history of changes for a memory."""
+        return self.memory.history(memory_id)
+
+    def delete(self, memory_id):
+        """Delete a memory."""
+        self.memory.delete(memory_id)
+
+    def delete_all(self, user_id=None, agent_id=None, run_id=None):
+        """Delete all memories."""
+        self.memory.delete_all(user_id=user_id, agent_id=agent_id, run_id=run_id)
+
+    def reset(self):
+        """Reset all memories."""
+        self.memory.reset()
+
+    def normalize_content(self, content):
+        """Normalize content for consistent storage."""
+        # Example normalization: strip whitespace, convert to lowercase
+        return content.strip().lower()
+
+    def add(self, file_path, user_id=None, agent_id=None, run_id=None, metadata=None):
+        """Read file content and store it in memory.
+        
+        Args:
+            file_path: Can be:
+                - A string path to local file
+                - A URL string
+                - A list containing file paths and/or URLs
+        """
+        if isinstance(file_path, (list, tuple)):
+            results = []
+            for path in file_path:
+                result = self._process_single_input(path, user_id, agent_id, run_id, metadata)
+                results.extend(result.get('results', []))
+            return {'results': results, 'relations': []}
+        
+        return self._process_single_input(file_path, user_id, agent_id, run_id, metadata)
+
+    def _process_single_input(self, input_path, user_id=None, agent_id=None, run_id=None, metadata=None):
+        """Process a single input which can be a file path or URL."""
+        try:
+            # Define supported file extensions
+            DOCUMENT_EXTENSIONS = {
+                'document': ('.pdf', '.ppt', '.pptx', '.doc', '.docx', '.xls', '.xlsx'),
+                'media': ('.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.mp3', '.wav', '.ogg', '.m4a'),
+                'text': ('.txt', '.csv', '.json', '.xml', '.md', '.html', '.htm'),
+                'archive': '.zip'
+            }
+
+            # Check if input is URL
+            if isinstance(input_path, str) and (input_path.startswith('http://') or input_path.startswith('https://')):
+                self._log(f"Processing URL: {input_path}")
+                raise NotImplementedError("URL processing not yet implemented")
+
+            # Check if input ends with any supported extension
+            is_supported_file = any(input_path.lower().endswith(ext) 
+                                  for exts in DOCUMENT_EXTENSIONS.values()
+                                  for ext in (exts if isinstance(exts, tuple) else (exts,)))
+            
+            if is_supported_file:
+                self._log(f"Processing as file path: {input_path}")
+                if not os.path.exists(input_path):
+                    logger.error(f"File not found: {input_path}")
+                    raise FileNotFoundError(f"File not found: {input_path}")
+                
+                file_ext = '.' + input_path.lower().split('.')[-1]  # Get extension reliably
+                
+                # Process file based on type
+                if file_ext in DOCUMENT_EXTENSIONS['text']:
+                    with open(input_path, 'r', encoding='utf-8') as file:
+                        content = file.read().strip()
+                    if not content:
+                        raise ValueError("Empty text file")
+                    memories = [self.normalize_content(content)]
+                else:
+                    # Use MarkItDown for documents and media
+                    result = self.markdown.convert(input_path)
+                    content = result.text_content
+                    if not content:
+                        raise ValueError("No content could be extracted from file")
+                    chunks = self.chunker.chunk(content)
+                    memories = [chunk.text.strip() if hasattr(chunk, 'text') else str(chunk).strip() 
+                              for chunk in chunks if chunk]
+
+                # Set metadata for file
+                if not metadata:
+                    metadata = {}
+                metadata['file_type'] = file_ext.lstrip('.')
+                metadata['filename'] = os.path.basename(input_path)
+            else:
+                # Treat as raw text content only if no file extension
+                memories = [self.normalize_content(input_path)]
+
+            # Create progress display
+            progress = Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TaskProgressColumn(),
+                transient=True
+            )
+
+            # Store memories with progress bar
+            all_results = []
+            with progress:
+                store_task = progress.add_task(f"Adding to Knowledge from {os.path.basename(input_path)}", total=len(memories))
+                for memory in memories:
+                    if memory:
+                        memory_result = self.store(memory, user_id=user_id, agent_id=agent_id, 
+                                                 run_id=run_id, metadata=metadata)
+                        if memory_result:
+                            all_results.extend(memory_result.get('results', []))
+                        progress.advance(store_task)
+
+            return {'results': all_results, 'relations': []}
+
+        except Exception as e:
+            logger.error(f"Error processing input {input_path}: {str(e)}", exc_info=True)
+            raise

agents/praisonaiagents/process/process.py

@@ -10,14 +10,16 @@ class LoopItems(BaseModel):
     items: List[Any]
 
 class Process:
-    def __init__(self, tasks: Dict[str, Task], agents: List[Agent], manager_llm: Optional[str] = None, verbose: bool = False):
+    def __init__(self, tasks: Dict[str, Task], agents: List[Agent], manager_llm: Optional[str] = None, verbose: bool = False, max_iter: int = 10):
         self.tasks = tasks
         self.agents = agents
         self.manager_llm = manager_llm
         self.verbose = verbose
+        self.max_iter = max_iter
 
     async def aworkflow(self) -> AsyncGenerator[str, None]:
         """Async version of workflow method"""
+        current_iter = 0  # Track how many times we've looped
         # Build workflow relationships first
         for task in self.tasks.values():
             if task.next_tasks:
@@ -41,7 +43,12 @@ class Process:
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
         
-        while current_task and current_task.id not in visited_tasks:
+        while current_task:
+            current_iter += 1
+            if current_iter > self.max_iter:
+                logging.info(f"Max iteration limit {self.max_iter} reached, ending workflow.")
+                break
+
             task_id = current_task.id
             logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
             
@@ -111,6 +118,11 @@ Return a JSON object with an 'items' array containing the items to process.
             yield task_id
             visited_tasks.add(task_id)
             
+            # Reset completed task to "not started" so it can run again
+            if self.tasks[task_id].status == "completed":
+                logging.debug(f"Task {task_id} was completed, resetting to 'not started' for next iteration.")
+                self.tasks[task_id].status = "not started"
+            
             # Handle loop progression
             if current_task.task_type == "loop":
                 loop_key = f"loop_{current_task.name}"
@@ -130,22 +142,28 @@ Return a JSON object with an 'items' array containing the items to process.
                     
             # Determine next task based on result
             next_task = None
-            if current_task.result:
+            if current_task and current_task.result:
                 if current_task.task_type in ["decision", "loop"]:
                     result = current_task.result.raw.lower()
                     # Check conditions
                     for condition, tasks in current_task.condition.items():
-                        if condition.lower() in result and tasks:
-                            next_task_name = tasks[0]
+                        if condition.lower() in result:
+                            # Handle both list and direct string values
+                            task_value = tasks[0] if isinstance(tasks, list) else tasks
+                            if not task_value or task_value == "exit":  # If empty or explicit exit
+                                logging.info("Workflow exit condition met, ending workflow")
+                                current_task = None
+                                break
+                            next_task_name = task_value
                             next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
                             # For loops, allow revisiting the same task
                             if next_task and next_task.id == current_task.id:
                                 visited_tasks.discard(current_task.id)
                             break
             
-                if not next_task and current_task.next_tasks:
-                    next_task_name = current_task.next_tasks[0]
-                    next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+            if not next_task and current_task and current_task.next_tasks:
+                next_task_name = current_task.next_tasks[0]
+                next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
             
             current_task = next_task
             if not current_task:
@@ -285,6 +303,7 @@ Provide a JSON with the structure:
 
     def workflow(self):
         """Synchronous version of workflow method"""
+        current_iter = 0  # Track how many times we've looped
         # Build workflow relationships first
         for task in self.tasks.values():
             if task.next_tasks:
@@ -308,7 +327,12 @@ Provide a JSON with the structure:
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
         
-        while current_task and current_task.id not in visited_tasks:
+        while current_task:
+            current_iter += 1
+            if current_iter > self.max_iter:
+                logging.info(f"Max iteration limit {self.max_iter} reached, ending workflow.")
+                break
+
             task_id = current_task.id
             logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
             
@@ -372,6 +396,11 @@ Return a JSON object with an 'items' array containing the items to process.
             yield task_id
             visited_tasks.add(task_id)
             
+            # Reset completed task to "not started" so it can run again
+            if self.tasks[task_id].status == "completed":
+                logging.debug(f"Task {task_id} was completed, resetting to 'not started' for next iteration.")
+                self.tasks[task_id].status = "not started"
+            
             # Handle loop progression
             if current_task.task_type == "loop":
                 loop_key = f"loop_{current_task.name}"
@@ -391,22 +420,28 @@ Return a JSON object with an 'items' array containing the items to process.
                     
             # Determine next task based on result
             next_task = None
-            if current_task.result:
+            if current_task and current_task.result:
                 if current_task.task_type in ["decision", "loop"]:
                     result = current_task.result.raw.lower()
                     # Check conditions
                     for condition, tasks in current_task.condition.items():
-                        if condition.lower() in result and tasks:
-                            next_task_name = tasks[0]
+                        if condition.lower() in result:
+                            # Handle both list and direct string values
+                            task_value = tasks[0] if isinstance(tasks, list) else tasks
+                            if not task_value or task_value == "exit":  # If empty or explicit exit
+                                logging.info("Workflow exit condition met, ending workflow")
+                                current_task = None
+                                break
+                            next_task_name = task_value
                             next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
                             # For loops, allow revisiting the same task
                             if next_task and next_task.id == current_task.id:
                                 visited_tasks.discard(current_task.id)
                             break
             
-                if not next_task and current_task.next_tasks:
-                    next_task_name = current_task.next_tasks[0]
-                    next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+            if not next_task and current_task and current_task.next_tasks:
+                next_task_name = current_task.next_tasks[0]
+                next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
             
             current_task = next_task
             if not current_task:

agents/praisonaiagents/tools/pandas_tools.py

@@ -160,6 +160,9 @@ class PandasTools:
             Dict: Summary statistics and information
         """
         try:
+            if not isinstance(df, pd.DataFrame):
+                raise TypeError(f"Expected pandas DataFrame, got {type(df).__name__}")
+                
             numeric_summary = df.describe().to_dict()
             # Convert numpy types to native Python types
             for col in numeric_summary:

agents/praisonaiagents/tools/yfinance_tools.py

@@ -145,7 +145,15 @@ class YFinanceTools:
                 return [{"error": "yfinance package not available"}]
 
             hist = ticker.history(period=period, interval=interval, start=start, end=end)
-            return hist.reset_index().to_dict('records')
+            data = hist.reset_index().to_dict('records')
+            
+            # Convert timestamps to ISO format strings
+            for record in data:
+                if 'Date' in record and hasattr(record['Date'], 'isoformat'):
+                    record['Date'] = record['Date'].isoformat()
+                if 'Datetime' in record and hasattr(record['Datetime'], 'isoformat'):
+                    record['Datetime'] = record['Datetime'].isoformat()
+            return data
         except Exception as e:
             error_msg = f"Error fetching historical data: {str(e)}"
             logging.error(error_msg)

agents/programming-agent.py

@@ -0,0 +1,19 @@
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import execute_code, analyze_code, format_code, lint_code, disassemble_code # Code Tools
+from praisonaiagents.tools import execute_command, list_processes, kill_process, get_system_info # Shell Tools
+from praisonaiagents.tools import duckduckgo # Web Search Tool
+
+agent = Agent(
+    instructions="You are a Programming Agent", self_reflect=True, min_reflect=5, max_reflect=10, 
+    tools=[execute_code, analyze_code, format_code, lint_code, disassemble_code, execute_command, list_processes, kill_process, get_system_info, duckduckgo]
+)
+agent.start(
+    "Write a python script using yfinance to find the stock price of Tesla"
+    "First check if required packages are installed"
+    "Run it using execute_code"
+    "execute_command if you want to run any terminal command"
+    "search internet using duckduckgo if you want to know update python package information"
+    "Analyse the output using analyze_code and fix error if required"
+    "if no package is installed, install it"
+    "then run the code"
+)

agents/prompt_chaining copy.py

@@ -0,0 +1,91 @@
+from praisonaiagents.agent import Agent
+from praisonaiagents.task import Task
+from praisonaiagents.agents import PraisonAIAgents
+from typing import List, Dict
+import time
+
+def get_time_check():
+    current_time = int(time.time())
+    result = "even" if current_time % 2 == 0 else "odd"
+    print(f"Time check: {current_time} is {result}")
+    return result
+
+def create_prompt_chain():
+    # Create agents for each step in the chain
+    agent1 = Agent(
+        name="Time Checker",
+        role="Time checker",
+        goal="Check if the time is even or odd",
+        instructions="Check if the time is even or odd",
+        tools=[get_time_check]
+    )
+
+    agent2 = Agent(
+        name="Advanced Analyzer",
+        role="Advanced data analyzer",
+        goal="Perform in-depth analysis of processed data",
+        instructions="Analyze the processed data in detail"
+    )
+
+    agent3 = Agent(
+        name="Final Processor",
+        role="Final data processor",
+        goal="Generate final output based on analysis",
+        instructions="Create final output based on analyzed data"
+    )
+
+    # Create tasks for each step
+    initial_task = Task(
+        name="time_check",
+        description="Getting time check and checking if it is even or odd",
+        expected_output="Getting time check and checking if it is even or odd",
+        agent=agent1,
+        is_start=True,  # Mark as the starting task
+        task_type="decision",  # This task will make a decision
+        next_tasks=["advanced_analysis"],  # Next task if condition passes
+        condition={
+            "even": ["advanced_analysis"],  # If passes, go to advanced analysis
+            "odd": ["final_processing"]  # If fails, exit the chain
+        }
+    )
+
+    analysis_task = Task(
+        name="advanced_analysis",
+        description="Perform advanced analysis on the processed data",
+        expected_output="Analyzed data ready for final processing",
+        agent=agent2,
+        next_tasks=["final_processing"]
+    )
+
+    final_task = Task(
+        name="final_processing",
+        description="Generate final output",
+        expected_output="Final processed result",
+        agent=agent3
+    )
+
+    # Create the workflow manager
+    workflow = PraisonAIAgents(
+        agents=[agent1, agent2, agent3],
+        tasks=[initial_task, analysis_task, final_task],
+        process="workflow",  # Use workflow process type
+        verbose=True
+    )
+
+    return workflow
+
+def main():
+    # Create and run the prompt chain
+    workflow = create_prompt_chain()
+    
+    # Run the workflow
+    results = workflow.start()
+    
+    # Print results
+    print("\nWorkflow Results:")
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"Task {task_id}: {result.raw}")
+
+if __name__ == "__main__":
+    main()

agents/prompt_chaining.py

@@ -0,0 +1,78 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import time
+
+def get_time_check():
+    current_time = int(time.time())
+    result = "even" if current_time % 2 == 0 else "odd"
+    print(f"Time check: {current_time} is {result}")
+    return result
+
+# Create agents for each step in the chain
+agent1 = Agent(
+    name="Time Checker",
+    role="Time checker",
+    goal="Check if the time is even or odd",
+    instructions="Check if the time is even or odd",
+    tools=[get_time_check]
+)
+
+agent2 = Agent(
+    name="Advanced Analyzer",
+    role="Advanced data analyzer",
+    goal="Perform in-depth analysis of processed data",
+    instructions="Analyze the processed data in detail"
+)
+
+agent3 = Agent(
+    name="Final Processor",
+    role="Final data processor",
+    goal="Generate final output based on analysis",
+    instructions="Create final output based on analyzed data"
+)
+
+# Create tasks for each step
+initial_task = Task(
+    name="time_check",
+    description="Getting time check and checking if it is even or odd",
+    expected_output="Getting time check and checking if it is even or odd",
+    agent=agent1,
+    is_start=True,  # Mark as the starting task
+    task_type="decision",  # This task will make a decision
+    next_tasks=["advanced_analysis"],  # Next task if condition passes
+    condition={
+        "even": ["advanced_analysis"],  # If passes, go to advanced analysis
+        "odd": "exit"  # If fails, exit the chain
+    }
+)
+
+analysis_task = Task(
+    name="advanced_analysis",
+    description="Perform advanced analysis on the processed data",
+    expected_output="Analyzed data ready for final processing",
+    agent=agent2,
+    next_tasks=["final_processing"]
+)
+
+final_task = Task(
+    name="final_processing",
+    description="Generate final output",
+    expected_output="Final processed result",
+    agent=agent3
+)
+
+# Create the workflow manager
+workflow = PraisonAIAgents(
+    agents=[agent1, agent2, agent3],
+    tasks=[initial_task, analysis_task, final_task],
+    process="workflow",  # Use workflow process type
+    verbose=True
+)
+
+# Run the workflow
+results = workflow.start()
+
+# Print results
+print("\nWorkflow Results:")
+for task_id, result in results["task_results"].items():
+    if result:
+        print(f"Task {task_id}: {result.raw}")

agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.31"
+version = "0.0.39"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 authors = [
     { name="Mervin Praison" }
@@ -17,5 +17,18 @@ dependencies = [
 
 [project.optional-dependencies]
 memory = [
-    "chromadb>=0.6.0"
-] 
+    "chromadb>=0.5.23"
+]
+
+knowledge = [
+    "mem0ai>=0.1.0",
+    "chromadb==0.5.23",
+    "markitdown",
+    "chonkie"
+]
+
+# Combined features
+all = [
+    "praisonaiagents[memory]",
+    "praisonaiagents[knowledge]"
+]

agents/recommendation-agent.py

@@ -0,0 +1,5 @@
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Recommendation Agent", tools=[duckduckgo])
+agent.start("Recommend me a good movie to watch in 2025")

agents/research-agent.py

@@ -0,0 +1,5 @@
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Research Agent", tools=[duckduckgo])
+agent.start("Research about AI 2024")

agents/routing copy.py

@@ -0,0 +1,82 @@
+from praisonaiagents.agent import Agent
+from praisonaiagents.task import Task
+from praisonaiagents.agents import PraisonAIAgents
+import time
+
+current_time = int(time.time())
+result = "even" if current_time % 2 == 0 else "odd"
+print(f"Time check: {current_time} is {result}")
+
+# Create specialized agents
+router = Agent(
+    name="Router",
+    role="Input Router",
+    goal="Evaluate input and determine routing path",
+    instructions="Analyze input and decide whether to proceed or exit",
+    tools=[get_time_check]
+)
+
+processor1 = Agent(
+    name="Processor 1",
+    role="Secondary Processor",
+    goal="Process valid inputs that passed initial check",
+    instructions="Process data that passed the routing check"
+)
+
+processor2 = Agent(
+    name="Processor 2",
+    role="Final Processor",
+    goal="Perform final processing on validated data",
+    instructions="Generate final output for processed data"
+)
+
+# Create tasks with routing logic
+routing_task = Task(
+    name="initial_routing",
+    description="check the time and return according to what is returned",
+    expected_output="pass or fail based on what is returned",
+    agent=router,
+    is_start=True,
+    task_type="decision",
+    condition={
+        "pass": ["process_valid"],
+        "fail": "exit"
+    }
+)
+
+processing_task = Task(
+    name="process_valid",
+    description="Process validated input",
+    expected_output="Processed data ready for final step",
+    agent=processor1,
+    next_tasks=["final_process"]
+)
+
+final_task = Task(
+    name="final_process",
+    description="Generate final output",
+    expected_output="Final processed result",
+    agent=processor2
+)
+
+# Create and run workflow
+workflow = PraisonAIAgents(
+    agents=[router, processor1, processor2],
+    tasks=[routing_task, processing_task, final_task],
+    process="workflow",
+    verbose=True
+)
+
+print("\nStarting Routing Workflow...")
+print("=" * 50)
+
+results = workflow.start()
+
+print("\nWorkflow Results:")
+print("=" * 50)
+for task_id, result in results["task_results"].items():
+    if result:
+        task_name = result.description
+        print(f"\nTask: {task_name}")
+        print(f"Result: {result.raw}")
+        print("-" * 50)

agents/routing.py

@@ -0,0 +1,83 @@
+from praisonaiagents.agent import Agent
+from praisonaiagents.task import Task
+from praisonaiagents.agents import PraisonAIAgents
+import time
+
+def get_time_check():
+    current_time = int(time.time())
+    result = "even" if current_time % 2 == 0 else "odd"
+    print(f"Time check: {current_time} is {result}")
+    return result
+
+# Create specialized agents
+router = Agent(
+    name="Router",
+    role="Input Router",
+    goal="Evaluate input and determine routing path",
+    instructions="Analyze input and decide whether to proceed or exit",
+    tools=[get_time_check]
+)
+
+processor1 = Agent(
+    name="Processor 1",
+    role="Secondary Processor",
+    goal="Process valid inputs that passed initial check",
+    instructions="Process data that passed the routing check"
+)
+
+processor2 = Agent(
+    name="Processor 2",
+    role="Final Processor",
+    goal="Perform final processing on validated data",
+    instructions="Generate final output for processed data"
+)
+
+# Create tasks with routing logic
+routing_task = Task(
+    name="initial_routing",
+    description="check the time and return according to what is returned",
+    expected_output="pass or fail based on what is returned",
+    agent=router,
+    is_start=True,
+    task_type="decision",
+    condition={
+        "pass": ["process_valid"],
+        "fail": ["process_invalid"]
+    }
+)
+
+processing_task = Task(
+    name="process_valid",
+    description="Process validated input",
+    expected_output="Processed data ready for final step",
+    agent=processor1,
+)
+
+final_task = Task(
+    name="process_invalid",
+    description="Generate final output",
+    expected_output="Final processed result",
+    agent=processor2
+)
+
+# Create and run workflow
+workflow = PraisonAIAgents(
+    agents=[router, processor1, processor2],
+    tasks=[routing_task, processing_task, final_task],
+    process="workflow",
+    verbose=True
+)
+
+print("\nStarting Routing Workflow...")
+print("=" * 50)
+
+results = workflow.start()
+
+print("\nWorkflow Results:")
+print("=" * 50)
+for task_id, result in results["task_results"].items():
+    if result:
+        task_name = result.description
+        print(f"\nTask: {task_name}")
+        print(f"Result: {result.raw}")
+        print("-" * 50)

agents/sample.md

@@ -0,0 +1,5 @@
+# Sample Markdown
+## Section 1
+This is a test markdown file.
+## Section 2
+It contains some formatted text and sections.

agents/sample.txt

@@ -0,0 +1,3 @@
+This is a sample text file.
+It contains multiple lines.
+This is for testing purposes.

agents/shopping-agent.py

@@ -0,0 +1,5 @@
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Shopping Agent", tools=[duckduckgo])
+agent.start("I want to buy iPhone 16 Pro Max, check 5 stores and give me price in table")

agents/single-agent.py

@@ -0,0 +1,4 @@
+from praisonaiagents import Agent
+
+agent = Agent(instructions="You are a Markdown Agent, output in markdown format")
+agent.start("Write a blog post about AI")

agents/streamlit-agents.py

@@ -0,0 +1,21 @@
+import streamlit as st
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+st.title("AI Research Assistant")
+st.write("Enter your research query below to get started!")
+
+# Initialize the research agent
+agent = Agent(instructions="You are a Research Agent", tools=[duckduckgo])
+
+# Create the input field
+query = st.text_input("Research Query", placeholder="Enter your research topic...")
+
+# Add a search button
+if st.button("Search"):
+    if query:
+        with st.spinner("Researching..."):
+            result = agent.start(query)
+            st.write(result)
+    else:
+        st.warning("Please enter a research query")

agents/tesla-stock-price.csv

@@ -0,0 +1,758 @@
+"date","close","volume","open","high","low"
+"11:34","270.49","4,787,699","264.50","273.88","262.24"
+"2018/10/15","259.5900","6189026.0000","259.0600","263.2800","254.5367"
+"2018/10/12","258.7800","7189257.0000","261.0000","261.9900","252.0100"
+"2018/10/11","252.2300","8128184.0000","257.5300","262.2500","249.0300"
+"2018/10/10","256.8800","12781560.0000","264.6100","265.5100","247.7700"
+"2018/10/09","262.8000","12037780.0000","255.2500","266.7700","253.3000"
+"2018/10/08","250.5600","13371180.0000","264.5200","267.7599","249.0000"
+"2018/10/05","261.9500","17900710.0000","274.6500","274.8800","260.0000"
+"2018/10/04","281.8300","9638885.0000","293.9500","294.0000","277.6700"
+"2018/10/03","294.8000","7982272.0000","303.3300","304.6000","291.5700"
+"2018/10/02","301.0200","11699690.0000","313.9500","316.8400","299.1500"
+"2018/10/01","310.7000","21714210.0000","305.7700","311.4400","301.0500"
+"2018/09/28","264.7700","33597290.0000","270.2600","278.0000","260.5550"
+"2018/09/27","307.5200","7337760.0000","312.9000","314.9600","306.9100"
+"2018/09/26","309.5800","7835863.0000","301.9100","313.8900","301.1093"
+"2018/09/25","300.9900","4472287.0000","300.0000","304.6000","296.5000"
+"2018/09/24","299.6800","4834384.0000","298.4800","302.9993","293.5800"
+"2018/09/21","299.1000","5038497.0000","297.7000","300.5800","295.3700"
+"2018/09/20","298.3300","7332477.0000","303.5600","305.9800","293.3300"
+"2018/09/19","299.0200","8264353.0000","280.5100","300.0000","280.5000"
+"2018/09/18","284.9600","16494280.0000","296.6900","302.6400","275.5000"
+"2018/09/17","294.8400","6866208.0000","290.0400","300.8700","288.1300"
+"2018/09/14","295.2000","6757652.0000","288.7600","297.3256","286.5200"
+"2018/09/13","289.4600","6333281.0000","288.0200","295.0000","285.1800"
+"2018/09/12","290.5400","10002150.0000","281.4400","292.5000","278.6463"
+"2018/09/11","279.4400","9161061.0000","279.4700","282.0000","273.5500"
+"2018/09/10","285.5000","14232250.0000","273.2600","286.0300","271.0000"
+"2018/09/07","263.2400","22442310.0000","260.1000","268.3500","252.2548"
+"2018/09/06","280.9500","7472756.0000","284.8000","291.1700","278.8800"
+"2018/09/05","280.7400","7707342.0000","285.0500","286.7800","277.1800"
+"2018/09/04","288.9500","8304571.0000","296.9400","298.1900","288.0000"
+"2018/08/31","301.6600","5367048.0000","302.0000","305.3082","298.6000"
+"2018/08/30","303.1500","7210625.0000","302.2600","304.6000","297.7200"
+"2018/08/29","305.0100","7410538.0000","310.2700","311.8500","303.6900"
+"2018/08/28","311.8600","7639453.0000","318.4100","318.8800","311.1900"
+"2018/08/27","319.2700","13062650.0000","318.0000","322.4350","308.8100"
+"2018/08/24","322.8200","3592734.0000","320.7000","323.8500","319.4000"
+"2018/08/23","320.1000","5138685.0000","319.1400","327.3200","318.1000"
+"2018/08/22","321.6400","5935853.0000","320.8700","323.8800","314.6700"
+"2018/08/21","321.9000","13147770.0000","310.6100","324.7900","309.0000"
+"2018/08/20","308.4400","17380430.0000","291.7040","308.5000","288.2000"
+"2018/08/17","305.5000","18895880.0000","323.5000","326.7700","303.5300"
+"2018/08/16","335.4500","6045392.0000","339.9100","342.2800","333.8200"
+"2018/08/15","338.6900","9073033.0000","341.9060","344.4900","332.1400"
+"2018/08/14","347.6400","6948511.0000","358.4500","359.1995","347.1000"
+"2018/08/13","356.4100","10444920.0000","361.1300","363.1900","349.0200"
+"2018/08/10","355.4900","11530510.0000","354.0000","360.0000","346.0000"
+"2018/08/09","352.4500","16951800.0000","365.5500","367.0100","345.7300"
+"2018/08/08","370.3400","24535420.0000","369.0900","382.6400","367.1200"
+"2018/08/07","379.5700","30596400.0000","343.8400","387.4600","339.1501"
+"2018/08/06","341.9900","8536766.0000","345.4600","354.9800","341.8200"
+"2018/08/03","348.1700","13646640.0000","347.8100","355.0000","342.5300"
+"2018/08/02","349.5400","23159160.0000","328.4400","349.9900","323.1600"
+"2018/08/01","300.8400","8768099.0000","297.9900","303.0000","293.0000"
+"2018/07/31","298.1400","5055094.0000","292.2500","298.3200","289.0700"
+"2018/07/30","290.1700","6799581.0000","295.9000","296.1000","286.1300"
+"2018/07/27","297.1800","5694690.0000","307.2500","307.6933","295.3404"
+"2018/07/26","306.6500","4619567.0000","304.8500","310.7000","303.6411"
+"2018/07/25","308.7400","7031382.0000","296.7400","309.6200","294.5025"
+"2018/07/24","297.4300","9586186.0000","304.4209","307.7171","292.5452"
+"2018/07/23","303.2000","10974820.0000","301.8400","305.5000","292.8601"
+"2018/07/20","313.5800","5159831.0000","321.2300","323.2400","311.7093"
+"2018/07/19","320.2300","5907116.0000","316.3300","323.5400","314.0100"
+"2018/07/18","323.8500","5610085.0000","325.0000","325.5000","316.2500"
+"2018/07/17","322.6900","6987782.0000","308.8100","324.7400","308.5000"
+"2018/07/16","310.1000","7800454.0000","311.7100","315.1600","306.2500"
+"2018/07/13","318.8700","5866776.0000","315.5800","319.5849","309.2500"
+"2018/07/12","316.7100","5711851.0000","321.4300","323.2300","312.7700"
+"2018/07/11","318.9600","4878595.0000","315.8000","321.9400","315.0700"
+"2018/07/10","322.4700","9437557.0000","324.5600","327.6771","319.2000"
+"2018/07/09","318.5100","7579541.0000","311.9900","318.5200","308.0000"
+"2018/07/06","308.9000","8860198.0000","304.9550","312.0700","302.0000"
+"2018/07/05","309.1600","17457570.0000","313.7600","314.3900","296.2200"
+"2018/07/03","310.8600","12282640.0000","331.7500","332.4900","309.6900"
+"2018/07/02","335.0700","18732710.0000","360.0700","364.7800","329.8500"
+"2018/06/29","342.9500","6475903.0000","353.3300","353.8600","342.4100"
+"2018/06/28","349.9300","8388172.0000","348.6600","357.0200","346.1100"
+"2018/06/27","344.5000","8313817.0000","345.0000","350.7900","339.5000"
+"2018/06/26","342.0000","7434749.0000","336.0540","343.5500","325.7990"
+"2018/06/25","333.0100","6925089.0000","330.1200","338.4700","327.5000"
+"2018/06/22","333.6300","10253770.0000","351.5400","352.2500","332.0000"
+"2018/06/21","347.5100","7949846.0000","362.0000","366.2139","346.2700"
+"2018/06/20","362.2200","8370268.0000","358.0400","364.3800","352.0000"
+"2018/06/19","352.5500","12734840.0000","365.1600","370.0000","346.2500"
+"2018/06/18","370.8300","12025450.0000","355.4000","373.7300","354.5000"
+"2018/06/15","358.1700","10827560.0000","353.8400","364.6700","351.2500"
+"2018/06/14","357.7200","10961150.0000","347.6300","358.7500","346.6000"
+"2018/06/13","344.7800","9401467.0000","346.7060","347.2000","339.8000"
+"2018/06/12","342.7700","22256430.0000","344.7000","354.9700","338.0000"
+"2018/06/11","332.1000","13166050.0000","322.5100","334.6600","322.5000"
+"2018/06/08","317.6600","8192175.0000","319.0000","324.4800","317.1500"
+"2018/06/07","316.0900","14336110.0000","316.1500","330.0000","313.5800"
+"2018/06/06","319.5000","18742400.0000","300.5000","322.1700","297.4800"
+"2018/06/05","291.1300","5877873.0000","297.7000","297.8000","286.7400"
+"2018/06/04","296.7400","4793787.0000","294.3400","299.0000","293.5480"
+"2018/06/01","291.8200","5417984.0000","285.8600","291.9500","283.8390"
+"2018/05/31","284.7300","5912825.0000","287.2100","290.3700","282.9300"
+"2018/05/30","291.7200","7473590.0000","283.2900","295.0050","281.6000"
+"2018/05/29","283.7600","5657153.0000","278.5100","286.5000","276.1500"
+"2018/05/25","278.8500","3872621.0000","277.6250","279.6400","275.6100"
+"2018/05/24","277.8500","4170789.0000","278.4000","281.1100","274.8900"
+"2018/05/23","279.0700","5972237.0000","277.7600","279.9099","274.0000"
+"2018/05/22","275.0100","8938501.0000","287.7620","288.0000","273.4220"
+"2018/05/21","284.4900","9167844.0000","281.3300","291.4900","281.3000"
+"2018/05/18","276.8200","7243699.0000","284.6500","284.6500","274.0000"
+"2018/05/17","284.5400","4418258.0000","285.9000","289.1873","283.9700"
+"2018/05/16","286.4800","5669644.0000","283.8300","288.8100","281.5600"
+"2018/05/15","284.1800","9509753.0000","285.0100","286.9600","280.5000"
+"2018/05/14","291.9700","7265501.0000","303.3200","304.9400","291.6200"
+"2018/05/11","301.0600","4665321.0000","307.7000","308.8800","299.0800"
+"2018/05/10","305.0200","5642771.0000","307.4997","312.9900","304.1119"
+"2018/05/09","306.8500","5712255.0000","300.4100","307.0100","300.0500"
+"2018/05/08","301.9700","5927447.0000","300.7950","307.7500","299.0000"
+"2018/05/07","302.7700","8673090.0000","297.5000","305.9588","295.1700"
+"2018/05/04","294.0900","8565506.0000","283.0000","296.8600","279.5200"
+"2018/05/03","284.4500","17339090.0000","278.7900","288.0400","275.2300"
+"2018/05/02","301.1500","8346176.0000","298.5700","306.8500","297.7844"
+"2018/05/01","299.9200","4614946.0000","293.5100","300.8200","293.2200"
+"2018/04/30","293.9000","4224068.0000","293.6100","298.7300","292.5000"
+"2018/04/27","294.0750","4346854.0000","285.3700","294.4700","283.8300"
+"2018/04/26","285.4800","4348108.0000","278.7500","285.7900","276.5000"
+"2018/04/25","280.6900","4000421.0000","283.5000","285.1600","277.2500"
+"2018/04/24","283.4600","5678242.0000","285.0000","287.0900","278.4600"
+"2018/04/23","283.3700","4880743.0000","291.2900","291.6200","282.3300"
+"2018/04/20","290.2400","5622630.0000","295.1700","299.9800","289.7500"
+"2018/04/19","300.0800","6083800.0000","291.0800","301.0100","288.5500"
+"2018/04/18","293.3500","6531563.0000","291.0800","300.2400","288.1600"
+"2018/04/17","287.6900","6931152.0000","288.8700","292.1700","282.5100"
+"2018/04/16","291.2100","6289497.0000","299.0000","299.6600","289.0100"
+"2018/04/13","300.3400","7319225.0000","303.6000","303.9499","295.9800"
+"2018/04/12","294.0800","7595525.0000","302.3200","303.9500","293.6800"
+"2018/04/11","300.9300","7470204.0000","300.7400","308.9800","299.6600"
+"2018/04/10","304.7000","11017010.0000","298.9700","307.1000","293.6800"
+"2018/04/09","289.6600","10241410.0000","300.3700","309.5000","289.2100"
+"2018/04/06","299.3000","13516530.0000","301.0000","309.2800","295.5000"
+"2018/04/05","305.7200","19025860.0000","289.3400","306.2600","288.2000"
+"2018/04/04","286.9400","19880180.0000","252.7800","288.3700","252.0000"
+"2018/04/03","267.5300","18829650.0000","269.8200","273.3500","254.4900"
+"2018/04/02","252.4800","16093290.0000","256.2600","260.3318","244.5901"
+"2018/03/29","266.1300","15014440.0000","256.4900","270.9599","248.2100"
+"2018/03/28","257.7800","20962280.0000","264.5800","268.6800","252.1000"
+"2018/03/27","279.1800","13787060.0000","304.0000","304.2700","277.1800"
+"2018/03/26","304.1800","8364937.0000","307.3400","307.5900","291.3600"
+"2018/03/23","301.5400","6639960.0000","311.2500","311.6100","300.4500"
+"2018/03/22","309.1000","4924928.0000","313.8900","318.8200","308.1800"
+"2018/03/21","316.5300","5954247.0000","310.2500","322.4400","310.1900"
+"2018/03/20","310.5500","4761031.0000","314.8700","316.2500","308.7600"
+"2018/03/19","313.5600","7467890.0000","316.5000","320.7500","309.6700"
+"2018/03/16","321.3500","6113365.0000","325.9600","327.4000","319.0700"
+"2018/03/15","325.6000","6554568.0000","329.3800","332.8500","321.1000"
+"2018/03/14","326.6300","7952152.0000","336.7600","339.8100","323.9300"
+"2018/03/13","341.8400","5960636.0000","344.9200","345.1200","336.2635"
+"2018/03/12","345.5100","8252919.0000","328.6100","347.2100","326.5000"
+"2018/03/09","327.1700","5502779.0000","324.1000","328.4900","322.3700"
+"2018/03/08","329.1000","3514367.0000","332.8600","333.3000","326.2740"
+"2018/03/07","332.3000","5001940.0000","325.4400","332.5000","321.7400"
+"2018/03/06","328.2000","4236483.0000","333.7500","336.3700","327.0300"
+"2018/03/05","333.3500","3820702.0000","332.3900","337.7500","329.2929"
+"2018/03/02","335.1200","5088789.0000","326.9800","335.2200","322.9700"
+"2018/03/01","330.9300","6872552.0000","345.0100","348.6700","330.0700"
+"2018/02/28","343.0600","6066044.0000","352.5700","355.2400","342.2200"
+"2018/02/27","350.9900","4785022.0000","356.2500","359.9900","350.0100"
+"2018/02/26","357.4200","4334500.0000","353.5000","359.0000","352.3550"
+"2018/02/23","352.0500","5814177.0000","347.8300","354.9900","347.1000"
+"2018/02/22","346.1700","6961880.0000","335.5300","347.4400","334.7501"
+"2018/02/21","333.3000","3207250.0000","336.0300","339.6929","333.1700"
+"2018/02/20","334.7700","4005962.0000","334.4700","340.8400","331.5000"
+"2018/02/16","335.4900","5640184.0000","332.5000","343.1200","331.6400"
+"2018/02/15","334.0650","5909823.0000","324.5000","334.1200","322.4000"
+"2018/02/14","322.3100","3948077.0000","320.8400","326.1700","318.5200"
+"2018/02/13","323.6600","4554631.0000","315.0200","324.1900","312.5105"
+"2018/02/12","315.7300","6224479.0000","316.1300","318.0800","306.2500"
+"2018/02/09","310.4200","12924430.0000","319.9300","320.9845","294.7600"
+"2018/02/08","315.2300","10296420.0000","343.3100","348.6200","314.6000"
+"2018/02/07","345.0000","6729682.0000","338.9900","346.0000","335.6600"
+"2018/02/06","333.9700","5080032.0000","325.2100","336.2200","323.5000"
+"2018/02/05","333.1300","4441166.0000","337.9700","344.4700","333.0000"
+"2018/02/02","343.7500","3696157.0000","348.4400","351.9500","340.5100"
+"2018/02/01","349.2500","4187440.0000","351.0000","359.6600","348.6300"
+"2018/01/31","354.3100","6199373.0000","347.5100","356.1900","345.1900"
+"2018/01/30","345.8200","4710684.0000","345.1400","348.2700","342.1700"
+"2018/01/29","349.5300","4738208.0000","339.8500","350.8500","338.2800"
+"2018/01/26","342.8500","4535457.0000","341.5000","344.0000","335.7100"
+"2018/01/25","337.6400","6725208.0000","348.2700","349.2000","336.4000"
+"2018/01/24","345.8900","5277386.0000","354.5800","354.7500","343.5200"
+"2018/01/23","352.7900","5447622.0000","360.0000","360.5000","351.0000"
+"2018/01/22","351.5600","6199777.0000","349.4000","357.8300","349.2000"
+"2018/01/19","350.0200","4871181.0000","345.0000","350.5899","342.6000"
+"2018/01/18","344.5700","5679629.0000","345.6700","352.3000","343.7400"
+"2018/01/17","347.1600","7092554.0000","340.4700","349.0000","339.7500"
+"2018/01/16","340.0600","6429234.0000","337.5400","345.0000","334.8000"
+"2018/01/12","336.2200","4822509.0000","338.6300","340.4100","333.6700"
+"2018/01/11","337.9500","6640863.0000","335.2400","344.8099","333.2600"
+"2018/01/10","334.8000","4303053.0000","332.2000","337.0000","330.0000"
+"2018/01/09","333.6900","7134525.0000","335.1600","338.8000","327.4050"
+"2018/01/08","336.4100","9832610.0000","316.0000","337.0199","315.5000"
+"2018/01/05","316.5800","4588728.0000","316.6200","317.2400","312.0000"
+"2018/01/04","314.6200","9944593.0000","312.8700","318.5500","305.6800"
+"2018/01/03","317.2500","4438520.0000","321.0000","325.2500","315.5500"
+"2018/01/02","320.5300","4345615.0000","312.0000","322.1099","311.0000"
+"2017/12/29","311.3500","3769504.0000","316.1800","316.4100","310.0000"
+"2017/12/28","315.3600","4306746.0000","311.7500","315.8200","309.5400"
+"2017/12/27","311.6400","4705084.0000","316.0000","317.6800","310.7500"
+"2017/12/26","317.2900","4368699.0000","323.8300","323.9400","316.5800"
+"2017/12/22","325.2000","4207602.0000","329.5100","330.9214","324.8200"
+"2017/12/21","331.6600","4369994.0000","329.5900","333.7400","327.2100"
+"2017/12/20","328.9800","5907378.0000","332.6900","333.1000","325.0400"
+"2017/12/19","331.1000","6820868.0000","340.2600","341.4925","330.3000"
+"2017/12/18","338.8700","5466546.0000","344.9000","346.7300","337.5800"
+"2017/12/15","343.4500","6921246.0000","342.0400","343.9000","335.7600"
+"2017/12/14","337.8900","5792024.0000","341.0100","347.4400","336.9000"
+"2017/12/13","339.0300","6217701.0000","340.9300","344.2200","336.5000"
+"2017/12/12","341.0300","8715570.0000","330.4500","341.4400","330.0300"
+"2017/12/11","328.9100","7926090.0000","314.6300","329.0100","313.7500"
+"2017/12/08","315.1300","3466088.0000","314.6000","316.9800","311.2600"
+"2017/12/07","311.2400","4779590.0000","312.0000","318.6341","311.0500"
+"2017/12/06","313.2600","7184477.0000","300.1000","313.3900","300.0000"
+"2017/12/05","303.7000","4643708.0000","302.0000","308.0000","301.0000"
+"2017/12/04","305.2000","5834227.0000","306.5000","308.2650","300.6100"
+"2017/12/01","306.5300","4286082.0000","305.4400","310.3200","305.0500"
+"2017/11/30","308.8500","4345434.0000","308.5600","310.7000","304.5400"
+"2017/11/29","307.5400","8757463.0000","317.3000","318.0000","301.2300"
+"2017/11/28","317.5500","4941703.0000","316.3600","320.0000","313.9200"
+"2017/11/27","316.8100","4537779.0000","313.2500","317.3400","309.5100"
+"2017/11/24","315.5500","3244065.0000","313.7900","316.4100","311.0000"
+"2017/11/22","312.6000","4913283.0000","316.7700","317.4200","311.8400"
+"2017/11/21","317.8100","7256381.0000","310.8600","318.2300","308.7100"
+"2017/11/20","308.7400","8241821.0000","313.7900","315.5000","304.7500"
+"2017/11/17","315.0500","13720830.0000","325.6700","326.6700","313.1500"
+"2017/11/16","312.5000","5794409.0000","313.9900","318.1400","311.3000"
+"2017/11/15","311.3000","5951835.0000","306.0100","312.4900","301.5000"
+"2017/11/14","308.7000","5661904.0000","315.0000","316.3500","306.9000"
+"2017/11/13","315.4000","7565242.0000","300.1300","316.8000","299.1100"
+"2017/11/10","302.9900","4621080.0000","302.5000","308.3600","301.8500"
+"2017/11/09","302.9900","5440173.0000","302.5000","304.4600","296.3000"
+"2017/11/08","304.3900","4725355.0000","305.5000","306.8900","301.3001"
+"2017/11/07","306.0500","5284844.0000","301.0200","306.5000","300.0300"
+"2017/11/06","302.7800","6480689.0000","307.0000","307.5000","299.0100"
+"2017/11/03","306.0900","8885933.0000","299.5000","306.2500","295.1300"
+"2017/11/02","299.2600","19771280.0000","300.1300","308.6900","292.6300"
+"2017/11/01","321.0800","8242487.0000","332.2500","332.6089","320.2600"
+"2017/10/31","331.5300","5650062.0000","320.2300","331.9500","320.1800"
+"2017/10/30","320.0800","4247619.0000","319.1800","323.7800","317.2500"
+"2017/10/27","320.8700","6968365.0000","319.7500","324.5900","316.6600"
+"2017/10/26","326.1700","5010087.0000","327.7800","330.2300","323.2000"
+"2017/10/25","325.8400","8583619.0000","336.7000","337.5000","323.5600"
+"2017/10/24","337.3400","4485692.0000","338.8000","342.8000","336.1600"
+"2017/10/23","337.0200","5739598.0000","349.8800","349.9500","336.2500"
+"2017/10/20","345.1000","4925657.0000","352.6900","354.5500","344.3400"
+"2017/10/19","351.8100","5055715.0000","355.5600","357.1465","348.2000"
+"2017/10/18","359.6500","4936024.0000","355.9700","363.0000","354.1300"
+"2017/10/17","355.7500","3290290.0000","350.9100","356.2200","350.0700"
+"2017/10/16","350.6000","5373090.0000","353.7600","354.4800","347.1600"
+"2017/10/13","355.5700","3538807.0000","356.9800","358.4900","353.6800"
+"2017/10/12","355.6800","4073552.0000","352.9500","359.7800","352.6400"
+"2017/10/11","354.6000","4494733.0000","353.8900","357.6000","351.1500"
+"2017/10/10","355.5900","6972263.0000","346.8000","355.6300","345.5305"
+"2017/10/09","342.9400","7461461.0000","349.6500","351.7500","342.6700"
+"2017/10/06","356.8800","4272866.0000","353.1000","360.0992","352.2500"
+"2017/10/05","355.3300","4167913.0000","356.0000","357.4350","351.3500"
+"2017/10/04","355.0100","8147995.0000","351.2500","358.6200","349.6000"
+"2017/10/03","348.1400","10122550.0000","335.9000","348.5500","331.2800"
+"2017/10/02","341.5300","5227547.0000","342.5200","343.7000","335.5100"
+"2017/09/29","341.1000","5099051.0000","341.8600","344.6800","338.6010"
+"2017/09/28","339.6000","5309779.0000","339.8800","342.7500","335.4000"
+"2017/09/27","340.9700","6027375.0000","349.9000","351.4890","340.5000"
+"2017/09/26","345.2500","7149649.0000","350.9300","351.2400","340.9000"
+"2017/09/25","344.9900","7587158.0000","353.1500","357.4690","342.8800"
+"2017/09/22","351.0900","8142895.0000","366.4900","369.8999","350.8800"
+"2017/09/21","366.4800","4610872.0000","374.9000","376.8300","364.5100"
+"2017/09/20","373.9100","4909958.0000","373.0000","378.2490","371.0700"
+"2017/09/19","375.1000","6435208.0000","380.0000","382.3900","373.5700"
+"2017/09/18","385.0000","7177773.0000","380.2500","389.6100","377.6800"
+"2017/09/15","379.8100","5407227.0000","374.5100","380.0000","372.7000"
+"2017/09/14","377.6400","7170263.0000","364.3300","377.9600","362.6300"
+"2017/09/13","366.2300","4171185.0000","363.8200","368.0700","359.5900"
+"2017/09/12","362.7500","5966204.0000","364.4900","368.7600","360.4000"
+"2017/09/11","363.6900","7651000.0000","351.3500","363.7100","350.0000"
+"2017/09/08","343.4000","3261333.0000","348.9900","349.7800","342.3000"
+"2017/09/07","350.6100","4235045.0000","345.9800","352.4800","343.4500"
+"2017/09/06","344.5300","4082001.0000","349.5000","350.9790","341.5600"
+"2017/09/05","349.5900","3836402.0000","353.8000","355.4900","345.8900"
+"2017/09/01","355.4000","3048550.0000","356.1200","357.5900","353.6902"
+"2017/08/31","355.9000","4063330.0000","353.5500","358.4400","352.8200"
+"2017/08/30","353.1800","3404165.0000","349.6700","353.4700","347.0000"
+"2017/08/29","347.3600","4069303.0000","339.4800","349.0500","338.7500"
+"2017/08/28","345.6600","3746240.0000","347.2800","347.3500","339.7200"
+"2017/08/25","348.0500","3475186.0000","354.2400","355.6900","347.3000"
+"2017/08/24","352.9300","4571574.0000","352.5200","356.6600","349.7400"
+"2017/08/23","352.7700","4941947.0000","338.9900","353.4900","338.3041"
+"2017/08/22","341.3500","4314268.0000","341.1300","342.2400","337.3725"
+"2017/08/21","337.8600","6489850.0000","345.8200","345.8200","331.8500"
+"2017/08/18","347.4600","5390805.0000","352.9100","354.0000","345.8000"
+"2017/08/17","351.9200","5010825.0000","361.2100","363.3000","351.5900"
+"2017/08/16","362.9100","3406173.0000","363.0000","366.5000","362.5200"
+"2017/08/15","362.3300","3084601.0000","365.2000","365.4900","359.3700"
+"2017/08/14","363.8000","4507969.0000","364.6300","367.6600","362.6000"
+"2017/08/11","357.8700","4357562.0000","356.9700","361.2600","353.6200"
+"2017/08/10","355.4000","7063054.0000","361.6000","366.6504","354.6600"
+"2017/08/09","363.5300","6881182.0000","361.0000","370.0000","358.9500"
+"2017/08/08","365.2200","7431838.0000","357.5300","368.5800","357.4000"
+"2017/08/07","355.1700","6309331.0000","357.3500","359.4800","352.7500"
+"2017/08/04","356.9100","9233295.0000","347.0000","357.2700","343.3000"
+"2017/08/03","347.0900","13524270.0000","345.3300","350.0000","343.1500"
+"2017/08/02","325.8900","11942350.0000","318.9400","327.1200","311.2200"
+"2017/08/01","319.5700","8284997.0000","323.0000","324.4500","316.1300"
+"2017/07/31","323.4700","8525454.0000","335.5000","341.4900","321.0400"
+"2017/07/28","335.0700","4869891.0000","336.8900","339.6000","332.5100"
+"2017/07/27","334.4600","8285879.0000","346.0000","347.5000","326.2900"
+"2017/07/26","343.8500","4809514.0000","340.3600","345.5000","338.1200"
+"2017/07/25","339.6000","6977932.0000","345.0000","345.6000","334.1500"
+"2017/07/24","342.5200","8598292.0000","330.2400","343.3990","330.0100"
+"2017/07/21","328.4000","4871708.0000","329.4600","331.2575","325.8000"
+"2017/07/20","329.9200","5142516.0000","326.9000","330.2200","324.2000"
+"2017/07/19","325.2600","6345884.0000","328.2300","331.6500","323.2193"
+"2017/07/18","328.2400","6360710.0000","317.5000","329.1300","315.6600"
+"2017/07/17","319.5700","9827506.0000","325.5400","327.1000","313.4500"
+"2017/07/14","327.7800","5607924.0000","323.1900","328.4200","321.2200"
+"2017/07/13","323.4100","8582315.0000","330.1100","331.6000","319.9700"
+"2017/07/12","329.5200","10317240.0000","330.4000","333.1000","324.5000"
+"2017/07/11","327.2200","11526760.0000","316.0000","327.2800","314.3000"
+"2017/07/10","316.0500","13760290.0000","312.9000","317.9400","303.1300"
+"2017/07/07","313.2200","14129950.0000","313.5000","317.0000","307.3800"
+"2017/07/06","308.8300","19258040.0000","317.2600","320.7899","306.3000"
+"2017/07/05","327.0900","16998300.0000","347.2000","347.2400","326.3300"
+"2017/07/03","352.6200","6305401.0000","370.2400","371.3500","351.5000"
+"2017/06/30","361.6100","5823046.0000","363.7100","366.7674","359.6187"
+"2017/06/29","360.7500","8202463.0000","370.6100","371.0000","354.1000"
+"2017/06/28","371.2400","6290323.0000","366.6800","371.7400","362.5200"
+"2017/06/27","362.3700","6977494.0000","376.4000","376.4000","362.0200"
+"2017/06/26","377.4900","6596854.0000","386.6900","386.9500","373.1000"
+"2017/06/23","383.4500","6425180.0000","382.4500","386.9900","379.3450"
+"2017/06/22","382.6100","7510406.0000","377.9900","385.0000","373.5700"
+"2017/06/21","376.4000","4916770.0000","374.3500","376.9900","368.0200"
+"2017/06/20","372.2400","7419110.0000","376.6700","378.8800","369.7300"
+"2017/06/19","369.8000","6433434.0000","375.0000","376.7000","367.8000"
+"2017/06/16","371.4000","6347450.0000","377.9750","378.0100","370.1000"
+"2017/06/15","375.3400","10412650.0000","372.5000","375.4600","366.4900"
+"2017/06/14","380.6600","12778480.0000","381.0850","384.2500","376.3100"
+"2017/06/13","375.9500","11773370.0000","367.6200","376.0000","366.6100"
+"2017/06/12","359.0100","10507860.0000","357.9900","364.5000","350.6200"
+"2017/06/09","357.3200","17250060.0000","374.4200","376.8700","354.8000"
+"2017/06/08","370.0000","9028677.0000","363.7500","371.9000","360.2200"
+"2017/06/07","359.6500","9348692.0000","356.3400","360.5000","355.1400"
+"2017/06/06","352.8500","11031920.0000","344.7000","359.4929","339.9700"
+"2017/06/05","347.3200","6769174.0000","338.5000","348.4400","334.2100"
+"2017/06/02","339.8500","5583952.0000","339.7700","342.8800","335.9300"
+"2017/06/01","340.3700","7601764.0000","344.0000","344.8800","337.2900"
+"2017/05/31","341.0100","9937556.0000","337.6900","342.8900","335.1600"
+"2017/05/30","335.1000","7771536.0000","326.0000","336.2800","325.7600"
+"2017/05/26","325.1400","7793009.0000","317.2800","325.4900","316.3100"
+"2017/05/25","316.8300","5000432.0000","311.0200","316.9700","307.8100"
+"2017/05/24","310.2200","5035192.0000","306.5100","311.0000","305.4000"
+"2017/05/23","303.8600","4314267.0000","310.4600","310.7300","303.4800"
+"2017/05/22","310.3500","4324305.0000","312.8000","314.3700","306.8000"
+"2017/05/19","310.8300","4654580.0000","315.5000","316.5000","310.2000"
+"2017/05/18","313.0600","5609153.0000","307.0000","313.9400","305.3100"
+"2017/05/17","306.1100","6695657.0000","314.3900","314.6300","305.5000"
+"2017/05/16","317.0100","4141066.0000","317.5900","320.0600","315.1400"
+"2017/05/15","315.8800","7606854.0000","318.3800","320.2000","312.5300"
+"2017/05/12","324.8100","4118613.0000","325.4800","327.0000","321.5300"
+"2017/05/11","323.1000","4747172.0000","323.4000","326.0000","319.6000"
+"2017/05/10","325.2200","5734524.0000","321.5600","325.5000","318.1200"
+"2017/05/09","321.2600","9663374.0000","309.3800","321.9900","309.1000"
+"2017/05/08","307.1900","7002907.0000","310.9000","313.7900","305.8200"
+"2017/05/05","308.3500","8117449.0000","298.0000","308.5500","296.8000"
+"2017/05/04","295.4600","14135990.0000","307.4350","307.7700","290.7601"
+"2017/05/03","311.0200","6879259.0000","317.6700","321.5300","310.4500"
+"2017/05/02","318.8900","5316551.0000","324.0000","327.6599","316.5601"
+"2017/05/01","322.8300","8819888.0000","314.8800","327.2500","314.8100"
+"2017/04/28","314.0700","4496659.0000","309.8300","314.8000","308.0000"
+"2017/04/27","308.6300","3462663.0000","311.6900","313.0900","307.5000"
+"2017/04/26","310.1700","4683131.0000","312.3700","314.5000","309.0000"
+"2017/04/25","313.7900","6734162.0000","308.0000","313.9800","305.8600"
+"2017/04/24","308.0300","5077771.0000","309.2200","310.5500","306.0215"
+"2017/04/21","305.6000","4501958.0000","302.0000","306.4000","300.4200"
+"2017/04/20","302.5100","6145961.0000","306.5100","309.1500","300.2300"
+"2017/04/19","305.5200","3891145.0000","302.4600","306.6200","302.1100"
+"2017/04/18","300.2500","3034225.0000","299.7000","300.8399","297.9000"
+"2017/04/17","301.4400","4128067.0000","302.7000","304.0000","298.6800"
+"2017/04/13","304.0000","9275682.0000","296.7000","307.3900","295.3000"
+"2017/04/12","296.8400","6043648.0000","306.3400","308.4481","296.3200"
+"2017/04/11","308.7100","5718053.0000","313.3800","313.4700","305.5000"
+"2017/04/10","312.3900","7653623.0000","309.1500","313.7299","308.7100"
+"2017/04/07","302.5400","4566632.0000","297.5000","302.6900","297.1500"
+"2017/04/06","298.7000","5517731.0000","296.8800","301.9400","294.1000"
+"2017/04/05","295.0000","7858565.0000","302.0400","304.8800","294.2000"
+"2017/04/04","303.7000","10108230.0000","296.8900","304.8100","294.5300"
+"2017/04/03","298.5200","13864850.0000","286.9000","299.0000","284.5800"
+"2017/03/31","278.3000","3293698.0000","278.7300","279.6800","276.3197"
+"2017/03/30","277.9200","4141437.0000","278.0400","282.0000","277.2100"
+"2017/03/29","277.3800","3672526.0000","278.3400","279.6000","275.5400"
+"2017/03/28","277.4500","7978665.0000","277.0200","280.6800","275.0000"
+"2017/03/27","270.2200","6221361.0000","260.6000","270.5700","259.7500"
+"2017/03/24","263.1600","5637668.0000","255.7000","263.8900","255.0100"
+"2017/03/23","254.7800","3309844.0000","255.3900","257.6720","253.3000"
+"2017/03/22","255.0100","4056735.0000","251.5600","255.0700","250.5100"
+"2017/03/21","250.6800","6901555.0000","262.8300","264.8000","250.2400"
+"2017/03/20","261.9200","3601616.0000","260.6000","264.5500","258.8210"
+"2017/03/17","261.5000","6491018.0000","264.0000","265.3300","261.2000"
+"2017/03/16","262.0500","7127180.0000","262.4000","265.7500","259.0600"
+"2017/03/15","255.7300","5233365.0000","257.0000","261.0000","254.2700"
+"2017/03/14","258.0000","7581719.0000","246.1100","258.1200","246.0200"
+"2017/03/13","246.1700","3011280.0000","244.8200","246.8500","242.7810"
+"2017/03/10","243.6900","3062785.0000","246.2100","246.5000","243.0000"
+"2017/03/09","244.9000","3876494.0000","247.6300","248.6600","243.0000"
+"2017/03/08","246.8700","3726746.0000","247.0000","250.0700","245.3200"
+"2017/03/07","248.5900","3452587.0000","251.9200","253.8900","248.3200"
+"2017/03/06","251.2100","3353601.0000","247.9100","251.7000","247.5100"
+"2017/03/03","251.5700","2925481.0000","250.7400","251.9000","249.0000"
+"2017/03/02","250.4800","3345751.0000","249.7100","253.2800","248.2700"
+"2017/03/01","250.0200","4804963.0000","254.1800","254.8500","249.1100"
+"2017/02/28","249.9900","6073890.0000","244.1900","251.0000","243.9000"
+"2017/02/27","246.2300","11450160.0000","248.1700","248.3600","242.0100"
+"2017/02/24","257.0000","8166869.0000","252.6600","258.2500","250.2000"
+"2017/02/23","255.9900","14877090.0000","264.0000","264.6600","255.5600"
+"2017/02/22","273.5100","8537811.0000","280.3100","283.4500","272.6000"
+"2017/02/21","277.3900","5647575.0000","275.4500","281.4000","274.0100"
+"2017/02/17","272.2300","6251469.0000","265.8000","272.8900","264.1500"
+"2017/02/16","268.9500","7063860.0000","277.6000","280.0000","268.5000"
+"2017/02/15","279.7600","4943879.0000","280.0000","282.2400","276.4400"
+"2017/02/14","280.9800","7341450.0000","279.0300","287.3900","278.6100"
+"2017/02/13","280.6000","7023072.0000","270.7400","280.7899","270.5100"
+"2017/02/10","269.2300","3618336.0000","269.7900","270.9500","266.1100"
+"2017/02/09","269.2000","7812600.0000","266.2500","271.1800","266.1500"
+"2017/02/08","262.0800","3912428.0000","257.3500","263.3600","256.2000"
+"2017/02/07","257.4800","4244063.0000","258.1900","260.0000","256.4200"
+"2017/02/06","257.7700","3557600.0000","251.0000","257.8200","250.6300"
+"2017/02/03","251.3300","2185230.0000","251.9100","252.1790","249.6800"
+"2017/02/02","251.5500","2498799.0000","248.3400","252.4200","247.7100"
+"2017/02/01","249.2400","3953105.0000","253.0500","253.2000","249.0500"
+"2017/01/31","251.9300","4112013.0000","249.2400","255.8900","247.7000"
+"2017/01/30","250.6300","3798638.0000","252.5300","255.2899","247.1000"
+"2017/01/27","252.9500","3161774.0000","251.3800","253.0000","248.5200"
+"2017/01/26","252.5100","3143717.0000","254.2900","255.7400","250.7500"
+"2017/01/25","254.4700","5145301.0000","257.3100","258.4600","251.8000"
+"2017/01/24","254.6100","4958144.0000","250.0000","254.8000","249.6500"
+"2017/01/23","248.9200","6262097.0000","245.8500","250.8899","245.5000"
+"2017/01/20","244.7300","4199720.0000","245.4600","246.0000","243.0100"
+"2017/01/19","243.7600","7717244.0000","247.2500","248.6800","240.7500"
+"2017/01/18","238.3600","3767272.0000","236.6500","239.7100","235.5800"
+"2017/01/17","235.5800","4614731.0000","236.7000","239.9600","234.3700"
+"2017/01/13","237.7500","6085610.0000","230.0000","237.8500","229.5900"
+"2017/01/12","229.5900","3787547.0000","229.0600","230.7000","225.5800"
+"2017/01/11","229.7300","3649910.0000","229.0700","229.9800","226.6800"
+"2017/01/10","229.8700","3658981.0000","232.0000","232.0000","226.8900"
+"2017/01/09","231.2800","3972716.0000","228.9700","231.9200","228.0000"
+"2017/01/06","229.0100","5524153.0000","226.9300","230.3100","225.4500"
+"2017/01/05","226.7500","5908927.0000","226.4200","227.4800","221.9500"
+"2017/01/04","226.9900","11204560.0000","214.7500","228.0000","214.3100"
+"2017/01/03","216.9900","5901494.0000","214.8600","220.3300","210.9600"
+"2016/12/30","213.6900","4641288.0000","216.3000","217.5000","211.6800"
+"2016/12/29","214.6800","4043086.0000","218.5600","219.2000","214.1225"
+"2016/12/28","219.7400","3778544.0000","221.5300","223.8000","217.2000"
+"2016/12/27","219.5300","5913335.0000","214.8800","222.2500","214.4200"
+"2016/12/23","213.3400","4668263.0000","208.0000","213.4500","207.7100"
+"2016/12/22","208.4500","3108427.0000","208.2200","209.9900","206.5000"
+"2016/12/21","207.7000","5206143.0000","208.4500","212.2300","207.4100"
+"2016/12/20","208.7900","4684269.0000","203.0500","209.0000","202.5000"
+"2016/12/19","202.7300","3486937.0000","202.4900","204.4500","199.8400"
+"2016/12/16","202.4900","3795444.0000","198.0800","202.5900","197.6000"
+"2016/12/15","197.5800","3218653.0000","198.4100","200.7400","197.3900"
+"2016/12/14","198.6900","4147314.0000","198.7400","203.0000","196.7600"
+"2016/12/13","198.1500","6819322.0000","193.1800","201.2800","193.0000"
+"2016/12/12","192.4300","2436428.0000","192.8000","194.4200","191.0400"
+"2016/12/09","192.1800","2720937.0000","190.8700","193.8360","190.8100"
+"2016/12/08","192.2900","3193684.0000","192.0500","192.5000","189.5400"
+"2016/12/07","193.1500","5457071.0000","186.1500","193.4000","185.0000"
+"2016/12/06","185.8500","3389365.0000","185.5200","186.5800","182.6825"
+"2016/12/05","186.8000","4069480.0000","182.5100","188.8900","182.5100"
+"2016/12/02","181.4700","4040201.0000","182.8800","184.8800","180.0000"
+"2016/12/01","181.8800","5119105.0000","188.2500","188.5300","181.0000"
+"2016/11/30","189.4000","3544891.0000","191.0000","191.8900","187.5000"
+"2016/11/29","189.5700","4435312.0000","195.5600","196.7300","189.5000"
+"2016/11/28","196.1200","4521082.0000","195.4800","199.3500","194.5500"
+"2016/11/25","196.6500","2366098.0000","193.6400","197.2372","193.6400"
+"2016/11/23","193.1400","4890285.0000","190.6100","195.6440","189.0000"
+"2016/11/22","191.1700","5601238.0000","185.8400","191.4700","183.7100"
+"2016/11/21","184.5200","4355872.0000","185.0400","188.8900","184.4100"
+"2016/11/18","185.0200","5206473.0000","190.6500","193.0000","185.0000"
+"2016/11/17","188.6600","4880969.0000","183.4900","189.4900","182.1101"
+"2016/11/16","183.9300","3432668.0000","182.6500","184.7300","181.2100"
+"2016/11/15","183.7700","3899743.0000","182.7800","186.4300","182.0500"
+"2016/11/14","181.4500","6547913.0000","188.0000","188.2500","178.1900"
+"2016/11/11","188.5600","3987091.0000","184.2400","188.8800","183.0000"
+"2016/11/10","185.3500","6746290.0000","191.0500","191.6100","180.4200"
+"2016/11/09","190.0600","8166447.0000","186.8750","192.0000","183.9500"
+"2016/11/08","194.9400","3252927.0000","193.7900","197.4900","191.2600"
+"2016/11/07","193.2100","3857682.0000","193.5900","194.2900","190.0500"
+"2016/11/04","190.5600","5143915.0000","189.0000","193.4600","185.9600"
+"2016/11/03","187.4200","2644550.0000","189.0000","191.4700","187.0401"
+"2016/11/02","188.0200","4242250.0000","190.0500","192.6951","187.5050"
+"2016/11/01","190.7900","7023674.0000","198.0400","198.5000","188.1050"
+"2016/10/31","197.7300","4691320.0000","202.4900","202.4900","195.8100"
+"2016/10/28","199.9700","4273456.0000","204.0000","205.3200","199.8300"
+"2016/10/27","204.0100","13070990.0000","211.3400","213.7000","201.6500"
+"2016/10/26","202.2400","5346893.0000","201.0000","203.1900","200.1000"
+"2016/10/25","202.3400","2442118.0000","202.9000","204.6900","201.2000"
+"2016/10/24","202.7600","2747344.0000","201.0000","203.9452","200.2500"
+"2016/10/21","200.0900","2936908.0000","198.6000","201.5700","197.4100"
+"2016/10/20","199.1000","5069410.0000","202.1200","203.0000","197.0500"
+"2016/10/19","203.5600","6966185.0000","199.7400","206.6600","198.0600"
+"2016/10/18","199.1000","5676046.0000","195.9900","199.4700","193.2600"
+"2016/10/17","193.9600","4518331.0000","197.0500","198.3900","192.0000"
+"2016/10/14","196.5100","4265471.0000","200.6600","201.4300","196.3000"
+"2016/10/13","200.2400","2495140.0000","200.5000","200.8950","197.0500"
+"2016/10/12","201.5100","1969099.0000","200.9500","203.8800","200.4200"
+"2016/10/11","200.1000","2326754.0000","201.8500","202.2000","198.3100"
+"2016/10/10","200.9500","3311340.0000","201.3500","204.1400","199.6600"
+"2016/10/07","196.6100","3489480.0000","201.0000","201.3200","195.8000"
+"2016/10/06","201.0000","4697937.0000","202.4600","204.2099","200.2100"
+"2016/10/05","208.4600","1872456.0000","212.2400","213.1500","208.1200"
+"2016/10/04","211.4100","3537953.0000","213.1000","213.3200","208.8200"
+"2016/10/03","213.7000","5989342.0000","212.3000","215.6688","208.2500"
+"2016/09/30","204.0300","2581730.0000","202.2100","204.9800","199.5500"
+"2016/09/29","200.7000","2714040.0000","205.6000","207.3300","200.5800"
+"2016/09/28","206.2700","2079324.0000","207.5100","208.2500","205.2600"
+"2016/09/27","205.8100","3367907.0000","209.6500","209.9818","204.6093"
+"2016/09/26","208.9900","2393373.0000","206.5000","211.0000","206.5000"
+"2016/09/23","207.4500","2904125.0000","205.9900","210.1800","205.6700"
+"2016/09/22","206.4300","2381600.0000","206.4000","207.2800","203.0000"
+"2016/09/21","205.2200","2631285.0000","206.3700","207.0000","201.5600"
+"2016/09/20","204.6400","2408556.0000","206.8500","207.7500","203.9100"
+"2016/09/19","206.3400","2298318.0000","207.0000","209.4300","205.0000"
+"2016/09/16","205.4000","3104266.0000","200.4200","205.7000","199.0000"
+"2016/09/15","200.4200","3082942.0000","196.4900","202.5193","196.4000"
+"2016/09/14","196.4100","2256143.0000","195.7500","197.9248","194.8562"
+"2016/09/13","196.0500","3583140.0000","197.0600","198.4900","193.4500"
+"2016/09/12","198.3000","3714049.0000","195.0000","201.3690","194.1000"
+"2016/09/09","194.4700","3753734.0000","199.0900","199.9200","193.7000"
+"2016/09/08","197.3600","3372293.0000","199.5500","199.8900","196.3600"
+"2016/09/07","201.7100","3637918.0000","205.5000","206.4968","200.7100"
+"2016/09/06","202.8300","4386193.0000","199.0200","203.2500","199.0000"
+"2016/09/02","197.7800","5970154.0000","202.3300","203.2000","196.2000"
+"2016/09/01","200.7700","7932444.0000","209.0100","211.0999","200.5000"
+"2016/08/31","212.0100","3274854.0000","210.4300","212.6000","208.6500"
+"2016/08/30","211.3400","3164222.0000","216.1100","216.1100","210.5200"
+"2016/08/29","215.2000","3261381.0000","220.1500","220.4000","215.0000"
+"2016/08/26","219.9900","2238087.0000","222.1400","222.8550","218.8200"
+"2016/08/25","220.9600","1760212.0000","223.1100","223.8000","220.7700"
+"2016/08/24","222.6200","2566947.0000","227.0500","227.1500","222.2200"
+"2016/08/23","224.8400","4747745.0000","224.3200","228.4900","222.8000"
+"2016/08/22","222.9300","2061692.0000","224.1700","225.1100","222.6800"
+"2016/08/19","225.0000","1658616.0000","223.5400","225.1690","222.5300"
+"2016/08/18","223.5100","1699300.0000","223.8200","225.6600","222.2900"
+"2016/08/17","223.2400","1786408.0000","224.3300","224.8300","222.8000"
+"2016/08/16","223.6100","2251115.0000","225.4900","227.1900","223.4101"
+"2016/08/15","225.5900","2017964.0000","226.0200","229.5000","224.9300"
+"2016/08/12","225.6100","1811850.0000","225.4100","226.6500","224.0400"
+"2016/08/11","224.9100","1876959.0000","226.1700","227.5700","223.4100"
+"2016/08/10","225.6500","2336496.0000","228.2400","229.8700","224.6200"
+"2016/08/09","229.0800","2199766.0000","226.8200","231.5375","226.6500"
+"2016/08/08","226.1600","2259465.0000","228.0000","229.6000","226.0900"
+"2016/08/05","230.0300","3190342.0000","230.0000","232.0000","227.4000"
+"2016/08/04","230.6100","4142155.0000","225.6900","230.8600","222.0500"
+"2016/08/03","225.7900","3808747.0000","227.3700","229.6990","224.2100"
+"2016/08/02","227.2000","3928706.0000","229.3700","229.8700","221.4000"
+"2016/08/01","230.0100","4014048.0000","235.5000","236.6300","229.3800"
+"2016/07/29","234.7900","3061574.0000","230.7000","235.2800","230.2400"
+"2016/07/28","230.6100","2415462.0000","227.9500","230.7600","226.6000"
+"2016/07/27","228.4900","2887028.0000","229.3400","233.3600","226.9200"
+"2016/07/26","229.5100","3427251.0000","227.6900","230.0000","225.3000"
+"2016/07/25","230.0100","4479483.0000","222.2700","231.3900","221.3715"
+"2016/07/22","222.2700","2570462.0000","221.9900","224.5000","218.8800"
+"2016/07/21","220.5000","4425756.0000","226.0000","227.8470","219.1000"
+"2016/07/20","228.3600","2556119.0000","226.4700","229.8000","225.0000"
+"2016/07/19","225.2600","3047535.0000","225.0000","229.1000","224.7500"
+"2016/07/18","226.2500","3394588.0000","219.6400","227.0900","218.3000"
+"2016/07/15","220.4000","2230821.0000","222.5200","222.7499","219.6400"
+"2016/07/14","221.5300","2657899.0000","223.1200","224.9400","221.0500"
+"2016/07/13","222.5300","3540699.0000","225.5000","225.5900","220.2900"
+"2016/07/12","224.6500","4573875.0000","224.1000","227.5000","223.2200"
+"2016/07/11","224.7800","5369066.0000","219.9600","226.7800","219.5100"
+"2016/07/08","216.7800","4067131.0000","217.8000","219.8100","214.5000"
+"2016/07/07","215.9400","3603385.0000","213.1000","218.1200","213.0100"
+"2016/07/06","214.4400","4910285.0000","210.0000","215.2300","209.0000"
+"2016/07/05","213.9800","5169832.0000","209.7300","214.5441","208.0000"
+"2016/07/01","216.5000","5396030.0000","206.1400","218.2400","206.0000"
+"2016/06/30","212.2800","4794440.0000","212.9700","213.4999","209.0200"
+"2016/06/29","210.1900","5987120.0000","205.1300","211.7800","203.0000"
+"2016/06/28","201.7900","6158996.0000","201.8900","204.0500","199.4100"
+"2016/06/27","198.5500","7211823.0000","190.8600","198.8100","187.8700"
+"2016/06/24","193.1500","6988949.0000","190.0500","195.1200","189.7300"
+"2016/06/23","196.4000","10098190.0000","195.6900","197.5500","192.1300"
+"2016/06/22","196.6600","23706100.0000","199.4700","205.9500","195.7500"
+"2016/06/21","219.6100","2855619.0000","220.6800","222.5690","218.8100"
+"2016/06/20","219.7000","3549768.0000","219.5000","223.7500","218.2300"
+"2016/06/17","215.4700","3107734.0000","217.8100","219.9900","214.5000"
+"2016/06/16","217.9300","2438692.0000","217.4200","218.0400","213.5000"
+"2016/06/15","217.7000","2905002.0000","216.9500","221.9000","215.1300"
+"2016/06/14","214.9600","3575822.0000","218.8800","222.2000","212.5300"
+"2016/06/13","217.8700","4187833.0000","219.5000","225.7700","217.6600"
+"2016/06/10","218.7900","5994548.0000","227.3900","227.9700","218.4217"
+"2016/06/09","229.3600","4454222.0000","234.9800","235.3300","227.0600"
+"2016/06/08","235.5200","5965110.0000","233.8000","240.8450","232.6050"
+"2016/06/07","232.3400","6194154.0000","222.2400","234.4400","221.5200"
+"2016/06/06","220.6800","2242634.0000","218.0000","220.9000","215.4500"
+"2016/06/03","218.9900","2226110.0000","220.0000","221.9400","218.0100"
+"2016/06/02","218.9600","2017279.0000","219.5900","219.9090","217.1100"
+"2016/06/01","219.5600","2982270.0000","221.4800","222.4000","216.8900"
+"2016/05/31","223.2300","2786682.0000","223.0400","224.7497","221.5001"
+"2016/05/27","223.0400","3645792.0000","224.9900","225.9300","220.7500"
+"2016/05/26","225.1200","4066512.0000","220.5000","225.2600","219.0500"
+"2016/05/25","219.5800","3131279.0000","217.9100","221.3600","216.5100"
+"2016/05/24","217.9100","3009327.0000","216.6000","218.7400","215.1800"
+"2016/05/23","216.2200","5096751.0000","219.8700","222.6000","215.8600"
+"2016/05/20","220.2800","8996546.0000","216.9900","220.5500","216.3500"
+"2016/05/19","215.2100","6817922.0000","213.6200","216.7900","207.3000"
+"2016/05/18","211.1700","5552692.0000","209.1500","215.3100","207.7500"
+"2016/05/17","204.6600","2842028.0000","209.0500","209.8199","204.0200"
+"2016/05/16","208.2900","2945754.0000","208.1500","213.1500","207.9200"
+"2016/05/13","207.6100","2820616.0000","207.7800","211.2000","206.7000"
+"2016/05/12","207.2800","3650075.0000","211.4400","211.6700","203.6572"
+"2016/05/11","208.9600","5159640.0000","207.5900","215.4800","206.0500"
+"2016/05/10","208.6900","4068053.0000","207.5500","209.4700","205.0000"
+"2016/05/09","208.9200","4772992.0000","215.7200","216.1500","206.8000"
+"2016/05/06","214.9300","5683675.0000","210.8700","216.3700","208.1100"
+"2016/05/05","211.5300","11248340.0000","228.4600","228.6400","209.7900"
+"2016/05/04","222.5600","8550004.0000","230.2900","234.4600","220.4000"
+"2016/05/03","232.3200","4296325.0000","237.3600","238.9100","231.6200"
+"2016/05/02","241.8000","3838958.0000","241.5000","243.1900","234.8200"
+"2016/04/29","240.7600","5405164.0000","248.1400","248.4300","237.8100"
+"2016/04/28","247.7100","2515595.0000","249.8500","253.4300","247.4400"
+"2016/04/27","251.4700","3198105.0000","252.7500","255.0000","249.4000"
+"2016/04/26","253.7400","3217779.0000","252.0500","255.7300","249.3900"
+"2016/04/25","251.8200","3665088.0000","253.0100","257.3800","250.7600"
+"2016/04/22","253.7500","3783126.0000","248.8900","254.0000","245.7100"
+"2016/04/21","248.2900","2777079.0000","248.9900","250.9000","246.9100"
+"2016/04/20","249.9700","5192343.0000","246.2600","253.6600","241.5000"
+"2016/04/19","247.3700","6351360.0000","253.1200","254.3699","241.2510"
+"2016/04/18","253.8800","4263246.0000","252.2300","258.3100","251.6600"
+"2016/04/15","254.5100","3748593.0000","251.3100","254.6000","249.1200"
+"2016/04/14","251.8600","4129258.0000","253.0000","256.8390","251.0501"
+"2016/04/13","254.5300","4921554.0000","248.5100","255.5000","247.3300"
+"2016/04/12","247.8200","5755351.0000","249.5000","251.8000","243.6300"
+"2016/04/11","249.9200","9156404.0000","251.0000","258.9900","245.3000"
+"2016/04/08","250.0700","7352707.0000","260.5000","260.8200","248.0201"
+"2016/04/07","257.2000","8845567.0000","266.4500","269.3400","254.5100"
+"2016/04/06","265.4200","11695760.0000","253.9700","267.7400","253.4500"
+"2016/04/05","255.4700","9931470.0000","240.5000","256.5600","240.0000"
+"2016/04/04","246.9900","13381160.0000","249.1200","252.1200","243.6400"
+"2016/04/01","237.5900","15979910.0000","244.8250","247.9000","233.2500"
+"2016/03/31","229.7700","7975638.0000","229.3400","237.4200","225.0100"
+"2016/03/30","226.8900","4025670.0000","235.0900","235.5000","226.5000"
+"2016/03/29","230.1300","4006037.0000","229.8900","232.3800","225.3300"
+"2016/03/28","230.2600","3878599.0000","231.6100","234.8100","225.0000"
+"2016/03/24","227.7500","4956604.0000","215.7800","228.8877","215.0000"
+"2016/03/23","222.5800","4936203.0000","232.3700","234.7300","222.0300"
+"2016/03/22","234.2400","4303052.0000","237.2100","238.9900","232.5580"
+"2016/03/21","238.3200","5289014.0000","235.3400","239.8800","235.0000"
+"2016/03/18","232.7400","4704761.0000","229.1000","234.4800","228.0600"
+"2016/03/17","226.3800","3769083.0000","221.4700","228.5000","220.0000"
+"2016/03/16","221.9300","3511873.0000","218.0000","222.5800","217.0200"
+"2016/03/15","218.3400","3133230.0000","214.2700","218.9700","211.5000"
+"2016/03/14","215.1500","4062304.0000","212.6500","216.7200","210.6400"
+"2016/03/11","207.5000","3339148.0000","207.9300","209.4200","205.3300"
+"2016/03/10","205.1800","5191602.0000","210.0000","213.2900","200.6710"
+"2016/03/09","208.7200","3207597.0000","204.5200","209.3726","202.7900"
+"2016/03/08","202.6000","4175498.0000","203.5000","207.5000","202.2000"
+"2016/03/07","205.2900","5331097.0000","197.6800","209.7000","197.4000"
+"2016/03/04","201.0400","6479858.0000","198.0000","204.0300","197.5001"
+"2016/03/03","195.7400","4822993.0000","188.2800","197.4200","184.2200"
+"2016/03/02","188.3400","4858631.0000","183.7300","188.5200","181.5000"
+"2016/03/01","186.3500","6695704.0000","194.2500","195.9484","182.7000"
+"2016/02/29","191.9300","4495402.0000","192.4000","196.3500","189.2220"
+"2016/02/26","190.3400","6054061.0000","188.7000","192.0000","185.0000"
+"2016/02/25","187.4300","5727008.0000","178.6500","188.5192","175.2000"
+"2016/02/24","179.0000","5385369.0000","172.7500","179.5000","167.8400"
+"2016/02/23","177.2100","5982993.0000","176.1600","181.7300","173.6800"
+"2016/02/22","177.7400","5055340.0000","170.1200","178.9100","169.8500"
+"2016/02/19","166.5800","2955832.0000","163.6600","167.4900","162.5000"
+"2016/02/18","166.7700","3883107.0000","172.4200","172.9500","164.7700"
+"2016/02/17","168.6800","5820264.0000","159.0000","169.3400","156.6800"
+"2016/02/16","155.1700","5561638.0000","158.7000","162.9500","154.1100"
+"2016/02/12","151.0400","7233264.0000","155.0000","157.0100","143.7000"
+"2016/02/11","150.4700","14236900.0000","152.0000","163.2600","147.0000"
+"2016/02/10","143.6700","10104690.0000","150.5000","154.9700","141.7400"
+"2016/02/09","148.2500","8639661.0000","142.3200","159.7900","141.0500"
+"2016/02/08","147.9900","9306754.0000","157.1050","157.1500","146.0000"
+"2016/02/05","162.6000","9434495.0000","171.3000","173.0000","157.7442"
+"2016/02/04","175.3300","4379442.0000","170.7000","175.9800","166.9900"
+"2016/02/03","173.4800","7927640.0000","183.5900","183.9400","170.1800"
+"2016/02/02","182.7800","5764817.0000","192.4200","193.1200","180.2300"
+"2016/02/01","196.9400","5295685.0000","188.7600","199.5200","182.7500"
+"2016/01/29","191.2000","2848929.0000","189.9500","193.7400","188.0800"
+"2016/01/28","189.7000","4586328.0000","190.7900","191.2800","182.4100"
+"2016/01/27","188.0700","3577353.0000","192.3800","193.2600","185.7700"
+"2016/01/26","193.5600","4956918.0000","196.7000","197.8200","188.8800"
+"2016/01/25","196.3800","2695408.0000","200.0600","203.5700","195.8800"
+"2016/01/22","202.5500","3122066.0000","204.8010","205.5000","199.0300"
+"2016/01/21","199.9700","3164424.0000","201.5500","203.2300","195.0200"
+"2016/01/20","198.7000","5826110.0000","199.4000","201.2800","191.2500"
+"2016/01/19","204.7200","4031271.0000","208.7100","210.4700","200.7800"
+"2016/01/15","204.9900","5325773.0000","198.9700","205.0700","197.2500"
+"2016/01/14","206.1800","6490579.0000","202.2100","210.0000","193.3800"
+"2016/01/13","200.3100","4120993.0000","212.0100","212.6500","200.0000"
+"2016/01/12","209.9700","3079051.0000","211.6000","213.7395","205.3100"
+"2016/01/11","207.8500","4090843.0000","214.0100","214.4500","203.0000"
+"2016/01/08","211.0000","3572360.0000","217.8600","220.4400","210.7700"
+"2016/01/07","215.6500","3550704.0000","214.1900","218.4400","213.6700"
+"2016/01/06","219.0400","3774353.0000","220.0000","220.0500","215.9800"
+"2016/01/05","223.4300","3185525.0000","226.3600","226.8900","220.0000"
+"2016/01/04","223.4100","6823510.0000","230.7200","231.3800","219.0000"
+"2015/12/31","240.0100","2713817.0000","238.5100","243.4500","238.3700"
+"2015/12/30","238.0900","3694448.0000","236.6000","243.6340","235.6707"
+"2015/12/29","237.1900","2402438.0000","230.0600","237.7200","229.5470"
+"2015/12/28","228.9500","1900171.0000","231.4900","231.9800","225.5400"
+"2015/12/24","230.5700","710277.0000","230.5600","231.8800","228.2800"
+"2015/12/23","229.7000","1551031.0000","232.1800","233.4500","228.1300"
+"2015/12/22","229.9500","1958836.0000","234.9900","236.5500","229.6300"
+"2015/12/21","232.5600","1951581.0000","231.6900","235.8300","231.0800"
+"2015/12/18","230.4600","3008057.0000","232.8900","235.9000","229.2900"
+"2015/12/17","233.3900","3294460.0000","233.9400","237.7600","229.8149"
+"2015/12/16","234.5100","5100443.0000","222.1000","234.8800","220.7300"
+"2015/12/15","221.0900","2241686.0000","221.8200","222.2200","218.0000"
+"2015/12/14","218.5800","2827797.0000","217.5100","220.9200","214.8700"
+"2015/12/11","217.0200","3259114.0000","225.2400","225.7500","216.6400"
+"2015/12/10","227.0700","2070088.0000","224.7100","228.4900","223.6400"
+"2015/12/09","224.5200","3057036.0000","226.7000","227.5000","220.7200"
+"2015/12/08","226.7200","2682259.0000","227.5200","228.8000","224.2000"
+"2015/12/07","231.1300","3140864.0000","227.7000","235.6300","226.1500"
+"2015/12/04","230.3800","2572014.0000","232.4600","233.2700","227.6600"
+"2015/12/03","232.7100","2937233.0000","235.4800","237.4500","230.0000"
+"2015/12/02","231.9900","2980644.0000","237.0000","238.6000","231.2300"
+"2015/12/01","237.1900","3728562.0000","231.0600","238.0000","231.0500"
+"2015/11/30","230.2600","2591205.0000","231.7900","234.2800","229.0800"
+"2015/11/27","231.6100","1949353.0000","231.0600","232.2500","227.0100"
+"2015/11/25","229.6400","3986945.0000","221.3400","230.8250","220.3750"
+"2015/11/24","218.2500","2478389.0000","215.3700","221.0000","215.0000"
+"2015/11/23","217.7500","2525196.0000","217.3500","219.1800","214.6798"
+"2015/11/20","220.0100","4394199.0000","223.4900","225.0000","213.5800"
+"2015/11/19","221.8000","2499593.0000","220.5400","226.1900","220.3000"
+"2015/11/18","221.0700","2810200.0000","214.5000","221.3800","212.5200"
+"2015/11/17","214.0000","2148326.0000","215.2000","216.0000","211.4000"
+"2015/11/16","214.3100","2920362.0000","206.0900","214.9800","205.8000"
+"2015/11/13","207.1900","3423139.0000","212.9500","212.9900","206.5200"
+"2015/11/12","212.9400","2913511.0000","217.8500","219.0000","212.6600"
+"2015/11/11","219.0800","3337501.0000","217.7700","219.4800","213.6300"
+"2015/11/10","216.5000","4612408.0000","223.4800","223.7000","216.0800"
+"2015/11/09","225.3300","3846179.0000","232.9900","232.9900","224.3100"
+"2015/11/06","232.3600","2444264.0000","230.7000","233.3590","229.5000"
+"2015/11/05","231.7700","4494944.0000","230.5800","234.5843","229.1900"
+"2015/11/04","231.6300","12713530.0000","227.0000","232.7400","225.2000"
+"2015/11/03","208.3500","8065091.0000","213.8500","214.4400","207.7500"
+"2015/11/02","213.7900","3924514.0000","208.9200","215.8000","207.2200"
+"2015/10/30","206.9300","4432433.0000","210.4000","211.6300","203.8900"
+"2015/10/29","211.6300","1794743.0000","211.7500","213.7481","210.6400"
+"2015/10/28","212.9600","2726880.0000","211.3100","213.4500","208.3000"
+"2015/10/27","210.3500","3512832.0000","214.8400","217.1000","207.5100"
+"2015/10/26","215.2600","3388227.0000","211.3800","215.8800","210.0000"
+"2015/10/23","209.0900","4226411.0000","215.0000","215.3500","207.6900"
+"2015/10/22","211.7200","2818801.0000","211.5600","215.7500","209.4000"
+"2015/10/21","210.0900","4177956.0000","211.9900","214.8100","208.8000"
+"2015/10/20","213.0300","14877020.0000","227.7200","228.6000","202.0000"
+"2015/10/19","228.1000","2506836.0000","226.5000","231.1500","224.9400"
+"2015/10/16","227.0100","4327574.0000","223.0400","230.4805","222.8700"
+"2015/10/15","221.3100","2835920.0000","216.4300","221.7300","213.7000"

agents/tools-class.py

@@ -0,0 +1,115 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import os
+import requests
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+class EXASearchTool(BaseModel):
+    """Wrapper for EXA Search API."""
+    search_url: str = "https://api.exa.ai/search"
+    headers: Dict = {
+        "accept": "application/json",
+        "content-type": "application/json",
+    }
+    max_results: Optional[int] = None
+
+    def run(self, query: str) -> str:
+        """Run query through EXA and return concatenated results.
+        
+        Args:
+            query (str): The search query to use
+            
+        Returns:
+            str: The concatenated search results
+        """
+        payload = {
+            "query": query,
+            "type": "magic",
+        }
+
+        headers = self.headers.copy()
+        headers["x-api-key"] = os.environ['EXA_API_KEY']
+
+        response = requests.post(self.search_url, json=payload, headers=headers)
+        results = response.json()
+        
+        if 'results' in results:
+            return self._parse_results(results['results'])
+        return ""
+
+    def results(self, query: str, max_results: Optional[int] = None) -> List[Dict[str, Any]]:
+        """Run query through EXA and return metadata.
+        
+        Args:
+            query (str): The search query to use
+            max_results (Optional[int]): Maximum number of results to return
+            
+        Returns:
+            List[Dict[str, Any]]: List of result dictionaries
+        """
+        payload = {
+            "query": query,
+            "type": "magic",
+        }
+
+        headers = self.headers.copy()
+        headers["x-api-key"] = os.environ['EXA_API_KEY']
+
+        response = requests.post(self.search_url, json=payload, headers=headers)
+        results = response.json()
+        
+        if 'results' in results:
+            return results['results'][:max_results] if max_results else results['results']
+        return []
+
+    def _parse_results(self, results: List[Dict[str, Any]]) -> str:
+        """Parse results into a readable string format.
+        
+        Args:
+            results (List[Dict[str, Any]]): List of result dictionaries
+            
+        Returns:
+            str: Formatted string of results
+        """
+        strings = []
+        for result in results:
+            try:
+                strings.append('\n'.join([
+                    f"Title: {result['title']}",
+                    f"Score: {result['score']}",
+                    f"Url: {result['url']}",
+                    f"ID: {result['id']}",
+                    "---"
+                ]))
+            except KeyError:
+                continue
+
+        content = '\n'.join(strings)
+        return f"\nSearch results: {content}\n"
+
+# Create an agent with the tool
+agent = Agent(
+    name="SearchAgent",
+    role="Research Assistant",
+    goal="Search for information about 'AI Agents Framework'",
+    backstory="I am an AI assistant that can search GitHub.",
+    tools=[EXASearchTool],
+    self_reflect=False
+)
+
+# Create tasks to demonstrate both tools
+task = Task(
+    name="search_task",
+    description="Search for information about 'AI Agents Framework'",
+    expected_output="Information about AI Agents Framework",
+    agent=agent
+)
+
+# Create and start the workflow
+agents = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task],
+    verbose=True
+)
+
+agents.start()

agents/video-agent.py

@@ -0,0 +1,36 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create Video Analysis Agent
+video_agent = Agent(
+    name="VideoAnalyst",
+    role="Video Analysis 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
+)
+
+# Task with Video File
+task1 = Task(
+    name="analyze_video",
+    description="""Watch this video and provide:
+    1. A summary of the main events
+    2. Key objects and people visible
+    3. Any text or important information shown
+    4. The overall context and setting""",
+    expected_output="Comprehensive analysis of the video content",
+    agent=video_agent,
+    images=["video.mp4"]  
+)
+
+# Create PraisonAIAgents instance
+agents = PraisonAIAgents(
+    agents=[video_agent],
+    tasks=[task1],
+    process="sequential",
+    verbose=1
+)
+
+# Run all tasks
+agents.start()

agents/websearch-agent.py

@@ -0,0 +1,5 @@
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Web Search Agent", tools=[duckduckgo])
+agent.start("Search about AI 2024")

agents/wikipedia-agent.py

@@ -0,0 +1,16 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import wiki_search, wiki_summary, wiki_page, wiki_random, wiki_language
+
+agent = Agent(
+    instructions="You are a Wikipedia Agent", 
+    tools=[wiki_search, wiki_summary, wiki_page, wiki_random, wiki_language],
+    self_reflect=True,
+    min_reflect=3,
+    max_reflect=5,
+)
+agent.start(
+    "What is the history of AI?"
+    "First search the history of AI"
+    "Read the page of the history of AI"
+    "Get the summary of the page"
+)

docs/agents/agents.mdx

@@ -0,0 +1,85 @@
+---
+title: "AI Agents"
+description: "Overview of all available PraisonAI agents and their capabilities"
+icon: "robot"
+---
+
+PraisonAI provides a diverse set of specialized agents for various tasks. Each agent is designed with specific capabilities and tools to handle different types of tasks effectively.
+
+## Data & Analysis
+
+<CardGroup cols={2}>
+  <Card title="Data Analyst" icon="chart-line" href="/agents/data-analyst">
+    Analyze data from various sources, create visualizations, and generate insights.
+  </Card>
+  <Card title="Finance" icon="money-bill-trend-up" href="/agents/finance">
+    Track stocks, analyze financial data, and provide investment recommendations.
+  </Card>
+  <Card title="Research" icon="magnifying-glass-chart" href="/agents/research">
+    Conduct comprehensive research and analysis across various topics.
+  </Card>
+  <Card title="Wikipedia" icon="book" href="/agents/wikipedia">
+    Search and extract information from Wikipedia articles.
+  </Card>
+</CardGroup>
+
+## Media & Content
+
+<CardGroup cols={2}>
+  <Card title="Image Analysis" icon="image" href="/agents/image">
+    Analyze and understand visual content from images.
+  </Card>
+  <Card title="Image to Text" icon="text" href="/agents/image-to-text">
+    Convert images to textual descriptions and extract text content.
+  </Card>
+  <Card title="Video" icon="video" href="/agents/video">
+    Analyze video content and extract meaningful information.
+  </Card>
+  <Card title="Markdown" icon="markdown" href="/agents/markdown">
+    Generate and format content in Markdown syntax.
+  </Card>
+</CardGroup>
+
+## Search & Recommendations
+
+<CardGroup cols={2}>
+  <Card title="Web Search" icon="globe" href="/agents/websearch">
+    Perform intelligent web searches and gather information.
+  </Card>
+  <Card title="Recommendation" icon="thumbs-up" href="/agents/recommendation">
+    Generate personalized recommendations based on preferences.
+  </Card>
+  <Card title="Shopping" icon="shop" href="/agents/shopping">
+    Compare prices and find the best deals across stores.
+  </Card>
+  <Card title="Planning" icon="calendar" href="/agents/planning">
+    Create travel plans and detailed itineraries.
+  </Card>
+</CardGroup>
+
+## Development
+
+<CardGroup cols={2}>
+  <Card title="Programming" icon="code" href="/agents/programming">
+    Write, analyze, and debug code across multiple languages.
+  </Card>
+  <Card title="Single Agent" icon="circle-1" href="/agents/single">
+    Simple, focused agent for basic tasks without external tools.
+  </Card>
+</CardGroup>
+
+## Getting Started
+
+Each agent can be easily initialized and customized for your specific needs. Here's a basic example:
+
+```python
+from praisonaiagents import Agent
+
+# Create an agent with specific instructions
+agent = Agent(instructions="Your task-specific instructions")
+
+# Start the agent with a task
+response = agent.start("Your task description")
+```
+
+For more detailed information about each agent, click on the respective cards above.

docs/agents/data-analyst.mdx

@@ -0,0 +1,120 @@
+---
+title: "Data Analyst Agent"
+sidebarTitle: "Data Analyst"
+description: "Learn how to create AI agents for data analysis and insights generation."
+icon: "chart-line"
+---
+
+```mermaid
+flowchart LR
+    In[Data Source] --> Reader[Data Reader]
+    Reader --> Analyzer[Data Analyzer]
+    Analyzer --> Generator[Insights Generator]
+    Generator --> Out[Output]
+    
+    style In fill:#8B0000,color:#fff
+    style Reader fill:#2E8B57,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Data Analyst Agent can read data from various sources, analyze it, and generate insights.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `data_analysis.py`:
+        ```python
+        from praisonaiagents import Agent, Tools
+        from praisonaiagents.tools import (
+            read_csv, read_excel, write_csv, write_excel,
+            filter_data, get_summary, group_by, pivot_table
+        )
+
+        agent = Agent(
+            instructions="You are a Data Analyst Agent",
+            tools=[
+                read_csv, read_excel, write_csv, write_excel,
+                filter_data, get_summary, group_by, pivot_table
+            ]
+        )
+
+        # Start analysis with a specific task
+        agent.start(f"""
+            Read the data from the csv file {os.path.join(os.path.dirname(__file__), "tesla-stock-price.csv")}
+            Analyse the data and give me the insights
+            read_csv to read the file
+        """)
+        ```
+    </Step>
+</Steps>
+
+## Understanding Data Analysis Workflow
+
+The Data Analyst Agent is designed to perform comprehensive data analysis tasks using a suite of specialized tools. Here's how it works:
+
+1. **Data Reading**: The agent can read data from various sources:
+   - CSV files using `read_csv`
+   - Excel files using `read_excel`
+
+2. **Data Analysis**: Multiple analysis tools are available:
+   - `filter_data`: Filter datasets based on conditions
+   - `get_summary`: Generate statistical summaries
+   - `group_by`: Group data by specific columns
+   - `pivot_table`: Create pivot tables for analysis
+
+3. **Data Export**: Results can be exported to:
+   - CSV format using `write_csv`
+   - Excel format using `write_excel`
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Multiple Data Sources" icon="table">
+    Support for both CSV and Excel file formats.
+  </Card>
+  <Card title="Analysis Tools" icon="calculator">
+    Comprehensive suite of analysis tools including filtering, summarization, and pivoting.
+  </Card>
+  <Card title="Data Export" icon="file-export">
+    Export capabilities to various formats.
+  </Card>
+  <Card title="Automated Insights" icon="lightbulb">
+    Automatic generation of data insights and patterns.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Analyzing stock data
+agent.start("""
+    1. Read 'stock_data.csv'
+    2. Filter data for the last 30 days
+    3. Calculate daily returns
+    4. Generate summary statistics
+    5. Export results to 'analysis_results.xlsx'
+""")
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex analysis workflows
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving analysis accuracy
+- Check out other specialized agents like the [Finance Agent](/agents/finance) for specific use cases

docs/agents/finance.mdx

@@ -0,0 +1,97 @@
+---
+title: "Finance Agent"
+sidebarTitle: "Finance"
+description: "Learn how to create AI agents for financial analysis and investment recommendations."
+icon: "money-bill-trend-up"
+---
+
+```mermaid
+flowchart LR
+    In[Request] --> Price[Stock Price]
+    Price --> Info[Stock Info]
+    Info --> History[Historical Data]
+    History --> Out[Investment Advice]
+    
+    style In fill:#8B0000,color:#fff
+    style Price fill:#2E8B57,color:#fff
+    style Info fill:#2E8B57,color:#fff
+    style History fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Finance Agent can analyze stock market data and provide investment recommendations.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `finance_analysis.py`:
+        ```python
+        from praisonaiagents import Agent, Tools
+        from praisonaiagents.tools import get_stock_price, get_stock_info, get_historical_data
+
+        agent = Agent(
+            instructions="You are a Research Agent",
+            tools=[get_stock_price, get_stock_info, get_historical_data]
+        )
+        agent.start("Understand current stock price and historical data of Apple and Google. Tell me if I can invest in them")
+        ```
+    </Step>
+</Steps>
+
+## Understanding Financial Analysis
+
+The Finance Agent specializes in stock market analysis and investment recommendations using three key components:
+
+1. **Real-time Price Data**: Uses `get_stock_price` to fetch current market prices
+2. **Company Information**: Retrieves company details using `get_stock_info`
+3. **Historical Analysis**: Analyzes trends with `get_historical_data`
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Real-time Data" icon="clock">
+    Access to current stock market prices and information.
+  </Card>
+  <Card title="Company Analysis" icon="building">
+    Detailed company information and fundamentals.
+  </Card>
+  <Card title="Historical Trends" icon="chart-line">
+    Analysis of historical price movements and patterns.
+  </Card>
+  <Card title="Investment Advice" icon="money-bill">
+    AI-powered investment recommendations.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Analyzing specific stocks
+agent.start("""
+    1. Get current prices for AAPL and GOOGL
+    2. Retrieve company information
+    3. Analyze 6-month historical data
+    4. Provide investment recommendations
+""")
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex financial analysis
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving recommendation accuracy
+- Check out the [Data Analyst Agent](/agents/data-analyst) for detailed data analysis capabilities

docs/agents/image-to-text.mdx

@@ -0,0 +1,140 @@
+---
+title: "Image to Text Agent"
+sidebarTitle: "Image to Text"
+description: "Learn how to create AI agents for converting images to textual descriptions and extracting text from images."
+icon: "text"
+---
+
+```mermaid
+flowchart LR
+    In[Image Input] --> OCR[Text Extractor]
+    OCR --> Analyzer[Content Analyzer]
+    Analyzer --> Generator[Description Generator]
+    Generator --> Out[Text Output]
+    
+    style In fill:#8B0000,color:#fff
+    style OCR fill:#2E8B57,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Image-to-Text Agent can extract text from images and generate comprehensive descriptions.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `image_to_text.py`:
+        ```python
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+
+        # Create Image-to-Text Agent
+        image_text_agent = Agent(
+            name="ImageTextConverter",
+            role="Image Text Extraction Specialist",
+            goal="Convert image content to textual descriptions and extract text",
+            backstory="""You are an expert in OCR and image understanding.
+            You excel at extracting text from images and generating detailed descriptions.""",
+            llm="gpt-4o-mini",
+            self_reflect=False
+        )
+
+        # Create text extraction task
+        extraction_task = Task(
+            name="extract_text",
+            description="Extract all text from this image and describe its layout.",
+            expected_output="Extracted text and layout description",
+            agent=image_text_agent,
+            images=["document.jpg"]
+        )
+
+        # Create description task
+        description_task = Task(
+            name="generate_description",
+            description="Generate a detailed description of the image content.",
+            expected_output="Comprehensive description of visual elements",
+            agent=image_text_agent,
+            images=["scene.jpg"]
+        )
+
+        # Create PraisonAIAgents instance
+        agents = PraisonAIAgents(
+            agents=[image_text_agent],
+            tasks=[extraction_task, description_task],
+            process="sequential",
+            verbose=1
+        )
+
+        # Run analysis
+        agents.start()
+        ```
+    </Step>
+</Steps>
+
+## Understanding Image-to-Text Conversion
+
+The Image-to-Text Agent combines multiple capabilities to convert visual content into textual form:
+
+1. **OCR Processing**: Extracts text from images using optical character recognition
+2. **Layout Analysis**: Understands the spatial arrangement of text and visual elements
+3. **Content Description**: Generates natural language descriptions of image content
+4. **Text Formatting**: Preserves text formatting and structure where possible
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Text Extraction" icon="text">
+    Advanced OCR capabilities for text extraction.
+  </Card>
+  <Card title="Layout Understanding" icon="table-layout">
+    Analysis of text and content layout.
+  </Card>
+  <Card title="Content Description" icon="pen-to-square">
+    Detailed descriptions of visual content.
+  </Card>
+  <Card title="Format Preservation" icon="paragraph">
+    Maintains text formatting and structure.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Processing a document image
+document_task = Task(
+    name="process_document",
+    description="Extract text and analyze document layout",
+    expected_output="Extracted text with layout information",
+    agent=image_text_agent,
+    images=["business_document.jpg"]
+)
+
+# Run single task
+agents = PraisonAIAgents(
+    agents=[image_text_agent],
+    tasks=[document_task],
+    process="sequential"
+)
+agents.start()
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex document processing
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving text extraction accuracy
+- Check out the [Image Agent](/agents/image) for pure image analysis capabilities

docs/agents/image.mdx

@@ -0,0 +1,139 @@
+---
+title: "Image Analysis Agent"
+sidebarTitle: "Image Analysis"
+description: "Learn how to create AI agents for image analysis and visual content understanding."
+icon: "image"
+---
+
+```mermaid
+flowchart LR
+    In[Image Input] --> Analyzer[Image Analyzer]
+    Analyzer --> Detector[Object Detector]
+    Detector --> Generator[Description Generator]
+    Generator --> Out[Analysis Output]
+    
+    style In fill:#8B0000,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Detector fill:#2E8B57,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Image Analysis Agent can process and analyze visual content, detect objects, and generate detailed descriptions.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `image_analysis.py`:
+        ```python
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+
+        # Create Image Analysis Agent
+        image_agent = Agent(
+            name="ImageAnalyst",
+            role="Image Analysis 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 for different types of analysis
+        task1 = 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=image_agent,
+            images=["https://example.com/landmark.jpg"]
+        )
+
+        task2 = Task(
+            name="analyze_local_image",
+            description="What objects can you see in this image? Describe their arrangement.",
+            expected_output="Detailed description of objects and their spatial relationships",
+            agent=image_agent,
+            images=["local_image.jpg"]
+        )
+
+        # Create PraisonAIAgents instance
+        agents = PraisonAIAgents(
+            agents=[image_agent],
+            tasks=[task1, task2],
+            process="sequential",
+            verbose=1
+        )
+
+        # Run analysis
+        agents.start()
+        ```
+    </Step>
+</Steps>
+
+## Understanding Image Analysis
+
+The Image Analysis Agent is designed to process and understand visual content through several key capabilities:
+
+1. **Image Input**: Supports both URL and local file inputs
+2. **Object Detection**: Identifies and locates objects within images
+3. **Architectural Analysis**: Specialized in analyzing architectural features
+4. **Spatial Understanding**: Describes spatial relationships between objects
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Multiple Input Sources" icon="images">
+    Support for both URL and local image files.
+  </Card>
+  <Card title="Object Detection" icon="magnifying-glass">
+    Advanced object detection and recognition.
+  </Card>
+  <Card title="Architectural Analysis" icon="building">
+    Specialized analysis of architectural features.
+  </Card>
+  <Card title="Detailed Descriptions" icon="pen">
+    Generation of comprehensive visual descriptions.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Analyzing a landmark image
+landmark_task = Task(
+    name="analyze_famous_landmark",
+    description="Analyze this historical landmark",
+    expected_output="Architectural details and historical significance",
+    agent=image_agent,
+    images=["https://example.com/landmark.jpg"]
+)
+
+# Run single task
+agents = PraisonAIAgents(
+    agents=[image_agent],
+    tasks=[landmark_task],
+    process="sequential"
+)
+agents.start()
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex image analysis workflows
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving analysis accuracy
+- Check out the [Video Agent](/agents/video) for video content analysis

docs/agents/markdown.mdx

@@ -0,0 +1,120 @@
+---
+title: "Markdown Agent"
+sidebarTitle: "Markdown"
+description: "Learn how to create AI agents for generating and formatting content in Markdown."
+icon: "markdown"
+---
+
+```mermaid
+flowchart LR
+    In[Content Request] --> Generator[Content Generator]
+    Generator --> Formatter[Markdown Formatter]
+    Formatter --> Validator[Format Validator]
+    Validator --> Out[Markdown Output]
+    
+    style In fill:#8B0000,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Formatter fill:#2E8B57,color:#fff
+    style Validator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Markdown Agent can generate and format content in Markdown syntax.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `markdown_generator.py`:
+        ```python
+        from praisonaiagents import Agent
+
+        # Create Markdown Agent
+        markdown_agent = Agent(
+            name="MarkdownWriter",
+            role="Markdown Content Specialist",
+            goal="Generate well-formatted content in Markdown syntax",
+            instructions="You are a Markdown Agent, output in markdown format",
+            llm="gpt-4o-mini",
+            self_reflect=False
+        )
+
+        # Generate content
+        response = markdown_agent.start(
+            "Write a blog post about artificial intelligence"
+        )
+        
+        # Save to file
+        with open('blog_post.md', 'w') as f:
+            f.write(response)
+        ```
+    </Step>
+</Steps>
+
+## Understanding Markdown Generation
+
+The Markdown Agent specializes in creating properly formatted Markdown content:
+
+1. **Content Generation**: Creates original content based on prompts
+2. **Markdown Formatting**: Applies proper Markdown syntax
+3. **Structure Validation**: Ensures correct formatting
+4. **Document Organization**: Creates well-structured documents
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Content Creation" icon="pen-to-square">
+    Generates original, well-structured content.
+  </Card>
+  <Card title="Markdown Syntax" icon="code">
+    Proper implementation of Markdown formatting.
+  </Card>
+  <Card title="Document Structure" icon="sitemap">
+    Organized document hierarchy and sections.
+  </Card>
+  <Card title="Format Validation" icon="check">
+    Ensures correct Markdown syntax usage.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Generate a technical documentation
+agent = Agent(
+    instructions="You are a Markdown Agent, output in markdown format"
+)
+
+# Generate API documentation
+response = agent.start("""
+    Create technical documentation for a REST API with:
+    - Introduction
+    - Authentication
+    - Endpoints
+    - Examples
+""")
+
+# Save documentation
+with open('api_docs.md', 'w') as f:
+    f.write(response)
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex document generation
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving content quality
+- Check out the [Documentation Agent](/agents/documentation) for specialized documentation generation

docs/agents/planning.mdx

@@ -0,0 +1,109 @@
+---
+title: "Planning Agent"
+sidebarTitle: "Planning"
+description: "Learn how to create AI agents for trip planning and itinerary generation."
+icon: "calendar"
+---
+
+```mermaid
+flowchart LR
+    In[Request] --> Search[Web Search]
+    Search --> Analyzer[Options Analyzer]
+    Analyzer --> Generator[Plan Generator]
+    Generator --> Out[Itinerary]
+    
+    style In fill:#8B0000,color:#fff
+    style Search fill:#2E8B57,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Planning Agent can search for travel options and create detailed itineraries.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `travel_planner.py`:
+        ```python
+        from praisonaiagents import Agent, Tools
+        from praisonaiagents.tools import duckduckgo
+
+        # Create Planning Agent
+        planning_agent = Agent(
+            name="TravelPlanner",
+            role="Travel Planning Specialist",
+            goal="Create comprehensive travel plans and itineraries",
+            instructions="You are a Planning Agent",
+            tools=[duckduckgo]
+        )
+
+        # Generate travel plan
+        response = planning_agent.start(
+            "I want to go to London next week, find me a good hotel and flight"
+        )
+        
+        # Save plan
+        with open('travel_plan.txt', 'w') as f:
+            f.write(response)
+        ```
+    </Step>
+</Steps>
+
+## Understanding Travel Planning
+
+The Planning Agent combines multiple capabilities to create comprehensive travel plans:
+
+1. **Web Search**: Uses DuckDuckGo to find current travel options
+2. **Options Analysis**: Evaluates and compares different choices
+3. **Plan Generation**: Creates detailed itineraries
+4. **Recommendations**: Provides personalized suggestions
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Flight Search" icon="plane">
+    Finds and compares flight options.
+  </Card>
+  <Card title="Hotel Booking" icon="hotel">
+    Recommends suitable accommodations.
+  </Card>
+  <Card title="Itinerary Creation" icon="calendar-days">
+    Generates detailed travel schedules.
+  </Card>
+  <Card title="Real-time Data" icon="clock">
+    Uses current pricing and availability.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Create a weekend trip plan
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Planning Agent", tools=[duckduckgo])
+agent.start("I want to go London next week, find me a good hotel and flight")
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex travel planning
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving recommendations
+- Check out the [Research Agent](/agents/research) for detailed destination research

docs/agents/programming.mdx

@@ -0,0 +1,125 @@
+---
+title: "Programming Agent"
+sidebarTitle: "Programming"
+description: "Learn how to create AI agents for code development, analysis, and execution."
+icon: "code"
+---
+
+```mermaid
+flowchart LR
+    In[Code Request] --> Analyzer[Code Analyzer]
+    Analyzer --> Generator[Code Generator]
+    Generator --> Executor[Code Executor]
+    Executor --> Debugger[Code Debugger]
+    Debugger --> Out[Output]
+    
+    style In fill:#8B0000,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Executor fill:#2E8B57,color:#fff
+    style Debugger fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Programming Agent can analyze, generate, execute, and debug code.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `code_assistant.py`:
+        ```python
+        from praisonaiagents import Agent, Tools
+        from praisonaiagents.tools import execute_code, analyze_code, format_code, lint_code, disassemble_code # Code Tools
+        from praisonaiagents.tools import execute_command, list_processes, kill_process, get_system_info # Shell Tools
+        from praisonaiagents.tools import duckduckgo # Web Search Tool
+
+        agent = Agent(
+            instructions="You are a Programming Agent", self_reflect=True, min_reflect=5, max_reflect=10, 
+            tools=[execute_code, analyze_code, format_code, lint_code, disassemble_code, execute_command, list_processes, kill_process, get_system_info, duckduckgo]
+        )
+        agent.start(
+            "Write a python script using yfinance to find the stock price of Tesla"
+            "First check if required packages are installed"
+            "Run it using execute_code"
+            "execute_command if you want to run any terminal command"
+            "search internet using duckduckgo if you want to know update python package information"
+            "Analyse the output using analyze_code and fix error if required"
+            "if no package is installed, install it"
+            "then run the code"
+        )
+        ```
+    </Step>
+</Steps>
+
+## Understanding Code Development
+
+The Programming Agent combines multiple tools for comprehensive code development:
+
+1. **Code Tools**:
+   - `execute_code`: Run Python code
+   - `analyze_code`: Analyze code structure
+   - `format_code`: Format code to standards
+   - `lint_code`: Check code quality
+   - `disassemble_code`: View bytecode
+
+2. **Shell Tools**:
+   - `execute_command`: Run terminal commands
+   - `list_processes`: View running processes
+   - `kill_process`: Terminate processes
+   - `get_system_info`: System information
+
+3. **Web Tools**:
+   - `duckduckgo`: Search for programming resources
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Code Execution" icon="play">
+    Run and test code directly.
+  </Card>
+  <Card title="Code Analysis" icon="magnifying-glass-code">
+    Analyze and improve code quality.
+  </Card>
+  <Card title="System Integration" icon="terminal">
+    Execute system commands and manage processes.
+  </Card>
+  <Card title="Package Management" icon="box">
+    Handle dependencies and installations.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Create and run a data analysis script
+response = agent.start("""
+    1. Create a script that:
+       - Uses pandas for data analysis
+       - Reads a CSV file
+       - Performs basic statistics
+       - Creates a visualization
+    2. Check and install required packages
+    3. Execute and analyze the results
+""")
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex development workflows
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving code quality
+- Check out the [Data Analyst Agent](/agents/data-analyst) for specialized data analysis

docs/agents/recommendation.mdx

@@ -0,0 +1,109 @@
+---
+title: "Recommendation Agent"
+sidebarTitle: "Recommendation"
+description: "Learn how to create AI agents for personalized recommendations across various domains."
+icon: "thumbs-up"
+---
+
+```mermaid
+flowchart LR
+    In[User Preferences] --> Search[Content Search]
+    Search --> Analyzer[Preference Analyzer]
+    Analyzer --> Generator[Recommendation Generator]
+    Generator --> Out[Recommendations]
+    
+    style In fill:#8B0000,color:#fff
+    style Search fill:#2E8B57,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Recommendation Agent can analyze preferences and generate personalized recommendations.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `recommendation_system.py`:
+        ```python
+        from praisonaiagents import Agent, Tools
+        from praisonaiagents.tools import duckduckgo
+
+        # Create Recommendation Agent
+        recommendation_agent = Agent(
+            name="RecommendationEngine",
+            role="Recommendation Specialist",
+            goal="Generate personalized recommendations based on preferences",
+            instructions="You are a Recommendation Agent",
+            tools=[duckduckgo]
+        )
+
+        # Get recommendations
+        response = recommendation_agent.start(
+            "Recommend me a good movie to watch in 2025"
+        )
+        
+        # Save recommendations
+        with open('recommendations.txt', 'w') as f:
+            f.write(response)
+        ```
+    </Step>
+</Steps>
+
+## Understanding Recommendation System
+
+The Recommendation Agent uses multiple approaches to generate personalized suggestions:
+
+1. **Content Search**: Uses DuckDuckGo to find current options
+2. **Preference Analysis**: Understands user preferences
+3. **Recommendation Generation**: Creates personalized suggestions
+4. **Content Filtering**: Filters based on relevance and quality
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Personalization" icon="user">
+    Tailored recommendations based on preferences.
+  </Card>
+  <Card title="Real-time Data" icon="clock">
+    Up-to-date content and information.
+  </Card>
+  <Card title="Multi-domain" icon="layer-group">
+    Recommendations across various categories.
+  </Card>
+  <Card title="Content Filtering" icon="filter">
+    Quality-based content selection.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Get personalized recommendations
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Recommendation Agent", tools=[duckduckgo])
+agent.start("Recommend me a good movie to watch in 2025")
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex recommendation systems
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving recommendation accuracy
+- Check out the [Research Agent](/agents/research) for detailed content research

docs/agents/research.mdx

@@ -0,0 +1,108 @@
+---
+title: "Research Agent"
+sidebarTitle: "Research"
+description: "Learn how to create AI agents for conducting comprehensive research and analysis."
+icon: "magnifying-glass-chart"
+---
+
+```mermaid
+flowchart LR
+    In[Research Query] --> Search[Web Search]
+    Search --> Analyzer[Content Analyzer]
+    Analyzer --> Synthesizer[Information Synthesizer]
+    Synthesizer --> Out[Research Report]
+    
+    style In fill:#8B0000,color:#fff
+    style Search fill:#2E8B57,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Synthesizer fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Research Agent can gather, analyze, and synthesize information from various sources.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `research_assistant.py`:
+        ```python
+        from praisonaiagents import Agent, Tools
+        from praisonaiagents.tools import duckduckgo
+
+        # Create Research Agent
+        research_agent = Agent(
+            name="ResearchAssistant",
+            role="Research Specialist",
+            goal="Conduct comprehensive research and analysis",
+            instructions="You are a Research Agent",
+            tools=[duckduckgo]
+        )
+
+        # Conduct research
+        response = research_agent.start(
+            "Research about AI developments in 2024"
+        )
+        
+        # Save research findings
+        with open('research_report.md', 'w') as f:
+            f.write(response)
+        ```
+    </Step>
+</Steps>
+
+## Understanding Research Process
+
+The Research Agent employs a systematic approach to information gathering and analysis:
+
+1. **Web Search**: Uses DuckDuckGo to find relevant sources
+2. **Content Analysis**: Evaluates source credibility and relevance
+3. **Information Synthesis**: Combines findings into coherent insights
+4. **Report Generation**: Creates structured research reports
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Web Research" icon="globe">
+    Comprehensive online information gathering.
+  </Card>
+  <Card title="Content Analysis" icon="microscope">
+    In-depth evaluation of sources.
+  </Card>
+  <Card title="Information Synthesis" icon="layer-group">
+    Integration of multiple sources.
+  </Card>
+  <Card title="Report Generation" icon="file-lines">
+    Structured research documentation.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Research Agent", tools=[duckduckgo])
+agent.start("Research about AI 2024")
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex research projects
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving research quality
+- Check out the [Data Analyst Agent](/agents/data-analyst) for data-driven research

docs/agents/shopping.mdx

@@ -0,0 +1,109 @@
+---
+title: "Shopping Agent"
+sidebarTitle: "Shopping"
+description: "Learn how to create AI agents for price comparison and shopping assistance."
+icon: "shop"
+---
+
+```mermaid
+flowchart LR
+    In[Product Query] --> Search[Store Search]
+    Search --> Analyzer[Price Analyzer]
+    Analyzer --> Comparator[Price Comparator]
+    Comparator --> Out[Price Report]
+    
+    style In fill:#8B0000,color:#fff
+    style Search fill:#2E8B57,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Comparator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Shopping Agent can search for products, compare prices, and provide shopping recommendations.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `shopping_assistant.py`:
+        ```python
+        from praisonaiagents import Agent, Tools
+        from praisonaiagents.tools import duckduckgo
+
+        # Create Shopping Agent
+        shopping_agent = Agent(
+            name="ShoppingAssistant",
+            role="Shopping Specialist",
+            goal="Find the best prices and deals across stores",
+            instructions="You are a Shopping Agent",
+            tools=[duckduckgo]
+        )
+
+        # Search for product prices
+        response = shopping_agent.start(
+            "I want to buy iPhone 16 Pro Max, check 5 stores and give me price in table"
+        )
+        
+        # Save price comparison
+        with open('price_comparison.md', 'w') as f:
+            f.write(response)
+        ```
+    </Step>
+</Steps>
+
+## Understanding Shopping Assistant
+
+The Shopping Agent combines multiple capabilities for effective price comparison:
+
+1. **Store Search**: Uses DuckDuckGo to find retailers
+2. **Price Analysis**: Gathers pricing information
+3. **Price Comparison**: Compares prices across stores
+4. **Deal Finding**: Identifies special offers and discounts
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Price Comparison" icon="scale-balanced">
+    Compare prices across multiple stores.
+  </Card>
+  <Card title="Deal Detection" icon="tag">
+    Find special offers and discounts.
+  </Card>
+  <Card title="Store Analysis" icon="store">
+    Evaluate retailer reliability.
+  </Card>
+  <Card title="Price Tracking" icon="chart-line">
+    Monitor price changes over time.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Compare product prices
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(instructions="You are a Shopping Agent", tools=[duckduckgo])
+agent.start("I want to buy iPhone 16 Pro Max, check 5 stores and give me price in table")
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex shopping research
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving price accuracy
+- Check out the [Research Agent](/agents/research) for detailed product research

docs/agents/single.mdx

@@ -0,0 +1,102 @@
+---
+title: "Single Agent"
+sidebarTitle: "Single"
+description: "Learn how to create a basic single-purpose AI agent for simple tasks."
+icon: "circle-1"
+---
+
+```mermaid
+flowchart LR
+    In[Input] --> Agent[Single Agent]
+    Agent --> Out[Output]
+    
+    style In fill:#8B0000,color:#fff
+    style Agent fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how to create and use a simple single-purpose agent.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `simple_agent.py`:
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="You are a Markdown Agent, output in markdown format")
+        agent.start("Write a blog post about AI")
+        ```
+    </Step>
+</Steps>
+
+## Understanding Single Agent
+
+The Single Agent is the simplest form of PraisonAI agent:
+
+1. **Simple Setup**: Minimal configuration required
+2. **Single Purpose**: Focused on one specific task
+3. **Direct Execution**: Straightforward input-output flow
+4. **No Dependencies**: No external tools required
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Simple Setup" icon="square-1">
+    Minimal configuration needed.
+  </Card>
+  <Card title="Focused Task" icon="bullseye">
+    Single-purpose execution.
+  </Card>
+  <Card title="Quick Start" icon="bolt">
+    Rapid implementation.
+  </Card>
+  <Card title="No Tools" icon="toolbox">
+    No external dependencies.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Create a content generation agent
+from praisonaiagents import Agent
+
+# Create content agent
+agent = Agent(
+    instructions="You are a Content Generation Agent, create engaging content"
+)
+
+# Generate content
+response = agent.start("""
+    Write a short story about:
+    - A future world
+    - With advanced AI
+    - And human collaboration
+""")
+
+# Save the story
+with open('ai_story.txt', 'w') as f:
+    f.write(response)
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for more complex workflows
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving output quality
+- Check out other specialized agents like the [Markdown Agent](/agents/markdown) for specific use cases

docs/agents/video.mdx

@@ -0,0 +1,149 @@
+---
+title: "Video Agent"
+sidebarTitle: "Video"
+description: "Learn how to create AI agents for video analysis and content understanding."
+icon: "video"
+---
+
+```mermaid
+flowchart LR
+    In[Video Input] --> Analyzer[Content Analyzer]
+    Analyzer --> Detector[Object Detector]
+    Detector --> Transcriber[Text Transcriber]
+    Transcriber --> Out[Analysis Report]
+    
+    style In fill:#8B0000,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Detector fill:#2E8B57,color:#fff
+    style Transcriber fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Video Agent can analyze video content, detect objects, and extract meaningful information.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `video_analyzer.py`:
+        ```python
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+
+        # Create Video Analysis Agent
+        video_agent = Agent(
+            name="VideoAnalyst",
+            role="Video Analysis Specialist",
+            goal="Analyze videos to extract meaningful information",
+            backstory="""You are an expert in computer vision and video analysis.
+            You excel at describing content, detecting objects, and understanding context.""",
+            llm="gpt-4o-mini",
+            self_reflect=False
+        )
+
+        # Create video analysis task
+        analysis_task = Task(
+            name="analyze_video",
+            description="""Analyze this video and provide:
+                1. Summary of main events
+                2. Key objects and people
+                3. Text and important information
+                4. Context and setting""",
+            expected_output="Comprehensive video analysis",
+            agent=video_agent,
+            images=["video.mp4"]
+        )
+
+        # Create PraisonAIAgents instance
+        agents = PraisonAIAgents(
+            agents=[video_agent],
+            tasks=[analysis_task],
+            process="sequential",
+            verbose=1
+        )
+
+        # Run analysis
+        agents.start()
+        ```
+    </Step>
+</Steps>
+
+## Understanding Video Analysis
+
+The Video Agent combines multiple capabilities for comprehensive video understanding:
+
+1. **Content Analysis**: Analyzes video scenes and events
+2. **Object Detection**: Identifies objects and people
+3. **Text Extraction**: Captures text shown in videos
+4. **Context Understanding**: Interprets settings and situations
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Scene Analysis" icon="film">
+    Detailed analysis of video scenes.
+  </Card>
+  <Card title="Object Detection" icon="cube">
+    Identification of objects and people.
+  </Card>
+  <Card title="Text Extraction" icon="closed-captioning">
+    Capture of text and captions.
+  </Card>
+  <Card title="Context Analysis" icon="sitemap">
+    Understanding of video context.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Analyze a presentation video
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+video_agent = Agent(
+    name="VideoAnalyst",
+    role="Video Analysis Specialist",
+    goal="Extract information from presentation videos",
+    llm="gpt-4o-mini"
+)
+
+# Create presentation analysis task
+presentation_task = Task(
+    name="analyze_presentation",
+    description="""Analyze this presentation video:
+        1. Extract key points
+        2. Capture slide content
+        3. Note speaker's main arguments
+        4. Summarize Q&A session""",
+    expected_output="Detailed presentation summary",
+    agent=video_agent,
+    images=["presentation.mp4"]
+)
+
+# Run analysis
+agents = PraisonAIAgents(
+    agents=[video_agent],
+    tasks=[presentation_task],
+    process="sequential"
+)
+agents.start()
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex video analysis
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving analysis accuracy
+- Check out the [Image Agent](/agents/image) for still image analysis

docs/agents/websearch.mdx

@@ -0,0 +1,124 @@
+---
+title: "Web Search Agent"
+sidebarTitle: "Web Search"
+description: "Learn how to create AI agents for intelligent web searching and information gathering."
+icon: "globe"
+---
+
+```mermaid
+flowchart LR
+    In[Search Query] --> Search[Web Search]
+    Search --> Filter[Content Filter]
+    Filter --> Summarizer[Content Summarizer]
+    Summarizer --> Out[Search Results]
+    
+    style In fill:#8B0000,color:#fff
+    style Search fill:#2E8B57,color:#fff
+    style Filter fill:#2E8B57,color:#fff
+    style Summarizer fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Web Search Agent can perform intelligent searches and process web content.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `web_search.py`:
+        ```python
+        from praisonaiagents import Agent, Tools
+        from praisonaiagents.tools import duckduckgo
+
+        # Create Web Search Agent
+        search_agent = Agent(
+            name="WebSearcher",
+            role="Web Search Specialist",
+            goal="Perform intelligent web searches and gather information",
+            instructions="You are a Web Search Agent",
+            tools=[duckduckgo]
+        )
+
+        # Perform search
+        response = search_agent.start(
+            "Search about AI developments in 2024"
+        )
+        
+        # Save search results
+        with open('search_results.md', 'w') as f:
+            f.write(response)
+        ```
+    </Step>
+</Steps>
+
+## Understanding Web Search
+
+The Web Search Agent employs sophisticated search strategies:
+
+1. **Query Processing**: Optimizes search queries
+2. **Content Filtering**: Filters relevant results
+3. **Information Extraction**: Extracts key information
+4. **Result Summarization**: Summarizes findings
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Smart Search" icon="magnifying-glass">
+    Intelligent query processing.
+  </Card>
+  <Card title="Content Filtering" icon="filter">
+    Relevance-based filtering.
+  </Card>
+  <Card title="Information Extraction" icon="scissors">
+    Key information extraction.
+  </Card>
+  <Card title="Result Summary" icon="list">
+    Concise result summaries.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Perform topic research
+from praisonaiagents import Agent, Tools
+from praisonaiagents.tools import duckduckgo
+
+agent = Agent(
+    instructions="You are a Web Search Agent",
+    tools=[duckduckgo]
+)
+
+# Research specific topic
+response = agent.start("""
+    Search for information about quantum computing:
+    - Recent breakthroughs
+    - Leading companies
+    - Current applications
+    - Future predictions
+""")
+
+# Save research results
+with open('quantum_computing_research.md', 'w') as f:
+    f.write(response)
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex search workflows
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving search relevance
+- Check out the [Research Agent](/agents/research) for comprehensive research capabilities

docs/agents/wikipedia.mdx

@@ -0,0 +1,139 @@
+---
+title: "Wikipedia Agent"
+sidebarTitle: "Wikipedia"
+description: "Learn how to create AI agents for searching and extracting information from Wikipedia."
+icon: "book"
+---
+
+```mermaid
+flowchart LR
+    In[Query] --> Search[Wiki Search]
+    Search --> Page[Page Retrieval]
+    Page --> Summary[Content Summary]
+    Summary --> Out[Knowledge Output]
+    
+    style In fill:#8B0000,color:#fff
+    style Search fill:#2E8B57,color:#fff
+    style Page fill:#2E8B57,color:#fff
+    style Summary fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how the Wikipedia Agent can search, retrieve, and summarize Wikipedia content.
+
+## Quick Start
+
+<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="Create Script">
+        Create a new file `wikipedia_assistant.py`:
+        ```python
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+        from praisonaiagents.tools import (
+            wiki_search,
+            wiki_summary,
+            wiki_page,
+            wiki_random,
+            wiki_language
+        )
+
+        # Create Wikipedia Agent
+        wiki_agent = Agent(
+            name="WikipediaAssistant",
+            role="Wikipedia Research Specialist",
+            goal="Extract and summarize Wikipedia content",
+            instructions="You are a Wikipedia Agent",
+            tools=[
+                wiki_search,
+                wiki_summary,
+                wiki_page,
+                wiki_random,
+                wiki_language
+            ],
+            self_reflect=True,
+            min_reflect=3,
+            max_reflect=5
+        )
+
+        # Research a topic
+        response = wiki_agent.start("""
+            What is the history of AI?
+            First search the history of AI
+            Read the page of the history of AI
+            Get the summary of the page
+        """)
+        
+        # Save research results
+        with open('ai_history.md', 'w') as f:
+            f.write(response)
+        ```
+    </Step>
+</Steps>
+
+## Understanding Wikipedia Research
+
+The Wikipedia Agent provides comprehensive Wikipedia access through multiple tools:
+
+1. **Wiki Search**: `wiki_search` for finding relevant articles
+2. **Page Access**: `wiki_page` for retrieving full articles
+3. **Summarization**: `wiki_summary` for concise overviews
+4. **Random Articles**: `wiki_random` for discovering content
+5. **Language Support**: `wiki_language` for multilingual access
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Article Search" icon="magnifying-glass">
+    Find relevant Wikipedia articles.
+  </Card>
+  <Card title="Content Retrieval" icon="book-open">
+    Access complete article content.
+  </Card>
+  <Card title="Summarization" icon="compress">
+    Generate concise article summaries.
+  </Card>
+  <Card title="Multilingual" icon="language">
+    Access content in multiple languages.
+  </Card>
+</CardGroup>
+
+## Example Usage
+
+```python
+# Example: Research a scientific topic
+from praisonaiagents import Agent
+from praisonaiagents.tools import wiki_search, wiki_summary, wiki_page, wiki_random, wiki_language
+
+agent = Agent(
+    instructions="You are a Wikipedia Agent", 
+    tools=[wiki_search, wiki_summary, wiki_page, wiki_random, wiki_language],
+    self_reflect=True,
+    min_reflect=3,
+    max_reflect=5,
+)
+agent.start(
+    "What is the history of AI?"
+    "First search the history of AI"
+    "Read the page of the history of AI"
+    "Get the summary of the page"
+)
+```
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining) for complex Wikipedia research
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) for improving research quality
+- Check out the [Research Agent](/agents/research) for broader research capabilities

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.39 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.0.48 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/concepts/agents.mdx

@@ -4,11 +4,8 @@ description: "Understanding Agents in PraisonAI"
 icon: "user"
 ---
 
-<Note>
-  Agents are the core building blocks of PraisonAI. Each agent is an autonomous AI entity with specific roles, goals, and capabilities.
-</Note>
-
 # Understanding Agents
+Agents are the core building blocks of PraisonAI. Each agent is an autonomous AI entity with specific roles, goals, and capabilities.
 
 ```mermaid
 graph LR
@@ -19,45 +16,34 @@ graph LR
     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[" "]
+    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[" "]
+    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
+
+    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
+    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
+    classDef tools fill:#2E8B57,stroke:#7C90A0,color:#fff
+    classDef transparent fill:none,stroke:none
+
+    class Start,Output,Task1,Task2 input
+    class Process,AgentIcon1,AgentIcon2 process
+    class Tools1,Tools2 tools
+    class Agent1,Agent2 transparent
 ```
 
 ## Key Components

docs/concepts/knowledge.mdx

@@ -0,0 +1,241 @@
+---
+title: "AI Agents with Knowledge"
+sidebarTitle: "Knowledge"
+description: "Learn how to create AI agents with custom knowledge bases"
+icon: "book"
+---
+
+```mermaid
+flowchart LR
+    subgraph In[Input]
+        PDF[PDF]
+        TXT[TXT]
+        MD[MD]
+    end
+
+    subgraph Router[Vector Store]
+        DB[(Chroma)]
+    end
+    
+    subgraph Out[Agents]
+        A1[Agent 1]
+        A2[Agent 2]
+        A3[Agent 3]
+    end
+
+    In --> Router
+    Router --> A1
+    Router --> A2
+    Router --> A3
+
+    style In fill:#8B0000,color:#fff
+    style Router fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+| Feature | [Knowledge](/concepts/knowledge) | [Memory](/concepts/memory) |
+|---------|--------------------------------|---------------------------|
+| When Used | Pre-loaded before agent execution | Created and updated during runtime |
+| Purpose | Provide static reference information | Store dynamic context and interactions |
+| Storage | Read-only knowledge base | Read-write memory store |
+| Persistence | Permanent until explicitly changed | Can be temporary (STM) or persistent (LTM) |
+| Updates | Manual updates through knowledge files | Automatic updates during agent execution |
+
+## Quick Start
+
+<Steps>
+  <Step title="Install Package">
+    Install PraisonAI Agents with knowledge support:
+    ```bash
+    pip install "praisonaiagents[knowledge]"
+    ```
+  </Step>
+
+  <Step title="Set API Key">
+    Set your OpenAI API key:
+    ```bash
+    export OPENAI_API_KEY=xxxxx
+    ```
+  </Step>
+
+  <Step title="Create Script">
+    Create a new file `app.py`:
+    ```python
+    from praisonaiagents import Agent
+
+    agent = Agent(
+        name="Knowledge Agent",
+        instructions="You answer questions based on the provided knowledge.",
+        knowledge=["small.pdf"]
+    )
+
+    agent.start("What is KAG in one line?")
+    ```
+  </Step>
+</Steps>
+
+## Basic Usage
+
+The simplest way to create a knowledge-based agent is without any configuration:
+
+```python
+from praisonaiagents import Agent
+
+agent = Agent(
+    name="Knowledge Agent",
+    instructions="You answer questions based on the provided knowledge.",
+    knowledge=["small.pdf"]
+)
+
+agent.start("What is KAG in one line?")
+```
+
+## Advanced Configuration
+
+For more control over the knowledge base, you can specify a configuration:
+
+```python
+from praisonaiagents import Agent
+
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "custom_knowledge",
+            "path": ".praison",
+        }
+    }
+}
+
+agent = Agent(
+    name="Knowledge Agent",
+    instructions="You answer questions based on the provided knowledge.",
+    knowledge=["small.pdf"],
+    knowledge_config=config
+)
+
+agent.start("What is KAG in one line?")
+```
+
+## Multi-Agent Knowledge System
+
+For more complex scenarios, you can create a knowledge-based system with multiple agents:
+
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import logging
+import os
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Define the configuration for the Knowledge instance
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "knowledge_test",
+            "path": ".praison",
+        }
+    }
+}
+
+# Create an agent with knowledge capabilities
+knowledge_agent = Agent(
+    name="KnowledgeAgent",
+    role="Information Specialist",
+    goal="Store and retrieve knowledge efficiently",
+    backstory="Expert in managing and utilizing stored knowledge",
+    knowledge=["sample.pdf"],
+    knowledge_config=config,
+    verbose=True
+)
+
+# Define a task for the agent
+knowledge_task = Task(
+    name="knowledge_task",
+    description="Who is Mervin Praison?",
+    expected_output="Answer to the question",
+    agent=knowledge_agent
+)
+
+# Create and start the agents
+agents = PraisonAIAgents(
+    agents=[knowledge_agent],
+    tasks=[knowledge_task],
+    process="sequential",
+    user_id="user1"
+)
+
+# Start execution
+result = agents.start()
+```
+
+## Understanding Knowledge Configuration
+
+<AccordionGroup>
+  <Accordion title="Vector Store Options">
+    - **Provider**: Choose between different vector store backends (e.g., "chroma")
+    - **Collection Name**: Name for your knowledge collection
+    - **Path**: Location to store the vector database
+  </Accordion>
+  
+  <Accordion title="Supported File Types">
+    - PDF documents (*.pdf)
+    - Text files (*.txt)
+    - Markdown files (*.md, *.mdx)
+    - And more...
+  </Accordion>
+
+  <Accordion title="Multi-Agent Setup">
+    - **Role**: Define specialized roles for knowledge agents
+    - **Goal**: Set specific knowledge management objectives
+    - **Process**: Choose between sequential or parallel execution
+  </Accordion>
+</AccordionGroup>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Custom Knowledge" icon="book">
+    Import your own documents and data as knowledge sources
+  </Card>
+  <Card title="Vector Storage" icon="database">
+    Efficient storage and retrieval of knowledge embeddings
+  </Card>
+  <Card title="Multiple Sources" icon="layer-group">
+    Combine multiple documents and file types
+  </Card>
+  <Card title="Persistent Storage" icon="hard-drive">
+    Save and reuse knowledge bases across sessions
+  </Card>
+</CardGroup>
+
+## Best Practices
+
+1. **Document Preparation**
+   - Clean and well-formatted documents work best
+   - Break large documents into smaller chunks
+   - Use consistent formatting
+
+2. **Knowledge Organization**
+   - Group related documents together
+   - Use meaningful file names
+   - Keep knowledge bases focused and relevant
+
+3. **Performance Optimization**
+   - Monitor vector store size
+   - Clean up unused collections
+   - Use appropriate chunk sizes
+
+4. **Multi-Agent Coordination**
+   - Define clear roles and responsibilities
+   - Set appropriate logging levels for debugging
+   - Use unique collection names for different agent groups
+
+## Next Steps
+
+- Learn about [Memory Management](/concepts/memory) for long-term recall
+- Explore [Tool Integration](/concepts/tools) for enhanced capabilities
+- Check out [Examples](/examples) for implementation ideas

docs/concepts/memory.mdx

@@ -5,6 +5,48 @@ description: "Learn how to create AI agents with memory capabilities for maintai
 icon: "brain"
 ---
 
+```mermaid
+flowchart TB
+    subgraph Memory
+        direction TB
+        STM[Short Term]
+        LTM[Long Term]
+    end
+
+    subgraph Store
+        direction TB
+        DB[(Vector DB)]
+    end
+
+    Input[Input] ---> Agents
+    subgraph Agents
+        direction LR
+        A1[Agent 1]
+        A2[Agent 2]
+        A3[Agent 3]
+    end
+    Agents ---> Output[Output]
+
+    Memory <--> Store
+    Store <--> A1
+    Store <--> A2
+    Store <--> A3
+
+    style Memory fill:#189AB4,color:#fff
+    style Store fill:#2E8B57,color:#fff
+    style Agents fill:#8B0000,color:#fff
+    style Input fill:#8B0000,color:#fff
+    style Output fill:#8B0000,color:#fff
+```
+
+| Feature | [Knowledge](/concepts/knowledge) | [Memory](/concepts/memory) |
+|---------|--------------------------------|---------------------------|
+| When Used | Pre-loaded before agent execution | Created and updated during runtime |
+| Purpose | Provide static reference information | Store dynamic context and interactions |
+| Storage | Read-only knowledge base | Read-write memory store |
+| Persistence | Permanent until explicitly changed | Can be temporary (STM) or persistent (LTM) |
+| Updates | Manual updates through knowledge files | Automatic updates during agent execution |
+
 ## Quick Start
 
 <Tabs>
@@ -396,16 +438,6 @@ PraisonAI's memory system includes several types of memory:
     - 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
@@ -437,5 +469,4 @@ 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

@@ -36,6 +36,24 @@ Process types in PraisonAI define how tasks are executed and how agents collabor
 
 ## Sequential Process
 
+```mermaid
+graph LR
+    Input[Input] --> A1
+    subgraph Agents
+        direction LR
+        A1[Agent 1] --> A2[Agent 2] --> A3[Agent 3]
+    end
+    A3 --> Output[Output]
+
+    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
+    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
+    classDef transparent fill:none,stroke:none
+
+    class Input,Output input
+    class A1,A2,A3 process
+    class Agents transparent
+```
+
 The simplest form of task execution where tasks are performed one after another.
 
 <Card>
@@ -57,6 +75,39 @@ The simplest form of task execution where tasks are performed one after another.
 
 ## Hierarchical Process
 
+```mermaid
+graph TB
+    Input[Input] --> Manager
+    
+    subgraph Agents
+        Manager[Manager Agent]
+        
+        subgraph Workers
+            direction LR
+            W1[Worker 1]
+            W2[Worker 2]
+            W3[Worker 3]
+        end
+        
+        Manager --> W1
+        Manager --> W2
+        Manager --> W3
+    end
+    
+    W1 --> Manager
+    W2 --> Manager
+    W3 --> Manager
+    Manager --> Output[Output]
+
+    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
+    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
+    classDef transparent fill:none,stroke:none
+
+    class Input,Output input
+    class Manager,W1,W2,W3 process
+    class Agents,Workers transparent
+```
+
 Uses a manager agent to coordinate task execution and agent assignments.
 
 <Card>
@@ -79,6 +130,33 @@ Uses a manager agent to coordinate task execution and agent assignments.
 
 ## Workflow Process
 
+```mermaid
+graph LR
+    Input[Input] --> Start
+    
+    subgraph Workflow
+        direction LR
+        Start[Start] --> C1{Condition}
+        C1 --> |Yes| A1[Agent 1]
+        C1 --> |No| A2[Agent 2]
+        A1 --> Join
+        A2 --> Join
+        Join --> A3[Agent 3]
+    end
+    
+    A3 --> Output[Output]
+
+    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
+    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
+    classDef decision fill:#2E8B57,stroke:#7C90A0,color:#fff
+    classDef transparent fill:none,stroke:none
+
+    class Input,Output input
+    class Start,A1,A2,A3,Join process
+    class C1 decision
+    class Workflow transparent
+```
+
 Advanced process type supporting complex task relationships and conditional execution.
 
 <Card>

docs/concepts/tasks.mdx

@@ -4,9 +4,36 @@ description: "Understanding Tasks in PraisonAI"
 icon: "list-check"
 ---
 
-<Note>
-  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
+Tasks are units of work that agents execute. Each task has a clear goal, input requirements, and expected outputs.
+
+```mermaid
+graph LR
+    Input[Input] ---> Task
+    
+    subgraph Task
+        direction LR
+        Role[Role]
+        Goal[Goal]
+        Story[Backstory]
+        Expected[Expected Output]
+        
+        Role --> Goal
+        Goal --> Story
+        Story --> Expected
+    end
+    
+    Task ---> Output[Output]
+
+    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
+    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
+    classDef tools fill:#2E8B57,stroke:#7C90A0,color:#fff
+    classDef transparent fill:none,stroke:none
+
+    class Input,Output input
+    class Role,Goal,Story,Expected process
+    class Task transparent
+```
 
 ## Core Components
 

docs/concepts/tools.mdx

@@ -1,12 +1,49 @@
 ---
-title: "Tools"
-description: "Understanding Tools in PraisonAI"
+title: "AI Agents with Tools"
+sidebarTitle: "Tools"
+description: "Learn how to create AI agents that can use tools to interact with external systems and perform actions."
 icon: "screwdriver-wrench"
 ---
 
-# Understanding Tools
+```mermaid
+flowchart TB
+    subgraph Tools
+        direction TB
+        T3[Internet Search]
+        T1[Code Execution]
+        T2[Formatting]
+    end
 
-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.
+    Input[Input] ---> Agents
+    subgraph Agents
+        direction LR
+        A1[Agent 1]
+        A2[Agent 2]
+        A3[Agent 3]
+    end
+    Agents ---> Output[Output]
+
+    T3 --> A1
+    T1 --> A2
+    T2 --> A3
+
+    style Tools fill:#189AB4,color:#fff
+    style Agents fill:#8B0000,color:#fff
+    style Input fill:#8B0000,color:#fff
+    style Output fill:#8B0000,color:#fff
+```
+
+| Feature | [Knowledge](/concepts/knowledge) | [Tools](/concepts/tools) |
+|---------|--------------------------------|---------------------------|
+| Purpose | Static reference information | Dynamic interaction capabilities |
+| Access | Read-only reference | Execute actions and commands |
+| Updates | Manual through files | Real-time through tool calls |
+| Storage | Knowledge base | Assigned to specific agents |
+| Persistence | Permanent until changed | Available during agent execution |
+
+## Quick Start
+
+Tools are functions that agents can use to interact with external systems and perform actions. They are essential for creating agents that can do more than just process text.
 
 ## Creating Custom Tool
 <Steps>

docs/examples/adaptive-learning.mdx

@@ -0,0 +1,244 @@
+---
+title: "Adaptive Learning"
+description: "Learn how to create AI agents for personalized adaptive learning experiences."
+icon: "graduation-cap"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Assessor[Student Assessor]
+    Assessor --> Generator[Content Generator]
+    Generator --> Evaluator[Performance Evaluator]
+    Evaluator --> Adapter[Difficulty Adapter]
+    Adapter --> |decrease/increase| Generator
+    Adapter --> |maintain| Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style Assessor fill:#2E8B57,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Evaluator fill:#2E8B57,color:#fff
+    style Adapter fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+Learn how to implement an adaptive learning system using AI agents for personalized education and dynamic content adjustment.
+
+## Quick Start
+
+<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
+import time
+from typing import Dict
+
+def assess_student_level():
+    """Simulates student assessment"""
+    levels = ["beginner", "intermediate", "advanced"]
+    current_time = int(time.time())
+    return levels[current_time % 3]
+
+def generate_content(level: str):
+    """Simulates content generation"""
+    content_types = {
+        "beginner": "basic concepts and examples",
+        "intermediate": "practice problems and applications",
+        "advanced": "complex scenarios and projects"
+    }
+    return content_types.get(level, "basic concepts")
+
+def evaluate_performance():
+    """Simulates performance evaluation"""
+    scores = ["low", "medium", "high"]
+    current_time = int(time.time())
+    return scores[current_time % 3]
+
+def adapt_difficulty(performance: str):
+    """Simulates difficulty adaptation"""
+    adaptations = {
+        "low": "decrease",
+        "medium": "maintain",
+        "high": "increase"
+    }
+    return adaptations.get(performance, "maintain")
+
+# Create specialized agents
+assessor = Agent(
+    name="Student Assessor",
+    role="Level Assessment",
+    goal="Assess student's current level",
+    instructions="Evaluate student's knowledge and skills",
+    tools=[assess_student_level]
+)
+
+generator = Agent(
+    name="Content Generator",
+    role="Content Creation",
+    goal="Generate appropriate learning content",
+    instructions="Create content based on student's level",
+    tools=[generate_content]
+)
+
+evaluator = Agent(
+    name="Performance Evaluator",
+    role="Performance Assessment",
+    goal="Evaluate student's performance",
+    instructions="Assess learning outcomes",
+    tools=[evaluate_performance]
+)
+
+adapter = Agent(
+    name="Difficulty Adapter",
+    role="Content Adaptation",
+    goal="Adapt content difficulty",
+    instructions="Adjust difficulty based on performance",
+    tools=[adapt_difficulty]
+)
+
+# Create workflow tasks
+assessment_task = Task(
+    name="assess_level",
+    description="Assess student's current level",
+    expected_output="Student's proficiency level",
+    agent=assessor,
+    is_start=True,
+    next_tasks=["generate_content"]
+)
+
+generation_task = Task(
+    name="generate_content",
+    description="Generate appropriate content",
+    expected_output="Learning content",
+    agent=generator,
+    next_tasks=["evaluate_performance"]
+)
+
+evaluation_task = Task(
+    name="evaluate_performance",
+    description="Evaluate student's performance",
+    expected_output="Performance assessment",
+    agent=evaluator,
+    next_tasks=["adapt_difficulty"]
+)
+
+adaptation_task = Task(
+    name="adapt_difficulty",
+    description="Adapt content difficulty",
+    expected_output="Difficulty adjustment",
+    agent=adapter,
+    task_type="decision",
+    condition={
+        "decrease": ["generate_content"],
+        "maintain": "",
+        "increase": ["generate_content"]
+    }
+)
+
+# Create workflow
+workflow = PraisonAIAgents(
+    agents=[assessor, generator, evaluator, adapter],
+    tasks=[assessment_task, generation_task, evaluation_task, adaptation_task],
+    process="workflow",
+    verbose=True
+)
+
+def main():
+    print("\nStarting Adaptive Learning Workflow...")
+    print("=" * 50)
+    
+    # Run workflow
+    results = workflow.start()
+    
+    # Print results
+    print("\nAdaptive Learning Results:")
+    print("=" * 50)
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"\nTask: {task_id}")
+            print(f"Result: {result.raw}")
+            print("-" * 50)
+
+if __name__ == "__main__":
+    main()
+```
+    </Step>
+
+    <Step title="Start Agents">
+        Run your adaptive learning system:
+        ```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>
+
+## Understanding Adaptive Learning
+
+<Card title="What is Adaptive Learning?" icon="question">
+  Adaptive learning enables:
+  - Personalized learning experiences
+  - Dynamic content adjustment
+  - Performance-based progression
+  - Continuous skill assessment
+  - Intelligent difficulty scaling
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Student Assessment" icon="user-graduate">
+    Evaluate student proficiency:
+    - Knowledge level assessment
+    - Skill gap identification
+    - Learning style analysis
+  </Card>
+  <Card title="Content Generation" icon="book">
+    Create personalized content:
+    - Level-appropriate materials
+    - Custom learning paths
+    - Interactive exercises
+  </Card>
+  <Card title="Performance Tracking" icon="chart-line">
+    Monitor learning progress:
+    - Real-time evaluation
+    - Progress tracking
+    - Achievement metrics
+  </Card>
+  <Card title="Dynamic Adaptation" icon="sliders">
+    Adjust learning experience:
+    - Difficulty scaling
+    - Content optimization
+    - Pace adjustment
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Prompt Chaining" icon="link" href="/features/promptchaining">
+    Learn about chaining prompts for complex workflows
+  </Card>
+  <Card title="Evaluator Optimizer" icon="gauge" href="/features/evaluator-optimiser">
+    Explore how to optimize and evaluate solutions
+  </Card>
+</CardGroup> 

docs/examples/code-review.mdx

@@ -0,0 +1,207 @@
+---
+title: "Code Review"
+sidebarTitle: "Code Review"
+description: "Learn how to create AI agents for automated code review and issue resolution."
+icon: "code"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Analyzer[Code Analyzer]
+    Analyzer --> Suggester[Fix Suggester]
+    Suggester --> Applier[Fix Applier]
+    Applier -->|fixed| Out[Out]
+    Applier -->|manual_review| Suggester
+    
+    style In fill:#8B0000,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Suggester fill:#2E8B57,color:#fff
+    style Applier fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how AI agents can automate code review, from analysis through fix suggestion and application.
+
+## Quick Start
+
+<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
+        import time
+        from typing import List, Dict
+
+        def analyze_code_changes():
+            """Simulates code analysis"""
+            issues = [
+                {"type": "style", "severity": "low", "file": "main.py"},
+                {"type": "security", "severity": "high", "file": "auth.py"},
+                {"type": "performance", "severity": "medium", "file": "data.py"}
+            ]
+            return issues[int(time.time()) % 3]
+
+        def suggest_fixes(issue: Dict):
+            """Simulates fix suggestions"""
+            fixes = {
+                "style": "Apply PEP 8 formatting",
+                "security": "Implement input validation",
+                "performance": "Use list comprehension"
+            }
+            return fixes.get(issue["type"], "Review manually")
+
+        def apply_automated_fix(fix: str):
+            """Simulates applying automated fixes"""
+            success = int(time.time()) % 2 == 0
+            return "fixed" if success else "manual_review"
+
+        # Create specialized agents
+        analyzer = Agent(
+            name="Code Analyzer",
+            role="Code analysis",
+            goal="Analyze code changes and identify issues",
+            instructions="Review code changes and report issues",
+            tools=[analyze_code_changes]
+        )
+
+        fix_suggester = Agent(
+            name="Fix Suggester",
+            role="Solution provider",
+            goal="Suggest fixes for identified issues",
+            instructions="Provide appropriate fix suggestions",
+            tools=[suggest_fixes]
+        )
+
+        fix_applier = Agent(
+            name="Fix Applier",
+            role="Fix implementation",
+            goal="Apply suggested fixes automatically when possible",
+            instructions="Implement suggested fixes and report results",
+            tools=[apply_automated_fix]
+        )
+
+        # Create workflow tasks
+        analysis_task = Task(
+            name="analyze_code",
+            description="Analyze code changes for issues",
+            expected_output="Identified code issues",
+            agent=analyzer,
+            is_start=True,
+            next_tasks=["suggest_fixes"]
+        )
+
+        suggestion_task = Task(
+            name="suggest_fixes",
+            description="Suggest fixes for identified issues",
+            expected_output="Fix suggestions",
+            agent=fix_suggester,
+            next_tasks=["apply_fixes"]
+        )
+
+        fix_task = Task(
+            name="apply_fixes",
+            description="Apply suggested fixes",
+            expected_output="Fix application status",
+            agent=fix_applier,
+            task_type="decision",
+            condition={
+                "fixed": "",
+                "manual_review": ["suggest_fixes"]  # Loop back for manual review
+            }
+        )
+
+        # Create workflow
+        workflow = PraisonAIAgents(
+            agents=[analyzer, fix_suggester, fix_applier],
+            tasks=[analysis_task, suggestion_task, fix_task],
+            process="workflow",
+            verbose=True
+        )
+
+        def main():
+            print("\nStarting Code Review Workflow...")
+            print("=" * 50)
+            
+            # Run workflow
+            results = workflow.start()
+            
+            # Print results
+            print("\nCode Review Results:")
+            print("=" * 50)
+            for task_id, result in results["task_results"].items():
+                if result:
+                    print(f"\nTask: {task_id}")
+                    print(f"Result: {result.raw}")
+                    print("-" * 50)
+
+        if __name__ == "__main__":
+            main()
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```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 Python
+</Note>
+
+## Understanding Code Review
+
+<Card title="What is Code Review?" icon="question">
+  Automated code review workflow enables:
+  - Automated issue detection
+  - Intelligent fix suggestions
+  - Automated fix application
+  - Manual review routing when needed
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Issue Detection" icon="magnifying-glass">
+    Automatically identify code issues and their severity.
+  </Card>
+  <Card title="Fix Suggestions" icon="lightbulb">
+    Generate appropriate fix suggestions based on issue type.
+  </Card>
+  <Card title="Automated Fixes" icon="wand-magic-sparkles">
+    Apply fixes automatically when possible.
+  </Card>
+  <Card title="Manual Review" icon="user-check">
+    Route complex issues for manual review.
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Prompt Chaining" icon="link" href="/features/promptchaining">
+    Learn about sequential prompt execution
+  </Card>
+  <Card title="Evaluator Optimizer" icon="magnifying-glass-chart" href="/features/evaluator-optimiser">
+    Explore optimization techniques
+  </Card>
+</CardGroup> 

docs/examples/customer-service.mdx

@@ -0,0 +1,206 @@
+---
+title: Customer Service
+sidebar_title: Customer Service
+icon: "user-group"
+---
+
+```mermaid
+flowchart LR
+  In[In] --> Classifier[Query Classifier]
+  Classifier --> Handler[Query Handler]
+  Handler --> Evaluator[Satisfaction Evaluator]
+  Evaluator --> Optimizer[Response Optimizer]
+  Optimizer --> Out[Out]
+  Optimizer --> Classifier
+  
+  style In fill:#8B0000,color:#fff
+  style Out fill:#8B0000,color:#fff
+  style Classifier fill:#2E8B57,color:#fff
+  style Handler fill:#2E8B57,color:#fff
+  style Evaluator fill:#2E8B57,color:#fff
+  style Optimizer fill:#2E8B57,color:#fff
+```
+
+Learn how to create AI agents for automated customer service and response optimization.
+
+## Quick Start
+
+1. Install the PraisonAI Agents package:
+```bash
+pip install praisonaiagents
+```
+
+2. Set your OpenAI API key:
+```bash
+export OPENAI_API_KEY=your_api_key_here
+```
+
+3. Create a file named `app.py`:
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import time
+from typing import Dict, List
+
+def classify_query():
+    """Simulates query classification"""
+    query_types = [
+        {"type": "technical", "priority": "high", "complexity": "complex"},
+        {"type": "billing", "priority": "medium", "complexity": "simple"},
+        {"type": "general", "priority": "low", "complexity": "simple"}
+    ]
+    return query_types[int(time.time()) % 3]
+
+def handle_query(query: Dict):
+    """Simulates query handling"""
+    responses = {
+        "technical": "Technical support solution provided",
+        "billing": "Billing inquiry resolved",
+        "general": "General information provided"
+    }
+    return responses.get(query["type"], "Query forwarded to specialist")
+
+def evaluate_satisfaction():
+    """Simulates satisfaction evaluation"""
+    scores = ["satisfied", "neutral", "unsatisfied"]
+    return scores[int(time.time()) % 3]
+
+def optimize_response(satisfaction: str):
+    """Simulates response optimization"""
+    optimizations = {
+        "satisfied": "maintain_approach",
+        "neutral": "minor_adjustments",
+        "unsatisfied": "major_revision"
+    }
+    return optimizations.get(satisfaction, "review_process")
+
+# Create specialized agents
+classifier = Agent(
+    name="Query Classifier",
+    role="Query Classification",
+    goal="Classify incoming customer queries",
+    instructions="Analyze and categorize customer queries",
+    tools=[classify_query]
+)
+
+handler = Agent(
+    name="Query Handler",
+    role="Query Resolution",
+    goal="Handle customer queries appropriately",
+    instructions="Provide appropriate responses to queries",
+    tools=[handle_query]
+)
+
+evaluator = Agent(
+    name="Satisfaction Evaluator",
+    role="Satisfaction Assessment",
+    goal="Evaluate customer satisfaction",
+    instructions="Assess response effectiveness",
+    tools=[evaluate_satisfaction]
+)
+
+optimizer = Agent(
+    name="Response Optimizer",
+    role="Service Optimization",
+    goal="Optimize service based on feedback",
+    instructions="Improve response strategies",
+    tools=[optimize_response]
+)
+
+# Create workflow tasks
+classification_task = Task(
+    name="classify_query",
+    description="Classify customer query",
+    expected_output="Query classification",
+    agent=classifier,
+    is_start=True,
+    task_type="decision",
+    condition={
+        "high": ["handle_query", "evaluate_satisfaction"],
+        "medium": ["handle_query", "evaluate_satisfaction"],
+        "low": ["handle_query"]
+    }
+)
+
+handling_task = Task(
+    name="handle_query",
+    description="Handle customer query",
+    expected_output="Query response",
+    agent=handler,
+    next_tasks=["evaluate_satisfaction"]
+)
+
+evaluation_task = Task(
+    name="evaluate_satisfaction",
+    description="Evaluate customer satisfaction",
+    expected_output="Satisfaction level",
+    agent=evaluator,
+    next_tasks=["optimize_response"]
+)
+
+optimization_task = Task(
+    name="optimize_response",
+    description="Optimize response strategy",
+    expected_output="Optimization recommendations",
+    agent=optimizer,
+    task_type="decision",
+    condition={
+        "major_revision": ["classify_query"],
+        "minor_adjustments": "",
+        "maintain_approach": ""
+    }
+)
+
+# Create workflow
+workflow = PraisonAIAgents(
+    agents=[classifier, handler, evaluator, optimizer],
+    tasks=[classification_task, handling_task, evaluation_task, optimization_task],
+    process="workflow",
+    verbose=True
+)
+
+def main():
+    print("\nStarting Customer Service Optimization Workflow...")
+    print("=" * 50)
+    
+    # Run workflow
+    results = workflow.start()
+    
+    # Print results
+    print("\nCustomer Service Results:")
+    print("=" * 50)
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"\nTask: {task_id}")
+            print(f"Result: {result.raw}")
+            print("-" * 50)
+
+if __name__ == "__main__":
+    main()
+```
+
+4. Run the system:
+```bash
+python app.py
+```
+
+<Note>
+**Requirements**
+- Python 3.10 or higher
+- OpenAI API key
+</Note>
+
+## Understanding Customer Service
+
+The customer service workflow demonstrates how AI agents can automate and optimize customer support operations. The system uses specialized agents to classify queries, handle responses, evaluate satisfaction, and continuously improve service quality through feedback-driven optimization.
+
+## Features
+
+- **Query Classification**: Automatically categorizes customer inquiries based on type, priority, and complexity
+- **Intelligent Response Handling**: Provides appropriate responses based on query classification
+- **Satisfaction Evaluation**: Assesses customer satisfaction with provided solutions
+- **Response Optimization**: Continuously improves service quality through feedback analysis
+
+## Next Steps
+
+- Learn about [Prompt Chaining](/features/promptchaining)
+- Explore [Evaluator Optimizer](/features/evaluator-optimiser) 

docs/examples/emergency-response.mdx

@@ -0,0 +1,241 @@
+---
+title: "Emergency Response"
+sidebarTitle: "Emergency Response"
+description: "Learn how to create AI agents for coordinated emergency response and resource management."
+icon: "truck-medical"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Router[Emergency Router]
+    Router -->|critical/high| Dispatcher[Resource Dispatcher]
+    Router -->|medium/low| Dispatcher
+    Dispatcher --> Monitor[Response Monitor]
+    Monitor -->|ongoing| Coordinator[Response Coordinator]
+    Monitor -->|completed| Out[Out]
+    Coordinator --> Out
+    
+    style In fill:#8B0000,color:#fff
+    style Router fill:#2E8B57,color:#fff
+    style Dispatcher fill:#2E8B57,color:#fff
+    style Monitor fill:#2E8B57,color:#fff
+    style Coordinator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how AI agents can coordinate emergency response, from initial assessment through resource dispatch and response monitoring.
+
+## Quick Start
+
+<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
+        import time
+        from typing import Dict, List
+
+        def assess_emergency(incident: Dict):
+            """Simulates emergency assessment"""
+            severity_levels = ["low", "medium", "high", "critical"]
+            current_time = int(time.time())
+            severity = severity_levels[current_time % 4]
+            print(f"Incident assessed with {severity} severity")
+            return severity
+
+        def dispatch_resources(severity: str):
+            """Simulates resource dispatch"""
+            resources = {
+                "low": ["local_police"],
+                "medium": ["local_police", "ambulance"],
+                "high": ["local_police", "ambulance", "fire"],
+                "critical": ["local_police", "ambulance", "fire", "special_units"]
+            }
+            dispatched = resources.get(severity, ["local_police"])
+            print(f"Dispatching resources: {dispatched}")
+            return dispatched
+
+        def monitor_response():
+            """Simulates response monitoring"""
+            current_time = int(time.time())
+            status = "completed" if current_time % 3 == 0 else "ongoing"
+            return status
+
+        # Create specialized agents
+        router = Agent(
+            name="Emergency Router",
+            role="Emergency Assessment",
+            goal="Evaluate emergency severity and type",
+            instructions="Assess incident and determine required response",
+            tools=[assess_emergency]
+        )
+
+        dispatcher = Agent(
+            name="Resource Dispatcher",
+            role="Resource Management",
+            goal="Coordinate and dispatch appropriate resources",
+            instructions="Deploy resources based on emergency assessment",
+            tools=[dispatch_resources]
+        )
+
+        monitor = Agent(
+            name="Response Monitor",
+            role="Response Tracking",
+            goal="Track response progress and effectiveness",
+            instructions="Monitor ongoing response and provide status updates",
+            tools=[monitor_response]
+        )
+
+        synthesizer = Agent(
+            name="Response Coordinator",
+            role="Response Synthesis",
+            goal="Coordinate multi-agency response",
+            instructions="Synthesize information and coordinate overall response"
+        )
+
+        # Create workflow tasks
+        assessment_task = Task(
+            name="assess_emergency",
+            description="Evaluate emergency severity and type",
+            expected_output="Emergency severity level",
+            agent=router,
+            is_start=True,
+            task_type="decision",
+            condition={
+                "critical": ["dispatch_resources", "monitor_response"],
+                "high": ["dispatch_resources", "monitor_response"],
+                "medium": ["dispatch_resources"],
+                "low": ["dispatch_resources"]
+            }
+        )
+
+        dispatch_task = Task(
+            name="dispatch_resources",
+            description="Deploy appropriate emergency resources",
+            expected_output="List of dispatched resources",
+            agent=dispatcher,
+            next_tasks=["monitor_response"]
+        )
+
+        monitor_task = Task(
+            name="monitor_response",
+            description="Track response progress",
+            expected_output="Response status",
+            agent=monitor,
+            task_type="decision",
+            condition={
+                "ongoing": ["coordinate_response"],
+                "completed": ""
+            }
+        )
+
+        coordinate_task = Task(
+            name="coordinate_response",
+            description="Coordinate overall emergency response",
+            expected_output="Coordinated response plan",
+            agent=synthesizer,
+            context=[assessment_task, dispatch_task, monitor_task]
+        )
+
+        # Create workflow
+        workflow = PraisonAIAgents(
+            agents=[router, dispatcher, monitor, synthesizer],
+            tasks=[assessment_task, dispatch_task, monitor_task, coordinate_task],
+            process="workflow",
+            verbose=True
+        )
+
+        def main():
+            # Simulate emergency incident
+            incident = {
+                "type": "fire",
+                "location": "123 Main St",
+                "reported_time": time.time()
+            }
+            
+            print("\nStarting Emergency Response Workflow...")
+            print("=" * 50)
+            
+            # Run workflow
+            results = workflow.start(initial_input=incident)
+            
+            # Print results
+            print("\nEmergency Response Results:")
+            print("=" * 50)
+            for task_id, result in results["task_results"].items():
+                if result:
+                    print(f"\nTask: {task_id}")
+                    print(f"Result: {result.raw}")
+                    print("-" * 50)
+
+        if __name__ == "__main__":
+            main()
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```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 Python
+</Note>
+
+## Understanding Emergency Response
+
+<Card title="What is Emergency Response?" icon="question">
+  Emergency response workflow enables:
+  - Dynamic severity assessment
+  - Automated resource dispatch
+  - Real-time response monitoring
+  - Multi-agency coordination
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Severity Assessment" icon="gauge-high">
+    Automatically evaluate incident severity and type.
+  </Card>
+  <Card title="Resource Management" icon="truck">
+    Dispatch appropriate resources based on severity.
+  </Card>
+  <Card title="Response Monitoring" icon="eye">
+    Track response progress and effectiveness.
+  </Card>
+  <Card title="Response Coordination" icon="people-group">
+    Coordinate multi-agency response efforts.
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Prompt Chaining" icon="link" href="/features/promptchaining">
+    Learn about sequential prompt execution
+  </Card>
+  <Card title="Evaluator Optimizer" icon="magnifying-glass-chart" href="/features/evaluator-optimiser">
+    Explore optimization techniques
+  </Card>
+</CardGroup> 

docs/examples/examples.mdx

@@ -0,0 +1,109 @@
+---
+title: "Examples"
+sidebarTitle: "Examples"
+description: "Explore real-world examples and use cases built with PraisonAI Agents."
+icon: "code"
+---
+
+## Use Cases
+
+<CardGroup cols={2}>
+  <Card 
+    title="Predictive Maintenance" 
+    icon="wrench" 
+    href="/examples/predictive-maintenance"
+  >
+    Learn how to create AI agents for predictive maintenance and equipment monitoring.
+  </Card>
+  
+  <Card 
+    title="Emergency Response" 
+    icon="truck-medical" 
+    href="/examples/emergency-response"
+  >
+    Learn how to create AI agents for coordinated emergency response and resource management.
+  </Card>
+
+  <Card 
+    title="Code Review" 
+    icon="code" 
+    href="/examples/code-review"
+  >
+    Learn how to create AI agents for automated code review and issue resolution.
+  </Card>
+
+  <Card 
+    title="Adaptive Learning" 
+    icon="graduation-cap" 
+    href="/examples/adaptive-learning"
+  >
+    Learn how to create AI agents for personalized adaptive learning experiences.
+  </Card>
+
+  <Card 
+    title="Supply Chain" 
+    icon="truck" 
+    href="/examples/supply-chain"
+  >
+    Learn how to create AI agents for supply chain risk management and mitigation.
+  </Card>
+
+  <Card 
+    title="Customer Service" 
+    icon="headset" 
+    href="/examples/customer-service"
+  >
+    Learn how to create AI agents for automated customer service and support.
+  </Card>
+
+  <Card 
+    title="Fraud Detection" 
+    icon="shield-check" 
+    href="/examples/fraud-detection"
+  >
+    Learn how to create AI agents for real-time fraud detection and alert management.
+  </Card>
+
+  <Card 
+    title="Healthcare Diagnosis" 
+    icon="stethoscope" 
+    href="/examples/healthcare-diagnosis"
+  >
+    Learn how to create AI agents for medical diagnosis and treatment recommendations.
+  </Card>
+
+  <Card 
+    title="Smart City" 
+    icon="city" 
+    href="/examples/smart-city"
+  >
+    Learn how to create AI agents for smart city resource optimization and management.
+  </Card>
+
+  <Card 
+    title="Multilingual Content" 
+    icon="language" 
+    href="/examples/multilingual-content"
+  >
+    Learn how to create AI agents for multilingual content generation and cultural adaptation.
+  </Card>
+</CardGroup>
+
+## What's Next?
+
+<CardGroup cols={2}>
+  <Card
+    title="Features"
+    icon="stars"
+    href="/features/promptchaining"
+  >
+    Explore advanced features like prompt chaining and parallel execution
+  </Card>
+  <Card
+    title="API Reference"
+    icon="code"
+    href="/api-reference"
+  >
+    View the complete API reference documentation
+  </Card>
+</CardGroup>

docs/examples/fraud-detection.mdx

@@ -0,0 +1,237 @@
+---
+title: "Fraud Detection"
+sidebarTitle: "Fraud Detection"
+description: "Learn how to create AI agents for real-time fraud detection and alert management."
+icon: "shield-check"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Analyzer[Transaction Analyzer]
+    Analyzer -->|high risk| Verifier[Identity Verifier]
+    Analyzer -->|all risks| Checker[Pattern Checker]
+    Checker --> Generator[Alert Generator]
+    Verifier --> Generator
+    Generator --> Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Verifier fill:#2E8B57,color:#fff
+    style Checker fill:#2E8B57,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how AI agents can detect fraud in real-time, from transaction analysis through alert generation.
+
+## Quick Start
+
+<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
+        import time
+        from typing import Dict, List
+        import asyncio
+
+        def analyze_transaction():
+            """Simulates transaction analysis"""
+            transactions = [
+                {"type": "credit_card", "amount": 5000, "location": "foreign", "risk": "high"},
+                {"type": "wire", "amount": 2000, "location": "domestic", "risk": "medium"},
+                {"type": "online", "amount": 500, "location": "domestic", "risk": "low"}
+            ]
+            return transactions[int(time.time()) % 3]
+
+        def check_patterns(transaction: Dict):
+            """Simulates pattern checking"""
+            patterns = {
+                "high": ["unusual_location", "large_amount"],
+                "medium": ["frequency_anomaly"],
+                "low": ["within_normal_limits"]
+            }
+            return patterns.get(transaction["risk"], ["unknown"])
+
+        def verify_identity():
+            """Simulates identity verification"""
+            results = ["verified", "suspicious", "failed"]
+            return results[int(time.time()) % 3]
+
+        def generate_alert(verification: str, patterns: List[str]):
+            """Simulates alert generation"""
+            if verification == "failed" or "unusual_location" in patterns:
+                return "high_priority_alert"
+            elif verification == "suspicious":
+                return "medium_priority_alert"
+            return "low_priority_alert"
+
+        # Create specialized agents
+        transaction_analyzer = Agent(
+            name="Transaction Analyzer",
+            role="Transaction Analysis",
+            goal="Analyze transactions for suspicious patterns",
+            instructions="Monitor and analyze financial transactions",
+            tools=[analyze_transaction]
+        )
+
+        pattern_checker = Agent(
+            name="Pattern Checker",
+            role="Pattern Detection",
+            goal="Identify suspicious patterns",
+            instructions="Check for known fraud patterns",
+            tools=[check_patterns]
+        )
+
+        identity_verifier = Agent(
+            name="Identity Verifier",
+            role="Identity Verification",
+            goal="Verify transaction identities",
+            instructions="Perform identity verification checks",
+            tools=[verify_identity]
+        )
+
+        alert_generator = Agent(
+            name="Alert Generator",
+            role="Alert Management",
+            goal="Generate appropriate alerts",
+            instructions="Create and prioritize alerts",
+            tools=[generate_alert]
+        )
+
+        # Create workflow tasks
+        analysis_task = Task(
+            name="analyze_transaction",
+            description="Analyze transaction details",
+            expected_output="Transaction analysis",
+            agent=transaction_analyzer,
+            is_start=True,
+            task_type="decision",
+            condition={
+                "high": ["check_patterns", "verify_identity"],
+                "medium": ["check_patterns"],
+                "low": ["check_patterns"]
+            }
+        )
+
+        pattern_task = Task(
+            name="check_patterns",
+            description="Check for suspicious patterns",
+            expected_output="Identified patterns",
+            agent=pattern_checker,
+            next_tasks=["generate_alert"],
+            async_execution=True
+        )
+
+        verification_task = Task(
+            name="verify_identity",
+            description="Verify transaction identity",
+            expected_output="Verification result",
+            agent=identity_verifier,
+            next_tasks=["generate_alert"],
+            async_execution=True
+        )
+
+        alert_task = Task(
+            name="generate_alert",
+            description="Generate fraud alert",
+            expected_output="Alert priority",
+            agent=alert_generator,
+            context=[pattern_task, verification_task]
+        )
+
+        # Create workflow
+        workflow = PraisonAIAgents(
+            agents=[transaction_analyzer, pattern_checker, identity_verifier, alert_generator],
+            tasks=[analysis_task, pattern_task, verification_task, alert_task],
+            process="workflow",
+            verbose=True
+        )
+
+        async def main():
+            print("\nStarting Fraud Detection Workflow...")
+            print("=" * 50)
+            
+            # Run workflow
+            results = await workflow.astart()
+            
+            # Print results
+            print("\nFraud Detection Results:")
+            print("=" * 50)
+            for task_id, result in results["task_results"].items():
+                if result:
+                    print(f"\nTask: {task_id}")
+                    print(f"Result: {result.raw}")
+                    print("-" * 50)
+
+        if __name__ == "__main__":
+            asyncio.run(main())
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```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 Python
+</Note>
+
+## Understanding Fraud Detection
+
+<Card title="What is Fraud Detection?" icon="question">
+  Automated fraud detection workflow enables:
+  - Real-time transaction monitoring
+  - Pattern-based detection
+  - Identity verification
+  - Prioritized alert generation
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Transaction Analysis" icon="magnifying-glass">
+    Analyze transactions for risk levels and suspicious patterns.
+  </Card>
+  <Card title="Pattern Detection" icon="chart-line">
+    Identify known fraud patterns and anomalies.
+  </Card>
+  <Card title="Identity Verification" icon="user-check">
+    Verify transaction identities for high-risk cases.
+  </Card>
+  <Card title="Alert Management" icon="bell">
+    Generate and prioritize fraud alerts.
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Prompt Chaining" icon="link" href="/features/promptchaining">
+    Learn about sequential prompt execution
+  </Card>
+  <Card title="Evaluator Optimizer" icon="magnifying-glass-chart" href="/features/evaluator-optimiser">
+    Explore optimization techniques
+  </Card>
+</CardGroup> 

docs/examples/healthcare-diagnosis.mdx

@@ -0,0 +1,278 @@
+---
+title: "Healthcare Diagnosis"
+description: "Learn how to create AI agents for automated medical diagnosis and treatment recommendations."
+icon: "stethoscope"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Symptoms[Symptom Analyzer]
+    Symptoms --> Labs[Lab Processor]
+    Symptoms --> History[History Analyzer]
+    Labs --> Diagnosis[Diagnosis Generator]
+    History --> Diagnosis
+    Diagnosis --> Treatment[Treatment Recommender]
+    Treatment --> Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style Symptoms fill:#2E8B57,color:#fff
+    style Labs fill:#2E8B57,color:#fff
+    style History fill:#2E8B57,color:#fff
+    style Diagnosis fill:#2E8B57,color:#fff
+    style Treatment fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+Learn how to implement an automated healthcare diagnosis system using AI agents for symptom analysis, lab processing, and treatment recommendations.
+
+## Quick Start
+
+<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
+import time
+from typing import Dict, List
+
+def analyze_symptoms():
+    """Simulates symptom analysis"""
+    cases = [
+        {"symptoms": ["fever", "cough", "fatigue"], "severity": "high", "duration": "5_days"},
+        {"symptoms": ["headache", "nausea"], "severity": "medium", "duration": "2_days"},
+        {"symptoms": ["rash", "itching"], "severity": "low", "duration": "1_week"}
+    ]
+    return cases[int(time.time()) % 3]
+
+def process_lab_results():
+    """Simulates lab result processing"""
+    results = [
+        {"blood_count": "abnormal", "inflammation": "high", "markers": "elevated"},
+        {"blood_count": "normal", "inflammation": "low", "markers": "normal"},
+        {"blood_count": "normal", "inflammation": "medium", "markers": "elevated"}
+    ]
+    return results[int(time.time()) % 3]
+
+def analyze_medical_history():
+    """Simulates medical history analysis"""
+    histories = [
+        {"chronic_conditions": True, "allergies": True, "risk_factors": "high"},
+        {"chronic_conditions": False, "allergies": True, "risk_factors": "medium"},
+        {"chronic_conditions": False, "allergies": False, "risk_factors": "low"}
+    ]
+    return histories[int(time.time()) % 3]
+
+def generate_diagnosis(symptoms: Dict, lab_results: Dict, history: Dict):
+    """Simulates diagnosis generation"""
+    if symptoms["severity"] == "high" and lab_results["markers"] == "elevated":
+        return {"diagnosis": "serious_condition", "confidence": "high"}
+    elif symptoms["severity"] == "medium" or lab_results["inflammation"] == "medium":
+        return {"diagnosis": "moderate_condition", "confidence": "medium"}
+    return {"diagnosis": "mild_condition", "confidence": "high"}
+
+def recommend_treatment(diagnosis: Dict):
+    """Simulates treatment recommendation"""
+    treatments = {
+        "serious_condition": ["immediate_intervention", "specialist_referral"],
+        "moderate_condition": ["medication", "follow_up"],
+        "mild_condition": ["rest", "observation"]
+    }
+    return treatments.get(diagnosis["diagnosis"], ["general_care"])
+
+# Create specialized agents
+symptom_analyzer = Agent(
+    name="Symptom Analyzer",
+    role="Symptom Analysis",
+    goal="Analyze patient symptoms",
+    instructions="Evaluate reported symptoms and their severity",
+    tools=[analyze_symptoms]
+)
+
+lab_processor = Agent(
+    name="Lab Processor",
+    role="Lab Analysis",
+    goal="Process laboratory results",
+    instructions="Analyze and interpret lab test results",
+    tools=[process_lab_results]
+)
+
+history_analyzer = Agent(
+    name="History Analyzer",
+    role="Medical History Analysis",
+    goal="Analyze patient medical history",
+    instructions="Review and assess patient medical history",
+    tools=[analyze_medical_history]
+)
+
+diagnosis_generator = Agent(
+    name="Diagnosis Generator",
+    role="Diagnosis Generation",
+    goal="Generate comprehensive diagnosis",
+    instructions="Combine all inputs to generate diagnosis",
+    tools=[generate_diagnosis]
+)
+
+treatment_recommender = Agent(
+    name="Treatment Recommender",
+    role="Treatment Planning",
+    goal="Recommend appropriate treatment",
+    instructions="Suggest treatment based on diagnosis",
+    tools=[recommend_treatment]
+)
+
+# Create workflow tasks
+symptom_task = Task(
+    name="analyze_symptoms",
+    description="Analyze patient symptoms",
+    expected_output="Symptom analysis",
+    agent=symptom_analyzer,
+    is_start=True,
+    task_type="decision",
+    condition={
+        "high": ["process_labs", "analyze_history"],
+        "medium": ["process_labs", "analyze_history"],
+        "low": ["process_labs"]
+    }
+)
+
+lab_task = Task(
+    name="process_labs",
+    description="Process lab results",
+    expected_output="Lab analysis",
+    agent=lab_processor,
+    next_tasks=["generate_diagnosis"]
+)
+
+history_task = Task(
+    name="analyze_history",
+    description="Analyze medical history",
+    expected_output="History analysis",
+    agent=history_analyzer,
+    next_tasks=["generate_diagnosis"]
+)
+
+diagnosis_task = Task(
+    name="generate_diagnosis",
+    description="Generate diagnosis",
+    expected_output="Diagnosis and confidence level",
+    agent=diagnosis_generator,
+    next_tasks=["recommend_treatment"],
+    context=[symptom_task, lab_task, history_task]
+)
+
+treatment_task = Task(
+    name="recommend_treatment",
+    description="Recommend treatment",
+    expected_output="Treatment recommendations",
+    agent=treatment_recommender,
+    context=[diagnosis_task]
+)
+
+# Create workflow
+workflow = PraisonAIAgents(
+    agents=[symptom_analyzer, lab_processor, history_analyzer, 
+            diagnosis_generator, treatment_recommender],
+    tasks=[symptom_task, lab_task, history_task, diagnosis_task, treatment_task],
+    process="workflow",
+    verbose=True
+)
+
+def main():
+    print("\nStarting Healthcare Diagnosis Workflow...")
+    print("=" * 50)
+    
+    # Run workflow
+    results = workflow.start()
+    
+    # Print results
+    print("\nDiagnosis Results:")
+    print("=" * 50)
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"\nTask: {task_id}")
+            print(f"Result: {result.raw}")
+            print("-" * 50)
+
+if __name__ == "__main__":
+    main()
+```
+    </Step>
+
+    <Step title="Start Agents">
+        Run your healthcare diagnosis system:
+        ```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>
+
+## Understanding Healthcare Diagnosis
+
+<Card title="What is Healthcare Diagnosis?" icon="question">
+  Healthcare diagnosis enables:
+  - Automated symptom analysis
+  - Lab result processing
+  - Medical history review
+  - Diagnosis generation
+  - Treatment recommendations
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Symptom Analysis" icon="stethoscope">
+    Analyze patient symptoms:
+    - Severity assessment
+    - Duration tracking
+    - Pattern recognition
+  </Card>
+  <Card title="Lab Processing" icon="flask">
+    Process medical tests:
+    - Blood count analysis
+    - Inflammation markers
+    - Test result interpretation
+  </Card>
+  <Card title="History Analysis" icon="book-medical">
+    Review medical history:
+    - Chronic conditions
+    - Allergies
+    - Risk factors
+  </Card>
+  <Card title="Treatment Planning" icon="prescription">
+    Generate treatment plans:
+    - Immediate interventions
+    - Medication recommendations
+    - Follow-up scheduling
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Prompt Chaining" icon="link" href="/features/promptchaining">
+    Learn about chaining prompts for complex workflows
+  </Card>
+  <Card title="Evaluator Optimizer" icon="gauge" href="/features/evaluator-optimiser">
+    Explore how to optimize and evaluate solutions
+  </Card>
+</CardGroup> 

docs/examples/multilingual-content.mdx

@@ -0,0 +1,276 @@
+---
+title: "Multilingual Content"
+description: "Learn how to create AI agents for multilingual content generation and cultural adaptation."
+icon: "language"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Generator[Content Generator]
+    Generator --> Translator[Content Translator]
+    Translator --> Cultural[Cultural Checker]
+    Cultural --> Adapter[Content Adapter]
+    Adapter --> Quality[Quality Assessor]
+    Quality --> Out[Out]
+    Quality --> Adapter
+    Quality --> Translator
+    
+    style In fill:#8B0000,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Translator fill:#2E8B57,color:#fff
+    style Cultural fill:#2E8B57,color:#fff
+    style Adapter fill:#2E8B57,color:#fff
+    style Quality fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+Learn how to implement a multilingual content generation system using AI agents for content creation, translation, cultural adaptation, and quality assurance.
+
+## Quick Start
+
+<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
+import time
+from typing import Dict, List
+
+def generate_base_content():
+    """Simulates base content generation"""
+    content_types = [
+        {"type": "marketing", "tone": "professional", "length": "medium"},
+        {"type": "technical", "tone": "formal", "length": "long"},
+        {"type": "social", "tone": "casual", "length": "short"}
+    ]
+    return content_types[int(time.time()) % 3]
+
+def translate_content(content: Dict):
+    """Simulates content translation"""
+    languages = ["spanish", "french", "german", "japanese", "chinese"]
+    translations = {lang: f"Translated content in {lang}" for lang in languages}
+    return translations
+
+def check_cultural_context(translations: Dict):
+    """Simulates cultural context verification"""
+    cultural_issues = {
+        "spanish": [],
+        "french": ["idiom_mismatch"],
+        "german": [],
+        "japanese": ["formality_level"],
+        "chinese": ["cultural_reference"]
+    }
+    return cultural_issues
+
+def adapt_content(issues: Dict):
+    """Simulates content adaptation"""
+    adaptations = {
+        "idiom_mismatch": "localized_expression",
+        "formality_level": "adjusted_tone",
+        "cultural_reference": "localized_reference"
+    }
+    return {lang: [adaptations[issue] for issue in issues] 
+            for lang, issues in issues.items() if issues}
+
+def quality_check():
+    """Simulates quality assessment"""
+    quality_levels = ["high", "medium", "needs_revision"]
+    return quality_levels[int(time.time()) % 3]
+
+# Create specialized agents
+content_generator = Agent(
+    name="Content Generator",
+    role="Base Content Creation",
+    goal="Generate high-quality base content",
+    instructions="Create engaging base content",
+    tools=[generate_base_content]
+)
+
+translator = Agent(
+    name="Content Translator",
+    role="Translation",
+    goal="Translate content accurately",
+    instructions="Translate content while maintaining meaning",
+    tools=[translate_content]
+)
+
+cultural_checker = Agent(
+    name="Cultural Checker",
+    role="Cultural Verification",
+    goal="Verify cultural appropriateness",
+    instructions="Check for cultural sensitivities",
+    tools=[check_cultural_context]
+)
+
+content_adapter = Agent(
+    name="Content Adapter",
+    role="Content Adaptation",
+    goal="Adapt content for cultural fit",
+    instructions="Modify content based on cultural context",
+    tools=[adapt_content]
+)
+
+quality_assessor = Agent(
+    name="Quality Assessor",
+    role="Quality Assessment",
+    goal="Ensure content quality",
+    instructions="Assess overall content quality",
+    tools=[quality_check]
+)
+
+# Create workflow tasks
+generation_task = Task(
+    name="generate_content",
+    description="Generate base content",
+    expected_output="Base content for translation",
+    agent=content_generator,
+    is_start=True,
+    next_tasks=["translate_content"]
+)
+
+translation_task = Task(
+    name="translate_content",
+    description="Translate content to target languages",
+    expected_output="Translated content",
+    agent=translator,
+    next_tasks=["check_cultural"]
+)
+
+cultural_task = Task(
+    name="check_cultural",
+    description="Check cultural appropriateness",
+    expected_output="Cultural context issues",
+    agent=cultural_checker,
+    next_tasks=["adapt_content"]
+)
+
+adaptation_task = Task(
+    name="adapt_content",
+    description="Adapt content for cultural fit",
+    expected_output="Culturally adapted content",
+    agent=content_adapter,
+    next_tasks=["assess_quality"]
+)
+
+quality_task = Task(
+    name="assess_quality",
+    description="Assess content quality",
+    expected_output="Quality assessment",
+    agent=quality_assessor,
+    task_type="decision",
+    condition={
+        "high": "",  # Complete workflow
+        "medium": ["adapt_content"],  # Minor revisions needed
+        "needs_revision": ["translate_content"]  # Major revisions needed
+    }
+)
+
+# Create workflow
+workflow = PraisonAIAgents(
+    agents=[content_generator, translator, cultural_checker, 
+            content_adapter, quality_assessor],
+    tasks=[generation_task, translation_task, cultural_task, 
+           adaptation_task, quality_task],
+    process="workflow",
+    verbose=True
+)
+
+def main():
+    print("\nStarting Multilingual Content Generation Workflow...")
+    print("=" * 50)
+    
+    # Run workflow
+    results = workflow.start()
+    
+    # Print results
+    print("\nContent Generation Results:")
+    print("=" * 50)
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"\nTask: {task_id}")
+            print(f"Result: {result.raw}")
+            print("-" * 50)
+
+if __name__ == "__main__":
+    main()
+```
+    </Step>
+
+    <Step title="Start Agents">
+        Run your multilingual content generation system:
+        ```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>
+
+## Understanding Multilingual Content Generation
+
+<Card title="What is Multilingual Content Generation?" icon="question">
+  Multilingual content generation enables:
+  - Base content creation
+  - Accurate translation
+  - Cultural context verification
+  - Content adaptation
+  - Quality assurance
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Content Generation" icon="pen">
+    Generate base content:
+    - Marketing content
+    - Technical documentation
+    - Social media posts
+  </Card>
+  <Card title="Translation" icon="language">
+    Translate content:
+    - Multiple languages
+    - Meaning preservation
+    - Context awareness
+  </Card>
+  <Card title="Cultural Adaptation" icon="globe">
+    Ensure cultural fit:
+    - Cultural sensitivity
+    - Idiom localization
+    - Reference adaptation
+  </Card>
+  <Card title="Quality Control" icon="check">
+    Quality assurance:
+    - Content assessment
+    - Revision workflow
+    - Continuous improvement
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Prompt Chaining" icon="link" href="/features/promptchaining">
+    Learn about chaining prompts for complex workflows
+  </Card>
+  <Card title="Evaluator Optimizer" icon="gauge" href="/features/evaluator-optimiser">
+    Explore how to optimize and evaluate solutions
+  </Card>
+</CardGroup> 

docs/examples/predictive-maintenance.mdx

@@ -0,0 +1,287 @@
+---
+title: "Predictive Maintenance"
+description: "Learn how to create AI agents for predictive maintenance and equipment monitoring."
+icon: "gear"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Monitor[Sensor Monitor]
+    Monitor --> Analyzer[Performance Analyzer]
+    Analyzer --> Detector[Anomaly Detector]
+    Detector --> Predictor[Failure Predictor]
+    Predictor -->|critical| Scheduler[Maintenance Scheduler]
+    Predictor -->|warning| Scheduler
+    Predictor -->|normal| Out[Out]
+    Scheduler --> Out
+    
+    style In fill:#8B0000,color:#fff
+    style Out fill:#8B0000,color:#fff
+    style Monitor fill:#2E8B57,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Detector fill:#2E8B57,color:#fff
+    style Predictor fill:#2E8B57,color:#fff
+    style Scheduler fill:#2E8B57,color:#fff
+```
+
+Learn how to implement a predictive maintenance system using AI agents for real-time equipment monitoring and maintenance scheduling.
+
+## Quick Start
+
+<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 `predictive_maintenance.py` with the basic setup:
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import time
+from typing import Dict, List
+import asyncio
+
+def collect_sensor_data():
+    """Simulates sensor data collection"""
+    sensor_readings = {
+        "temperature": 75 + (int(time.time()) % 20),
+        "vibration": 0.5 + (int(time.time()) % 10) / 10,
+        "pressure": 100 + (int(time.time()) % 50),
+        "noise_level": 60 + (int(time.time()) % 30)
+    }
+    return sensor_readings
+
+def analyze_performance():
+    """Simulates performance analysis"""
+    metrics = {
+        "efficiency": 0.8 + (int(time.time()) % 20) / 100,
+        "uptime": 0.95 + (int(time.time()) % 5) / 100,
+        "output_quality": 0.9 + (int(time.time()) % 10) / 100
+    }
+    return metrics
+
+def detect_anomalies(sensor_data: Dict, performance: Dict):
+    """Simulates anomaly detection"""
+    anomalies = []
+    if sensor_data["temperature"] > 90:
+        anomalies.append({"type": "temperature_high", "severity": "critical"})
+    if sensor_data["vibration"] > 1.2:
+        anomalies.append({"type": "vibration_excess", "severity": "warning"})
+    if performance["efficiency"] < 0.85:
+        anomalies.append({"type": "efficiency_low", "severity": "warning"})
+    return anomalies
+
+def predict_failures(anomalies: List[Dict]):
+    """Simulates failure prediction"""
+    predictions = []
+    severity_scores = {"critical": 0.9, "warning": 0.6}
+    
+    for anomaly in anomalies:
+        predictions.append({
+            "component": anomaly["type"].split("_")[0],
+            "probability": severity_scores[anomaly["severity"]],
+            "timeframe": "24_hours" if anomaly["severity"] == "critical" else "7_days"
+        })
+    return predictions
+
+def schedule_maintenance(predictions: List[Dict]):
+    """Simulates maintenance scheduling"""
+    schedule = []
+    for pred in predictions:
+        schedule.append({
+            "component": pred["component"],
+            "priority": "immediate" if pred["timeframe"] == "24_hours" else "planned",
+            "estimated_duration": "2_hours",
+            "required_parts": ["replacement_" + pred["component"]]
+        })
+    return schedule
+
+# Create specialized agents
+sensor_monitor = Agent(
+    name="Sensor Monitor",
+    role="Data Collection",
+    goal="Collect sensor data",
+    instructions="Monitor and collect sensor readings",
+    tools=[collect_sensor_data]
+)
+
+performance_analyzer = Agent(
+    name="Performance Analyzer",
+    role="Performance Analysis",
+    goal="Analyze equipment performance",
+    instructions="Analyze operational metrics",
+    tools=[analyze_performance]
+)
+
+anomaly_detector = Agent(
+    name="Anomaly Detector",
+    role="Anomaly Detection",
+    goal="Detect operational anomalies",
+    instructions="Identify abnormal patterns",
+    tools=[detect_anomalies]
+)
+
+failure_predictor = Agent(
+    name="Failure Predictor",
+    role="Failure Prediction",
+    goal="Predict potential failures",
+    instructions="Predict equipment failures",
+    tools=[predict_failures]
+)
+
+maintenance_scheduler = Agent(
+    name="Maintenance Scheduler",
+    role="Maintenance Planning",
+    goal="Schedule maintenance activities",
+    instructions="Plan and schedule maintenance",
+    tools=[schedule_maintenance]
+)
+
+# Create workflow tasks
+sensor_task = Task(
+    name="collect_data",
+    description="Collect sensor data",
+    expected_output="Sensor readings",
+    agent=sensor_monitor,
+    is_start=True,
+    next_tasks=["analyze_performance"],
+    async_execution=True
+)
+
+performance_task = Task(
+    name="analyze_performance",
+    description="Analyze performance metrics",
+    expected_output="Performance analysis",
+    agent=performance_analyzer,
+    next_tasks=["detect_anomalies"],
+    async_execution=True
+)
+
+anomaly_task = Task(
+    name="detect_anomalies",
+    description="Detect operational anomalies",
+    expected_output="Detected anomalies",
+    agent=anomaly_detector,
+    next_tasks=["predict_failures"],
+    context=[sensor_task, performance_task]
+)
+
+prediction_task = Task(
+    name="predict_failures",
+    description="Predict potential failures",
+    expected_output="Failure predictions",
+    agent=failure_predictor,
+    next_tasks=["schedule_maintenance"],
+    task_type="decision",
+    condition={
+        "critical": ["schedule_maintenance"],
+        "warning": ["schedule_maintenance"],
+        "normal": ""
+    }
+)
+
+scheduling_task = Task(
+    name="schedule_maintenance",
+    description="Schedule maintenance activities",
+    expected_output="Maintenance schedule",
+    agent=maintenance_scheduler,
+    context=[prediction_task]
+)
+
+# Create workflow
+workflow = PraisonAIAgents(
+    agents=[sensor_monitor, performance_analyzer, anomaly_detector,
+            failure_predictor, maintenance_scheduler],
+    tasks=[sensor_task, performance_task, anomaly_task,
+           prediction_task, scheduling_task],
+    process="workflow",
+    verbose=True
+)
+
+async def main():
+    print("\nStarting Predictive Maintenance Workflow...")
+    print("=" * 50)
+    
+    # Run workflow
+    results = await workflow.astart()
+    
+    # Print results
+    print("\nMaintenance Planning Results:")
+    print("=" * 50)
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"\nTask: {task_id}")
+            print(f"Result: {result.raw}")
+            print("-" * 50)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+    </Step>
+
+    <Step title="Start Agents">
+        Run your predictive maintenance system:
+        ```bash
+        python predictive_maintenance.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>
+
+## Understanding Predictive Maintenance
+
+<Card title="What is Predictive Maintenance?" icon="question">
+  Predictive maintenance using AI agents enables:
+  - Real-time equipment monitoring
+  - Performance analysis and anomaly detection
+  - Failure prediction and prevention
+  - Automated maintenance scheduling
+  - Optimized resource allocation
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Real-time Monitoring" icon="gauge-high">
+    Continuous monitoring of equipment sensors and performance metrics.
+  </Card>
+  <Card title="Anomaly Detection" icon="triangle-exclamation">
+    Automated detection of abnormal patterns and potential issues.
+  </Card>
+  <Card title="Failure Prediction" icon="chart-line">
+    Advanced analytics to predict potential equipment failures.
+  </Card>
+  <Card title="Maintenance Planning" icon="calendar">
+    Automated scheduling of maintenance activities based on predictions.
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Prompt Chaining" icon="link" href="/features/promptchaining">
+    Learn about sequential prompt chaining for complex workflows
+  </Card>
+  <Card title="Evaluator Optimizer" icon="magnifying-glass" href="/features/evaluator-optimiser">
+    Explore how to optimize agent outputs through evaluation
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal results, ensure your sensor data collection and analysis parameters are properly configured for your specific equipment.
+</Note> 

docs/examples/smart-city.mdx

@@ -0,0 +1,301 @@
+---
+title: "Smart City"
+description: "Learn how to create AI agents for smart city resource management and optimization."
+icon: "city"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Monitor[Utility Monitor]
+    Monitor --> Analyzer[Pattern Analyzer]
+    Analyzer --> Optimizer[Resource Optimizer]
+    Optimizer --> Implementation[Implementation Agent]
+    Implementation --> Feedback[Feedback Monitor]
+    Feedback --> Monitor
+    Feedback --> Optimizer
+    Feedback --> Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style Monitor fill:#2E8B57,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Optimizer fill:#2E8B57,color:#fff
+    style Implementation fill:#2E8B57,color:#fff
+    style Feedback fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+Learn how to implement a smart city resource management system using AI agents for monitoring, analysis, and optimization of city utilities.
+
+## Quick Start
+
+<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
+import time
+from typing import Dict, List
+
+def monitor_utilities():
+    """Simulates utility usage monitoring"""
+    readings = {
+        "power": {
+            "consumption": int(time.time()) % 1000,
+            "peak_hours": ["morning", "evening"],
+            "grid_load": "medium"
+        },
+        "water": {
+            "consumption": int(time.time()) % 500,
+            "pressure": "normal",
+            "quality": "good"
+        },
+        "traffic": {
+            "congestion": "high",
+            "peak_zones": ["downtown", "industrial"],
+            "incidents": 2
+        }
+    }
+    return readings
+
+def analyze_patterns():
+    """Simulates usage pattern analysis"""
+    patterns = [
+        {"type": "daily_cycle", "confidence": 0.85, "trend": "increasing"},
+        {"type": "weekly_cycle", "confidence": 0.92, "trend": "stable"},
+        {"type": "seasonal", "confidence": 0.78, "trend": "decreasing"}
+    ]
+    return patterns[int(time.time()) % 3]
+
+def optimize_resources(readings: Dict, patterns: Dict):
+    """Simulates resource optimization"""
+    optimizations = {
+        "power": {
+            "action": "load_balancing",
+            "target_zones": ["residential", "commercial"],
+            "expected_savings": "15%"
+        },
+        "water": {
+            "action": "pressure_adjustment",
+            "target_zones": ["industrial"],
+            "expected_savings": "8%"
+        },
+        "traffic": {
+            "action": "signal_timing",
+            "target_zones": ["downtown"],
+            "expected_impact": "20% reduction"
+        }
+    }
+    return optimizations
+
+def implement_changes(optimizations: Dict):
+    """Simulates implementation of optimization changes"""
+    success_rates = {
+        "load_balancing": 0.95,
+        "pressure_adjustment": 0.88,
+        "signal_timing": 0.85
+    }
+    return {"status": "implemented", "success_rate": success_rates[optimizations["power"]["action"]]}
+
+def monitor_feedback():
+    """Simulates monitoring of optimization feedback"""
+    feedbacks = ["positive", "neutral", "negative"]
+    return feedbacks[int(time.time()) % 3]
+
+# Create specialized agents
+utility_monitor = Agent(
+    name="Utility Monitor",
+    role="Resource Monitoring",
+    goal="Monitor city utility usage",
+    instructions="Track and report utility consumption patterns",
+    tools=[monitor_utilities]
+)
+
+pattern_analyzer = Agent(
+    name="Pattern Analyzer",
+    role="Pattern Analysis",
+    goal="Analyze usage patterns",
+    instructions="Identify and analyze resource usage patterns",
+    tools=[analyze_patterns]
+)
+
+resource_optimizer = Agent(
+    name="Resource Optimizer",
+    role="Resource Optimization",
+    goal="Optimize resource allocation",
+    instructions="Generate resource optimization strategies",
+    tools=[optimize_resources]
+)
+
+implementation_agent = Agent(
+    name="Implementation Agent",
+    role="Change Implementation",
+    goal="Implement optimization changes",
+    instructions="Execute optimization strategies",
+    tools=[implement_changes]
+)
+
+feedback_monitor = Agent(
+    name="Feedback Monitor",
+    role="Feedback Monitoring",
+    goal="Monitor optimization results",
+    instructions="Track and analyze optimization feedback",
+    tools=[monitor_feedback]
+)
+
+# Create workflow tasks
+monitoring_task = Task(
+    name="monitor_utilities",
+    description="Monitor utility usage",
+    expected_output="Current utility readings",
+    agent=utility_monitor,
+    is_start=True,
+    next_tasks=["analyze_patterns"]
+)
+
+pattern_task = Task(
+    name="analyze_patterns",
+    description="Analyze usage patterns",
+    expected_output="Usage patterns analysis",
+    agent=pattern_analyzer,
+    next_tasks=["optimize_resources"]
+)
+
+optimization_task = Task(
+    name="optimize_resources",
+    description="Generate optimization strategies",
+    expected_output="Resource optimization plans",
+    agent=resource_optimizer,
+    next_tasks=["implement_changes"],
+    context=[monitoring_task, pattern_task]
+)
+
+implementation_task = Task(
+    name="implement_changes",
+    description="Implement optimization changes",
+    expected_output="Implementation status",
+    agent=implementation_agent,
+    next_tasks=["monitor_feedback"]
+)
+
+feedback_task = Task(
+    name="monitor_feedback",
+    description="Monitor optimization feedback",
+    expected_output="Optimization feedback",
+    agent=feedback_monitor,
+    task_type="decision",
+    condition={
+        "negative": ["monitor_utilities"],  # Start over if negative feedback
+        "neutral": ["optimize_resources"],  # Adjust optimization if neutral
+        "positive": ""  # End workflow if positive
+    }
+)
+
+# Create workflow
+workflow = PraisonAIAgents(
+    agents=[utility_monitor, pattern_analyzer, resource_optimizer, 
+            implementation_agent, feedback_monitor],
+    tasks=[monitoring_task, pattern_task, optimization_task, 
+           implementation_task, feedback_task],
+    process="workflow",
+    verbose=True
+)
+
+def main():
+    print("\nStarting Smart City Resource Optimization Workflow...")
+    print("=" * 50)
+    
+    # Run workflow
+    results = workflow.start()
+    
+    # Print results
+    print("\nOptimization Results:")
+    print("=" * 50)
+    for task_id, result in results["task_results"].items():
+        if result:
+            print(f"\nTask: {task_id}")
+            print(f"Result: {result.raw}")
+            print("-" * 50)
+
+if __name__ == "__main__":
+    main()
+```
+    </Step>
+
+    <Step title="Start Agents">
+        Run your smart city management system:
+        ```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>
+
+## Understanding Smart City Management
+
+<Card title="What is Smart City Management?" icon="question">
+  Smart city management enables:
+  - Real-time utility monitoring
+  - Pattern analysis and prediction
+  - Resource optimization
+  - Automated implementation
+  - Continuous feedback monitoring
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Utility Monitoring" icon="gauge">
+    Monitor city utilities:
+    - Power consumption
+    - Water usage
+    - Traffic patterns
+  </Card>
+  <Card title="Pattern Analysis" icon="chart-line">
+    Analyze usage patterns:
+    - Daily cycles
+    - Weekly trends
+    - Seasonal variations
+  </Card>
+  <Card title="Resource Optimization" icon="sliders">
+    Optimize resource allocation:
+    - Load balancing
+    - Pressure adjustment
+    - Traffic signal timing
+  </Card>
+  <Card title="Feedback Loop" icon="rotate">
+    Continuous improvement:
+    - Implementation tracking
+    - Success rate monitoring
+    - Adaptive optimization
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Prompt Chaining" icon="link" href="/features/promptchaining">
+    Learn about chaining prompts for complex workflows
+  </Card>
+  <Card title="Evaluator Optimizer" icon="gauge" href="/features/evaluator-optimiser">
+    Explore how to optimize and evaluate solutions
+  </Card>
+</CardGroup> 

docs/examples/supply-chain.mdx

@@ -0,0 +1,211 @@
+---
+title: "Supply Chain"
+sidebarTitle: "Supply Chain"
+description: "Learn how to create AI agents for supply chain risk management and mitigation."
+icon: "truck"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Monitor[Global Monitor]
+    Monitor -->|high/medium/critical| Analyzer[Impact Analyzer]
+    Analyzer --> Generator[Strategy Generator]
+    Generator --> Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style Monitor fill:#2E8B57,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow demonstrating how AI agents can monitor global events, analyze supply chain impacts, and generate mitigation strategies.
+
+## Quick Start
+
+<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
+        import time
+        from typing import Dict, List
+
+        def monitor_global_events():
+            """Simulates monitoring of global events"""
+            events = [
+                {"type": "natural_disaster", "severity": "high", "region": "Asia"},
+                {"type": "political_unrest", "severity": "medium", "region": "Europe"},
+                {"type": "economic_crisis", "severity": "critical", "region": "Americas"}
+            ]
+            return events[int(time.time()) % 3]
+
+        def analyze_supply_impact(event: Dict):
+            """Simulates impact analysis on supply chain"""
+            impact_matrix = {
+                "natural_disaster": {"delay": "severe", "cost": "high", "risk_level": 9},
+                "political_unrest": {"delay": "moderate", "cost": "medium", "risk_level": 6},
+                "economic_crisis": {"delay": "significant", "cost": "extreme", "risk_level": 8}
+            }
+            return impact_matrix.get(event["type"])
+
+        def generate_mitigation_strategies(impact: Dict):
+            """Simulates generation of mitigation strategies"""
+            strategies = {
+                "severe": ["activate_backup_suppliers", "emergency_logistics_routing"],
+                "moderate": ["increase_buffer_stock", "alternative_transport"],
+                "significant": ["diversify_suppliers", "hedge_currency_risks"]
+            }
+            return strategies.get(impact["delay"], ["review_supply_chain"])
+
+        # Create specialized agents
+        monitor_agent = Agent(
+            name="Global Monitor",
+            role="Event Monitoring",
+            goal="Monitor and identify global events affecting supply chain",
+            instructions="Track and report significant global events",
+            tools=[monitor_global_events]
+        )
+
+        impact_analyzer = Agent(
+            name="Impact Analyzer",
+            role="Impact Assessment",
+            goal="Analyze event impact on supply chain",
+            instructions="Assess potential disruptions and risks",
+            tools=[analyze_supply_impact]
+        )
+
+        strategy_generator = Agent(
+            name="Strategy Generator",
+            role="Strategy Development",
+            goal="Generate mitigation strategies",
+            instructions="Develop strategies to address identified risks",
+            tools=[generate_mitigation_strategies]
+        )
+
+        # Create workflow tasks
+        monitoring_task = Task(
+            name="monitor_events",
+            description="Monitor global events affecting supply chain",
+            expected_output="Identified global events",
+            agent=monitor_agent,
+            is_start=True,
+            task_type="decision",
+            condition={
+                "high": ["analyze_impact"],
+                "medium": ["analyze_impact"],
+                "critical": ["analyze_impact"]
+            }
+        )
+
+        impact_task = Task(
+            name="analyze_impact",
+            description="Analyze impact on supply chain",
+            expected_output="Impact assessment",
+            agent=impact_analyzer,
+            next_tasks=["generate_strategies"]
+        )
+
+        strategy_task = Task(
+            name="generate_strategies",
+            description="Generate mitigation strategies",
+            expected_output="List of mitigation strategies",
+            agent=strategy_generator,
+            context=[monitoring_task, impact_task]
+        )
+
+        # Create workflow
+        workflow = PraisonAIAgents(
+            agents=[monitor_agent, impact_analyzer, strategy_generator],
+            tasks=[monitoring_task, impact_task, strategy_task],
+            process="workflow",
+            verbose=True
+        )
+
+        def main():
+            print("\nStarting Supply Chain Risk Management Workflow...")
+            print("=" * 50)
+            
+            # Run workflow
+            results = workflow.start()
+            
+            # Print results
+            print("\nRisk Management Results:")
+            print("=" * 50)
+            for task_id, result in results["task_results"].items():
+                if result:
+                    print(f"\nTask: {task_id}")
+                    print(f"Result: {result.raw}")
+                    print("-" * 50)
+
+        if __name__ == "__main__":
+            main()
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```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 Python
+</Note>
+
+## Understanding Supply Chain Risk Management
+
+<Card title="What is Supply Chain Risk Management?" icon="question">
+  Automated supply chain risk management workflow enables:
+  - Real-time global event monitoring
+  - Impact assessment and risk analysis
+  - Strategy generation for risk mitigation
+  - Proactive supply chain optimization
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Event Monitoring" icon="globe">
+    Monitor global events that could affect supply chain operations.
+  </Card>
+  <Card title="Impact Analysis" icon="chart-line">
+    Assess potential disruptions and quantify risks to the supply chain.
+  </Card>
+  <Card title="Strategy Generation" icon="lightbulb">
+    Generate mitigation strategies based on event impact.
+  </Card>
+  <Card title="Risk Management" icon="shield-check">
+    Proactively manage and mitigate supply chain risks.
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Prompt Chaining" icon="link" href="/features/promptchaining">
+    Learn about sequential prompt execution
+  </Card>
+  <Card title="Evaluator Optimizer" icon="magnifying-glass-chart" href="/features/evaluator-optimiser">
+    Explore optimization techniques
+  </Card>
+</CardGroup> 

docs/features/async.mdx

@@ -4,6 +4,26 @@ description: "Async AI Agents allow you to run AI tasks asynchronously, improvin
 icon: "clock"
 ---
 
+```mermaid
+flowchart LR
+    In[In] --> Agent1[AI Agent]
+    Agent1 --> Agent2[AI Agent]
+    Agent1 --> Agent3[AI Agent]
+    Agent1 --> Agent4[AI Agent]
+    Agent2 --> Out[Out]
+    Agent3 --> Out
+    Agent4 --> Out
+    
+    style In fill:#8B0000,color:#fff
+    style Agent1 fill:#2E8B57,color:#fff
+    style Agent2 fill:#2E8B57,color:#fff
+    style Agent3 fill:#2E8B57,color:#fff
+    style Agent4 fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+Async AI Agents allow you to run AI tasks asynchronously, improving performance and efficiency in your applications.
+
 ## Quick Start
 
 <Tabs>

docs/features/autoagents.mdx

@@ -4,6 +4,47 @@ description: "AutoAgents automatically creates and manages AI agents and tasks b
 icon: "robot"
 ---
 
+```mermaid
+flowchart LR
+    In[In] --> Plan[Plan Tasks]
+    
+    subgraph Creation[Automatic Agent Creation]
+        Plan --> Agent1[AI Agent 1]
+        Plan --> Agent2[AI Agent 2]
+        Plan --> Agent3[AI Agent 3]
+    end
+    
+    subgraph Tools[Automatic Tool Assignment]
+        Agent1 --> Tool1[Tools 1]
+        Agent2 --> Tool2[Tools 2]
+        Agent3 --> Tool3[Tools 3]
+    end
+    
+    Tools --> Execution
+    
+    subgraph Execution[Execution]
+        Exec1[AI Agent 1] --> Exec2[AI Agent 2]
+        Exec2 --> Exec3[AI Agent 3]
+    end
+    
+    Exec3 --> Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style Plan fill:#2E8B57,color:#fff
+    style Agent1 fill:#2E8B57,color:#fff
+    style Agent2 fill:#2E8B57,color:#fff
+    style Agent3 fill:#2E8B57,color:#fff
+    style Tool1 fill:#2E8B57,color:#fff
+    style Tool2 fill:#2E8B57,color:#fff
+    style Tool3 fill:#2E8B57,color:#fff
+    style Exec1 fill:#2E8B57,color:#fff
+    style Exec2 fill:#2E8B57,color:#fff
+    style Exec3 fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+AutoAgents automatically creates and manages AI agents and tasks based on high-level instructions.
+
 ## Quick Start
 
 <Tabs>

docs/features/autonomous-workflow.mdx

@@ -0,0 +1,277 @@
+---
+title: "Agentic Autonomous Workflow"
+sidebarTitle: "Autonomous Workflow"
+description: "Learn how to create AI agents that can autonomously monitor, act, and adapt based on environment feedback."
+icon: "robot"
+---
+
+```mermaid
+flowchart LR
+    Human[Human] <--> LLM[LLM Call]
+    LLM -->|ACTION| Environment[Environment]
+    Environment -->|FEEDBACK| LLM
+    LLM --> Stop[Stop]
+    
+    style Human fill:#8B0000,color:#fff
+    style LLM fill:#2E8B57,color:#fff
+    style Environment fill:#8B0000,color:#fff
+    style Stop fill:#333,color:#fff
+```
+
+An agent-based workflow where LLMs act autonomously within a loop, interacting with their environment and receiving feedback to refine their actions and decisions.
+
+## Quick Start
+
+<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
+        import time
+
+        def get_environment_state():
+            """Simulates getting current environment state"""
+            current_time = int(time.time())
+            states = ["normal", "critical", "optimal"]
+            state = states[current_time % 3]
+            print(f"Environment state: {state}")
+            return state
+
+        def perform_action(state: str):
+            """Simulates performing an action based on state"""
+            actions = {
+                "normal": "maintain",
+                "critical": "fix",
+                "optimal": "enhance"
+            }
+            action = actions.get(state, "observe")
+            print(f"Performing action: {action} for state: {state}")
+            return action
+
+        def get_feedback():
+            """Simulates environment feedback"""
+            current_time = int(time.time())
+            feedback = "positive" if current_time % 2 == 0 else "negative"
+            print(f"Feedback received: {feedback}")
+            return feedback
+
+        # Create specialized agents
+        llm_caller = Agent(
+            name="Environment Monitor",
+            role="State analyzer",
+            goal="Monitor environment and analyze state",
+            instructions="Check environment state and provide analysis",
+            tools=[get_environment_state]
+        )
+
+        action_agent = Agent(
+            name="Action Executor",
+            role="Action performer",
+            goal="Execute appropriate actions based on state",
+            instructions="Determine and perform actions based on environment state",
+            tools=[perform_action]
+        )
+
+        feedback_agent = Agent(
+            name="Feedback Processor",
+            role="Feedback analyzer",
+            goal="Process environment feedback and adapt strategy",
+            instructions="Analyze feedback and provide adaptation recommendations",
+            tools=[get_feedback]
+        )
+
+        # Create tasks for autonomous workflow
+        monitor_task = Task(
+            name="monitor_environment",
+            description="Monitor and analyze environment state",
+            expected_output="Current environment state analysis",
+            agent=llm_caller,
+            is_start=True,
+            task_type="decision",
+            next_tasks=["execute_action"],
+            condition={
+                "normal": ["execute_action"],
+                "critical": ["execute_action"],
+                "optimal": "exit"
+            }
+        )
+
+        action_task = Task(
+            name="execute_action",
+            description="Execute appropriate action based on state",
+            expected_output="Action execution result",
+            agent=action_agent,
+            next_tasks=["process_feedback"]
+        )
+
+        feedback_task = Task(
+            name="process_feedback",
+            description="Process feedback and adapt strategy",
+            expected_output="Strategy adaptation based on feedback",
+            agent=feedback_agent,
+            next_tasks=["monitor_environment"],  # Create feedback loop
+            context=[monitor_task, action_task]  # Access to previous states and actions
+        )
+
+        # Create workflow manager
+        workflow = PraisonAIAgents(
+            agents=[llm_caller, action_agent, feedback_agent],
+            tasks=[monitor_task, action_task, feedback_task],
+            process="workflow",
+            verbose=True
+        )
+
+        def main():
+            print("\nStarting Autonomous Agent Workflow...")
+            print("=" * 50)
+            
+            # Run autonomous workflow
+            results = workflow.start()
+            
+            # Print results
+            print("\nAutonomous Agent Results:")
+            print("=" * 50)
+            for task_id, result in results["task_results"].items():
+                if result:
+                    task_name = result.description
+                    print(f"\nTask: {task_name}")
+                    print(f"Result: {result.raw}")
+                    print("-" * 50)
+
+        if __name__ == "__main__":
+            main()
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```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 Python
+</Note>
+
+## Understanding Autonomous Workflow
+
+<Card title="What is Autonomous Workflow?" icon="question">
+  Autonomous Workflow enables:
+  - Continuous environment monitoring
+  - Automated decision-making and action execution
+  - Real-time feedback processing
+  - Self-adapting behavior based on outcomes
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Environment Monitoring" icon="eye">
+    Continuously monitor and analyze environment state.
+  </Card>
+  <Card title="Adaptive Actions" icon="gears">
+    Execute context-aware actions based on state analysis.
+  </Card>
+  <Card title="Feedback Processing" icon="rotate">
+    Process and learn from action outcomes.
+  </Card>
+  <Card title="Self-Optimization" icon="arrow-trend-up">
+    Improve performance through continuous learning.
+  </Card>
+</CardGroup>
+
+## Configuration Options
+
+```python
+# Create a monitor agent
+monitor = Agent(
+    name="Environment Monitor",
+    role="State analyzer",
+    goal="Monitor and analyze state",
+    tools=[get_environment_state],  # Environment monitoring tools
+    verbose=True  # Enable detailed logging
+)
+
+# Create an action agent
+action = Agent(
+    name="Action Executor",
+    role="Action performer",
+    goal="Execute appropriate actions",
+    tools=[perform_action]  # Action execution tools
+)
+
+# Create monitoring task
+monitor_task = Task(
+    name="monitor_environment",
+    description="Monitor environment state",
+    agent=monitor,
+    is_start=True,
+    task_type="decision",
+    condition={
+        "normal": ["execute_action"],
+        "critical": ["execute_action"],
+        "optimal": "exit"
+    }
+)
+
+# Create feedback loop task
+feedback_task = Task(
+    name="process_feedback",
+    description="Process and adapt",
+    agent=feedback_agent,
+    next_tasks=["monitor_environment"],  # Create feedback loop
+    context=[monitor_task, action_task]  # Access history
+)
+```
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Monitoring Issues" icon="triangle-exclamation">
+    If monitoring fails:
+    - Check environment access
+    - Verify state detection
+    - Enable verbose mode for debugging
+  </Card>
+
+  <Card title="Adaptation Flow" icon="diagram-project">
+    If adaptation is incorrect:
+    - Review feedback processing
+    - Check action outcomes
+    - Verify learning loop
+  </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 environment monitoring is reliable and your feedback processing logic is properly configured for effective adaptation.
+</Note>

docs/features/callbacks.mdx

@@ -5,6 +5,20 @@ description: "Learn how to implement callbacks to monitor and log AI agent inter
 icon: "bell"
 ---
 
+```mermaid
+flowchart LR
+    In[In] --> Agent[AI Agent]
+    Agent --> Out[Out]
+    Agent --> Callback[Callback]
+    
+    style In fill:#8B0000,color:#fff
+    style Agent fill:#2E8B57,color:#fff
+    style Callback fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+Learn how to implement callbacks to monitor and log AI agent interactions, errors, and task completions.
+
 ## Quick Start
 
 <Tabs>

docs/features/evaluator-optimiser.mdx

@@ -0,0 +1,230 @@
+---
+title: "Agentic Evaluator Optimizer"
+sidebarTitle: "Evaluator Optimizer"
+description: "Learn how to create AI agents that can generate and optimize solutions through iterative feedback."
+icon: "arrows-rotate"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Generator[LLM Call Generator] 
+    Generator -->|SOLUTION| Evaluator[LLM Call Evaluator] -->|ACCEPTED| Out[Out]
+    Evaluator -->|REJECTED + FEEDBACK| Generator
+    
+    style In fill:#8B0000,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Evaluator fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A feedback loop workflow where LLM-generated outputs are evaluated, refined, and optimized iteratively to improve accuracy and relevance.
+
+## Quick Start
+
+<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 generator and evaluator agents
+        generator = Agent(
+            name="Generator",
+            role="Solution generator",
+            goal="Generate initial solutions and incorporate feedback",
+            instructions=(
+                "1. Look at the context from previous tasks.\n"
+                "2. If you see that you have already produced 2 points, then add another 2 new points "
+                "   so that the total becomes 10.\n"
+                "3. Otherwise, just produce the first 2 points.\n"
+                "4. Return only the final list of points, with no extra explanation."
+            )
+        )
+
+        evaluator = Agent(
+            name="Evaluator",
+            role="Solution evaluator",
+            goal="Evaluate solutions and provide improvement feedback",
+            instructions=(
+                "1. Count how many lines in the response start with a number and a period (like '1. ' or '2. ').\n"
+                "2. If there are 10 or more, respond with 'done'.\n"
+                "3. Otherwise, respond with 'more'.\n"
+                "4. Return only the single word: 'done' or 'more'."
+            )
+        )
+
+        # Create tasks for the feedback loop
+        generate_task = Task(
+            name="generate",
+            description="Write 2 points about AI incuding if anything exiting from previous points",
+            expected_output="2 points",
+            agent=generator,
+            is_start=True,
+            task_type="decision",
+            next_tasks=["evaluate"]
+        )
+
+        evaluate_task = Task(
+            name="evaluate",
+            description="Check if there are 10 points about AI",
+            expected_output="more or done",
+            agent=evaluator,
+            next_tasks=["generate"],
+            context=[generate_task],
+            task_type="decision",
+            condition={
+                "more": ["generate"],  # Continue to generate
+                "done": [""]  # Exit when optimization complete
+            }
+        )
+
+        # Create workflow manager
+        workflow = PraisonAIAgents(
+            agents=[generator, evaluator],
+            tasks=[generate_task, evaluate_task],
+            process="workflow",
+            verbose=True
+        )
+
+        # Run optimization workflow
+        results = workflow.start()
+
+        # Print results
+        print("\nEvaluator-Optimizer Results:")
+        for task_id, result in results["task_results"].items():
+            if result:
+                print(f"Task {task_id}: {result.raw}")
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```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 Python
+</Note>
+
+## Understanding Evaluator-Optimizer
+
+<Card title="What is Evaluator-Optimizer?" icon="question">
+  Evaluator-Optimizer pattern enables:
+  - Iterative solution generation and refinement
+  - Automated quality evaluation
+  - Feedback-driven optimization
+  - Continuous improvement loops
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Solution Generation" icon="wand-magic-sparkles">
+    Generate solutions based on requirements and feedback.
+  </Card>
+  <Card title="Quality Evaluation" icon="magnifying-glass-chart">
+    Automatically assess solution quality and completeness.
+  </Card>
+  <Card title="Feedback Loop" icon="rotate">
+    Implement iterative improvement through feedback cycles.
+  </Card>
+  <Card title="Process Control" icon="sliders">
+    Monitor and control the optimization process.
+  </Card>
+</CardGroup>
+
+## Configuration Options
+
+```python
+# Create a generator agent
+generator = Agent(
+    name="Generator",
+    role="Solution generator",
+    goal="Generate and improve solutions",
+    instructions="Step-by-step instructions for generation",
+    verbose=True  # Enable detailed logging
+)
+
+# Create an evaluator agent
+evaluator = Agent(
+    name="Evaluator",
+    role="Solution evaluator",
+    goal="Evaluate and provide feedback",
+    instructions="Evaluation criteria and feedback format"
+)
+
+# Create tasks with feedback loop
+generate_task = Task(
+    name="generate",
+    description="Generate solution",
+    agent=generator,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["evaluate"]
+)
+
+evaluate_task = Task(
+    name="evaluate",
+    description="Evaluate solution",
+    agent=evaluator,
+    context=[generate_task],
+    task_type="decision",
+    condition={
+        "more": ["generate"],  # Continue optimization
+        "done": [""]  # Exit when complete
+    }
+)
+```
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Generation Issues" icon="triangle-exclamation">
+    If generation is not improving:
+    - Review generator instructions
+    - Check feedback integration
+    - Enable verbose mode for debugging
+  </Card>
+
+  <Card title="Evaluation Flow" icon="diagram-project">
+    If evaluation cycle is incorrect:
+    - Verify evaluation criteria
+    - Check condition mappings
+    - Review feedback loop connections
+  </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 generator instructions and evaluation criteria are clear and well-defined to achieve the desired optimization outcomes.
+</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/orchestrator-worker.mdx

@@ -0,0 +1,278 @@
+---
+title: "Agentic Orchestrator Worker"
+sidebarTitle: "Orchestrator Worker"
+description: "Learn how to create AI agents that orchestrate and distribute tasks among specialized workers."
+icon: "sitemap"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Router[LLM Call Router]
+    Router --> LLM1[LLM Call 1]
+    Router --> LLM2[LLM Call 2]
+    Router --> LLM3[LLM Call 3]
+    LLM1 --> Synthesizer[Synthesizer]
+    LLM2 --> Synthesizer
+    LLM3 --> Synthesizer
+    Synthesizer --> Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style Router fill:#2E8B57,color:#fff
+    style LLM1 fill:#2E8B57,color:#fff
+    style LLM2 fill:#2E8B57,color:#fff
+    style LLM3 fill:#2E8B57,color:#fff
+    style Synthesizer fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow with a central orchestrator directing multiple worker LLMs to perform subtasks, synthesizing their outputs for complex, coordinated operations.
+
+## Quick Start
+
+<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
+        import time
+
+        def get_time_check():
+            current_time = int(time.time())
+            if current_time % 3 == 0:
+                result = 1
+            elif current_time % 3 == 1:
+                result = 2
+            else:
+                result = 3
+            print(f"Time: {current_time}, Result: {result}")
+            return result
+
+        # Create orchestrator and worker agents
+        router = Agent(
+            name="Router",
+            role="Task router",
+            goal="Distribute tasks to based on response from get_time_check",
+            tools=[get_time_check]
+        )
+
+        worker1 = Agent(
+            name="Worker 1",
+            role="Specialized worker",
+            goal="Handle specific subtask type 1",
+        )
+
+        worker2 = Agent(
+            name="Worker 2",
+            role="Specialized worker",
+            goal="Handle specific subtask type 2",
+        )
+
+        worker3 = Agent(
+            name="Worker 3",
+            role="Specialized worker",
+            goal="Handle specific subtask type 3",
+        )
+
+        synthesizer = Agent(
+            name="Synthesizer",
+            role="Result synthesizer",
+            goal="Combine and synthesize worker outputs",
+        )
+
+        # Create orchestrated workflow tasks
+        router_task = Task(
+            name="route_task",
+            description="Analyze input from get_time_check and route to appropriate workers",
+            expected_output="Task routing decision, 1 , 2 or 3",
+            agent=router,
+            is_start=True,
+            task_type="decision",
+            next_tasks=["worker1_task", "worker2_task", "worker3_task"],
+            condition={
+                "1": ["worker1_task"],
+                "2": ["worker2_task"],
+                "3": ["worker3_task"]
+            }
+        )
+
+        worker1_task = Task(
+            name="worker1_task",
+            description="Process type 1 operation",
+            expected_output="Worker 1 result",
+            agent=worker1,
+            next_tasks=["synthesize_task"]
+        )
+
+        worker2_task = Task(
+            name="worker2_task",
+            description="Process type 2 operation",
+            expected_output="Worker 2 result",
+            agent=worker2,
+            next_tasks=["synthesize_task"]
+        )
+
+        worker3_task = Task(
+            name="worker3_task",
+            description="Process type 3 operation",
+            expected_output="Worker 3 result",
+            agent=worker3,
+            next_tasks=["synthesize_task"]
+        )
+
+        synthesize_task = Task(
+            name="synthesize_task",
+            description="Synthesize worker results into final output",
+            expected_output="Final synthesized result",
+            agent=synthesizer,
+            context=[worker1_task, worker2_task, worker3_task]
+        )
+
+        # Create workflow manager
+        workflow = PraisonAIAgents(
+            agents=[router, worker1, worker2, worker3, synthesizer],
+            tasks=[router_task, worker1_task, worker2_task, worker3_task, synthesize_task],
+            process="workflow",
+            verbose=True
+        )
+
+        # Run orchestrated workflow
+        results = workflow.start()
+
+        # Print results
+        print("\nOrchestrator-Workers Results:")
+        for task_id, result in results["task_results"].items():
+            if result:
+                print(f"Task {task_id}: {result.raw}")
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```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 Python
+</Note>
+
+## Understanding Orchestrator-Worker Pattern
+
+<Card title="What is Orchestrator-Worker?" icon="question">
+  Orchestrator-Worker pattern enables:
+  - Dynamic task distribution and routing
+  - Specialized worker execution
+  - Result synthesis and aggregation
+  - Coordinated workflow management
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Task Routing" icon="route">
+    Intelligently distribute tasks to specialized workers.
+  </Card>
+  <Card title="Worker Specialization" icon="user-gear">
+    Dedicated agents for specific task types.
+  </Card>
+  <Card title="Result Synthesis" icon="object-group">
+    Combine and process worker outputs effectively.
+  </Card>
+  <Card title="Process Control" icon="sliders">
+    Monitor and manage the orchestrated workflow.
+  </Card>
+</CardGroup>
+
+## Configuration Options
+
+```python
+# Create an orchestrator agent
+router = Agent(
+    name="Router",
+    role="Task router",
+    goal="Distribute tasks based on conditions",
+    tools=[get_time_check],  # Tools for routing decisions
+    verbose=True  # Enable detailed logging
+)
+
+# Create a worker agent
+worker = Agent(
+    name="Worker",
+    role="Specialized worker",
+    goal="Handle specific task type",
+    instructions="Processing instructions"
+)
+
+# Create routing task
+router_task = Task(
+    name="route_task",
+    description="Route tasks to workers",
+    agent=router,
+    is_start=True,
+    task_type="decision",
+    condition={
+        "1": ["worker1_task"],
+        "2": ["worker2_task"]
+    }
+)
+
+# Create synthesis task
+synthesis_task = Task(
+    name="synthesize",
+    description="Combine worker results",
+    agent=synthesizer,
+    context=[worker1_task, worker2_task]  # Reference worker tasks
+)
+```
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Routing Issues" icon="triangle-exclamation">
+    If task routing fails:
+    - Check routing conditions
+    - Verify worker availability
+    - Enable verbose mode for debugging
+  </Card>
+
+  <Card title="Synthesis Flow" icon="diagram-project">
+    If result synthesis is incorrect:
+    - Review worker outputs
+    - Check context connections
+    - Verify synthesis logic
+  </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 routing logic is well-defined and your workers are properly configured for their specialized tasks.
+</Note>

docs/features/parallelisation.mdx

@@ -0,0 +1,252 @@
+---
+title: "Agentic Parallelization"
+sidebarTitle: "Parallelization"
+description: "Learn how to create AI agents that can execute tasks in parallel for improved performance."
+icon: "arrows-split-up-and-left"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> LLM2[LLM Call 2]
+    In --> LLM1[LLM Call 1]
+    In --> LLM3[LLM Call 3]
+    LLM1 --> Aggregator[Aggregator]
+    LLM2 --> Aggregator
+    LLM3 --> Aggregator
+    Aggregator --> Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style LLM1 fill:#2E8B57,color:#fff
+    style LLM2 fill:#2E8B57,color:#fff
+    style LLM3 fill:#2E8B57,color:#fff
+    style Aggregator fill:#fff,color:#000
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow that distributes tasks across multiple LLM calls simultaneously, aggregating results to handle complex or large-scale operations efficiently.
+
+## Quick Start
+
+<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 datetime import datetime
+        import asyncio
+
+        def process_time():
+            """Simulate processing"""
+            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            print(f"Processing at: {current_time}")
+            return f"Processed at {current_time}"
+
+        # Create parallel processing agents
+        agent1 = Agent(
+            name="Processor 1",
+            role="Time collector",
+            goal="Get the time and return it",
+            tools=[process_time]
+        )
+
+        agent2 = Agent(
+            name="Processor 2",
+            role="Time collector",
+            goal="Get the time and return it",
+            tools=[process_time]
+        )
+
+        agent3 = Agent(
+            name="Processor 3",
+            role="Time collector",
+            goal="Get the time and return it",
+            tools=[process_time]
+        )
+
+        aggregator = Agent(
+            name="Aggregator",
+            role="Result aggregator",
+            goal="Collect all the processed time from all tasks"
+        )
+
+        # Create parallel tasks with memory disabled
+        task1 = Task(
+            name="process_1",
+            description="Use process_time tool to get the time",
+            expected_output="processed time",
+            agent=agent1,
+            is_start=True,
+            async_execution=True
+        )
+
+        task2 = Task(
+            name="process_2",
+            description="Use process_time tool to get the time",
+            expected_output="processed time",
+            agent=agent2,
+            is_start=True,
+            async_execution=True
+        )
+
+        task3 = Task(
+            name="process_3",
+            description="Use process_time tool to get the time",
+            expected_output="processed time",
+            agent=agent3,
+            is_start=True,
+            async_execution=True
+        )
+
+        aggregate_task = Task(
+            name="aggregate",
+            description="Collect all the processed time from all tasks",
+            expected_output="Output all the processed time from all tasks and just the time",
+            agent=aggregator,
+            context=[task1, task2, task3]
+        )
+
+        async def main():
+
+            # Create workflow manager
+            workflow = PraisonAIAgents(
+                agents=[agent1, agent2, agent3, aggregator],
+                tasks=[task1, task2, task3, aggregate_task],
+                process="workflow"
+            )
+
+            # Run parallel workflow
+            results = await workflow.astart()
+
+            # Print results
+            print("\nParallel Processing Results:")
+            for task_id, result in results["task_results"].items():
+                if result:
+                    print(f"Task {task_id}: {result.raw}")
+
+        # Run the async main function
+        if __name__ == "__main__":
+            asyncio.run(main())
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```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 Python and async programming
+</Note>
+
+## Understanding Parallelisation
+
+<Card title="What is Parallelisation?" icon="question">
+  Parallelisation enables:
+  - Concurrent execution of multiple tasks
+  - Improved performance through parallel processing
+  - Efficient handling of independent operations
+  - Aggregation of parallel task results
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Parallel Execution" icon="arrows-split-up-and-left">
+    Run multiple tasks simultaneously for improved performance.
+  </Card>
+  <Card title="Async Support" icon="bolt">
+    Built-in support for asynchronous execution.
+  </Card>
+  <Card title="Result Aggregation" icon="layer-group">
+    Combine results from parallel tasks efficiently.
+  </Card>
+  <Card title="Process Control" icon="sliders">
+    Monitor and manage parallel task execution.
+  </Card>
+</CardGroup>
+
+## Configuration Options
+
+```python
+# Create a parallel task
+task = Task(
+    name="parallel_task",
+    description="Task to run in parallel",
+    expected_output="Task result",
+    agent=agent,
+    is_start=True,
+    async_execution=True  # Enable parallel execution
+)
+
+# Create an aggregator task
+aggregator_task = Task(
+    name="aggregate",
+    description="Aggregate results from parallel tasks",
+    expected_output="Combined results",
+    agent=aggregator,
+    context=[task1, task2, task3]  # Reference parallel tasks
+)
+
+# Async workflow execution
+async def run_workflow():
+    workflow = PraisonAIAgents(
+        agents=[agent1, agent2, aggregator],
+        tasks=[task1, task2, aggregator_task],
+        process="workflow",
+        verbose=True
+    )
+    results = await workflow.astart()
+```
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Execution Issues" icon="triangle-exclamation">
+    If parallel execution fails:
+    - Check async configuration
+    - Verify task independence
+    - Monitor resource usage
+  </Card>
+
+  <Card title="Result Aggregation" icon="diagram-project">
+    If aggregation is incorrect:
+    - Review task outputs
+    - Check context connections
+    - Verify aggregator logic
+  </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 parallel tasks are truly independent and your system has sufficient resources to handle concurrent execution.
+</Note>

docs/features/promptchaining.mdx

@@ -0,0 +1,265 @@
+---
+title: "Agentic Prompt Chaining"
+sidebarTitle: "Prompt Chaining"
+description: "Learn how to create AI agents with sequential prompt chaining for complex workflows."
+icon: "link"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> LLM1[LLM Call 1] --> Gate{Gate}
+    Gate -->|Pass| LLM2[LLM Call 2] -->|Output 2| LLM3[LLM Call 3] --> Out[Out]
+    Gate -->|Fail| Exit[Exit]
+    
+    style In fill:#8B0000,color:#fff
+    style LLM1 fill:#2E8B57,color:#fff
+    style LLM2 fill:#2E8B57,color:#fff
+    style LLM3 fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+    style Exit fill:#8B0000,color:#fff
+```
+
+A workflow where the output of one LLM call becomes the input for the next. This sequential design allows for structured reasoning and step-by-step task completion.
+
+## Quick Start
+
+<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
+        import time
+
+        def get_time_check():
+            current_time = int(time.time())
+            result = "even" if current_time % 2 == 0 else "odd"
+            print(f"Time check: {current_time} is {result}")
+            return result
+
+        # Create agents for each step in the chain
+        agent1 = Agent(
+            name="Time Checker",
+            role="Time checker",
+            goal="Check if the time is even or odd",
+            instructions="Check if the time is even or odd",
+            tools=[get_time_check]
+        )
+
+        agent2 = Agent(
+            name="Advanced Analyzer",
+            role="Advanced data analyzer",
+            goal="Perform in-depth analysis of processed data",
+            instructions="Analyze the processed data in detail"
+        )
+
+        agent3 = Agent(
+            name="Final Processor",
+            role="Final data processor",
+            goal="Generate final output based on analysis",
+            instructions="Create final output based on analyzed data"
+        )
+
+        # Create tasks for each step
+        initial_task = Task(
+            name="time_check",
+            description="Getting time check and checking if it is even or odd",
+            expected_output="Getting time check and checking if it is even or odd",
+            agent=agent1,
+            is_start=True,  # Mark as the starting task
+            task_type="decision",  # This task will make a decision
+            next_tasks=["advanced_analysis"],  # Next task if condition passes
+            condition={
+                "even": ["advanced_analysis"],  # If passes, go to advanced analysis
+                "odd": ""  # If fails, exit the chain
+            }
+        )
+
+        analysis_task = Task(
+            name="advanced_analysis",
+            description="Perform advanced analysis on the processed data",
+            expected_output="Analyzed data ready for final processing",
+            agent=agent2,
+            next_tasks=["final_processing"]
+        )
+
+        final_task = Task(
+            name="final_processing",
+            description="Generate final output",
+            expected_output="Final processed result",
+            agent=agent3
+        )
+
+        # Create the workflow manager
+        workflow = PraisonAIAgents(
+            agents=[agent1, agent2, agent3],
+            tasks=[initial_task, analysis_task, final_task],
+            process="workflow",  # Use workflow process type
+            verbose=True
+        )
+
+        # Run the workflow
+        results = workflow.start()
+
+        # Print results
+        print("\nWorkflow Results:")
+        for task_id, result in results["task_results"].items():
+            if result:
+                print(f"Task {task_id}: {result.raw}")
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```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 Python
+</Note>
+
+## Understanding Prompt Chaining
+
+<Card title="What is Prompt Chaining?" icon="question">
+  Prompt chaining enables:
+  - Sequential execution of prompts
+  - Data flow between agents
+  - Conditional branching in workflows
+  - Step-by-step processing of complex tasks
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Sequential Processing" icon="arrow-right">
+    Execute tasks in a defined sequence with data passing between steps.
+  </Card>
+  <Card title="Decision Points" icon="code-branch">
+    Implement conditional logic to control workflow progression.
+  </Card>
+  <Card title="Data Flow" icon="arrows-up-down">
+    Pass data seamlessly between agents in the chain.
+  </Card>
+  <Card title="Process Control" icon="sliders">
+    Monitor and control the execution of each step in the chain.
+  </Card>
+</CardGroup>
+
+## Configuration Options to exit the chain
+
+```python
+# Task with chaining configuration
+task = Task(
+    name="time_check",
+    description="Check time and make decision",
+    expected_output="Time check result",
+    agent=agent,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["next_step"],
+    condition={
+        "even": ["next_step"],
+        "odd": ""
+    }
+)
+```
+
+```python
+task = Task(
+    name="time_check",
+    description="Check time and make decision",
+    expected_output="Time check result",
+    agent=agent,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["next_step"],
+    condition={
+        "even": ["next_step"],
+        "odd": "exit"
+    }
+)
+```
+
+```python
+task = Task(
+    name="time_check",
+    description="Check time and make decision",
+    expected_output="Time check result",
+    agent=agent,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["next_step"],
+    condition={
+        "even": ["next_step"],
+        "odd": ["exit"]
+    }
+)
+```
+
+```python
+task = Task(
+    name="time_check",
+    description="Check time and make decision",
+    expected_output="Time check result",
+    agent=agent,
+    is_start=True,
+    task_type="decision",
+    next_tasks=["next_step"],
+    condition={
+        "even": ["next_step"],
+        "odd": [""]
+    }
+)
+```
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Chain Issues" icon="triangle-exclamation">
+    If chain execution fails:
+    - Verify task connections
+    - Check condition logic
+    - Enable verbose mode for debugging
+  </Card>
+
+  <Card title="Data Flow" icon="diagram-project">
+    If data flow is incorrect:
+    - Review task outputs
+    - Check agent configurations
+    - Verify task dependencies
+  </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 chain is properly configured with clear task dependencies and conditions for branching logic.
+</Note>