Merge pull request #485 from MervinPraison/develop

Increment version to 0.0.84 in `pyproject.toml` and `uv.lock`, update…

.github/workflows/claude.yml

@@ -0,0 +1,37 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@beta
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+

.gitignore

@@ -1,3 +1,4 @@
+workspace.code-workspace
 .vscode
 crewai
 .cache
@@ -66,4 +67,6 @@ agents/praisonaiagents/build
 agents/praisonaiagents/dist
 agents/praisonaiagents/praisonaiagents.egg-info
 .codegpt
-.praison
+.praison
+# Local Netlify folder
+.netlify

README.md

@@ -20,7 +20,7 @@
 
 </div>
 
-PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human–agent collaboration.
+PraisonAI is a production-ready Multi-AI Agents framework with self-reflection, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. By integrating PraisonAI Agents, AG2 (Formerly AutoGen), and CrewAI into a low-code solution, it streamlines the building and management of multi-agent LLM systems, emphasising simplicity, customisation, and effective human-agent collaboration.
 
 <div align="center">
   <a href="https://docs.praison.ai">
@@ -37,35 +37,24 @@ PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application
 - 🧠 Reasoning AI Agents
 - 👁️ Multi Modal AI Agents
 - 🤝 Multi Agent Collaboration
-- ⚡ AI Agent Workflow
-- 🔄 Use CrewAI or AutoGen Framework
+- 🎭 AI Agent Workflow
+- 📚 Add Custom Knowledge
+- 🧠 Agents with Short and Long Term Memory
+- 📄 Chat with PDF Agents
+- 💻 Code Interpreter Agents
+- 📚 RAG Agents
+- 🤔 Async & Parallel Processing
+- 🔄 Auto Agents
+- 🔢 Math Agents
+- 🎯 Structured Output Agents
+- 🔗 LangChain Integrated Agents
+- 📞 Callback Agents
+- 🤏 Mini AI Agents
+- 🛠️ 100+ Custom Tools
+- 📄 YAML Configuration
 - 💯 100+ LLM Support
-- 💻 Chat with ENTIRE Codebase
-- 🎨 Interactive UIs
-- 📄 YAML-based Configuration
-- 🛠️ Custom Tool Integration
-- 🔍 Internet Search Capability (using Crawl4AI and Tavily)
-- 🖼️ Vision Language Model (VLM) Support
-- 🎙️ Real-time Voice Interaction
 
-## Using No Code
-
-### Auto Mode:
-```bash
-pip install praisonai
-export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
-praisonai --auto create a movie script about Robots in Mars
-```
-
-### Initialise Mode:
-```bash
-pip install praisonai
-export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
-praisonai --init create a movie script about Robots in Mars
-praisonai
-```
-
-## Using Coding
+## Using Python Code
 
 Light weight package dedicated for coding:
 ```bash
@@ -76,58 +65,13 @@ pip install praisonaiagents
 export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
 ```
 
+### 1. Single Agent
+
 Create app.py file and add the code below:
 ```python
-from praisonaiagents import Agent, Task, PraisonAIAgents
-
-# 1. Create agents
-researcher = Agent(
-    name="Researcher",
-    role="Senior Research Analyst",
-    goal="Uncover cutting-edge developments in AI and data science",
-    backstory="""You are an expert at a technology research group, 
-    skilled in identifying trends and analyzing complex data.""",
-    verbose=True,
-    llm="gpt-4o",
-    markdown=True
-)
-writer = Agent(
-    name="Writer",
-    role="Tech Content Strategist",
-    goal="Craft compelling content on tech advancements",
-    backstory="""You are a content strategist known for 
-    making complex tech topics interesting and easy to understand.""",
-    llm="gpt-4o",
-    markdown=True
-)
-
-# 2. Define Tasks
-task1 = Task(
-    name="research_task",
-    description="""Analyze 2024's AI advancements. 
-    Find major trends, new technologies, and their effects.""",
-    expected_output="""A detailed report on 2024 AI advancements""",
-    agent=researcher
-)
-
-task2 = Task(
-    name="writing_task",
-    description="""Create a blog post about major AI advancements using the insights you have.
-    Make it interesting, clear, and suited for tech enthusiasts. 
-    It should be at least 4 paragraphs long.""",
-    expected_output="A blog post of at least 4 paragraphs",
-    agent=writer,
-)
-
-agents = PraisonAIAgents(
-    agents=[researcher, writer],
-    tasks=[task1, task2],
-    verbose=False,
-    process="hierarchical",
-    manager_llm="gpt-4o"
-)
-
-result = agents.start()
+from praisonaiagents import Agent
+agent = Agent(instructions="Your are a helpful AI assistant")
+agent.start("Write a movie script about a robot in Mars")
 ```
 
 Run:
@@ -135,6 +79,396 @@ Run:
 python app.py
 ```
 
+### 2. Multi Agents
+
+Create app.py file and add the code below:
+```python
+from praisonaiagents import Agent, PraisonAIAgents
+
+research_agent = Agent(instructions="Research about AI")
+summarise_agent = Agent(instructions="Summarise research agent's findings")
+agents = PraisonAIAgents(agents=[research_agent, summarise_agent])
+agents.start()
+```
+
+Run:
+```bash
+python app.py
+```
+
+## Using No Code
+
+### Auto Mode:
+```bash
+pip install praisonai
+export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+praisonai --auto create a movie script about Robots in Mars
+```
+
+## Using JavaScript Code
+
+```bash
+npm install praisonai
+export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+```
+
+```javascript
+const { Agent } = require('praisonai');
+const agent = new Agent({ instructions: 'You are a helpful AI assistant' });
+agent.start('Write a movie script about a robot in Mars');
+```
+
+![PraisonAI CLI Demo](docs/demo/praisonai-cli-demo.gif)
+
+## AI Agents Flow
+
+```mermaid
+graph LR
+    %% Define the main flow
+    Start([▶ Start]) --> Agent1
+    Agent1 --> Process[⚙ Process]
+    Process --> Agent2
+    Agent2 --> Output([✓ Output])
+    Process -.-> Agent1
+    
+    %% Define subgraphs for agents and their tasks
+    subgraph Agent1[ ]
+        Task1[📋 Task]
+        AgentIcon1[🤖 AI Agent]
+        Tools1[🔧 Tools]
+        
+        Task1 --- AgentIcon1
+        AgentIcon1 --- Tools1
+    end
+    
+    subgraph Agent2[ ]
+        Task2[📋 Task]
+        AgentIcon2[🤖 AI Agent]
+        Tools2[🔧 Tools]
+        
+        Task2 --- AgentIcon2
+        AgentIcon2 --- Tools2
+    end
+
+    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
+```
+
+## AI Agents with Tools
+
+Create AI agents that can use tools to interact with external systems and perform actions.
+
+```mermaid
+flowchart TB
+    subgraph Tools
+        direction TB
+        T3[Internet Search]
+        T1[Code Execution]
+        T2[Formatting]
+    end
+
+    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
+```
+
+## AI Agents with Memory
+
+Create AI agents with memory capabilities for maintaining context and information across tasks.
+
+```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
+```
+
+## AI Agents with Different Processes
+
+### Sequential Process
+
+The simplest form of task execution where tasks are performed one after another.
+
+```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
+```
+
+### Hierarchical Process
+
+Uses a manager agent to coordinate task execution and agent assignments.
+
+```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
+```
+
+### Workflow Process
+
+Advanced process type supporting complex task relationships and conditional execution.
+
+```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
+```
+
+#### Agentic Routing Workflow
+
+Create AI agents that can dynamically route tasks to specialized LLM instances.
+
+```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 --> Out[Out]
+    LLM2 --> Out
+    LLM3 --> 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 Out fill:#8B0000,color:#fff
+```
+
+#### Agentic Orchestrator Worker
+
+Create AI agents that orchestrate and distribute tasks among specialized workers.
+
+```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
+```
+
+#### Agentic Autonomous Workflow
+
+Create AI agents that can autonomously monitor, act, and adapt based on environment feedback.
+
+```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
+```
+
+#### Agentic Parallelization
+
+Create AI agents that can execute tasks in parallel for improved performance.
+
+```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
+```
+
+#### Agentic Prompt Chaining
+
+Create AI agents with sequential prompt chaining for complex workflows.
+
+```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
+```
+
+#### Agentic Evaluator Optimizer
+
+Create AI agents that can generate and optimize solutions through iterative feedback.
+
+```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
+```
+
+#### Repetitive Agents
+
+Create AI agents that can efficiently handle repetitive tasks through automated loops.
+
+```mermaid
+flowchart LR
+    In[Input] --> LoopAgent[("Looping Agent")]
+    LoopAgent --> Task[Task]
+    Task --> |Next iteration| LoopAgent
+    Task --> |Done| Out[Output]
+    
+    style In fill:#8B0000,color:#fff
+    style LoopAgent fill:#2E8B57,color:#fff,shape:circle
+    style Task fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+## Adding Models
+
+<div align="center">
+  <a href="https://docs.praison.ai/models">
+    <p align="center">
+      <img src="https://img.shields.io/badge/%F0%9F%93%9A_Models-Visit_docs.praison.ai-blue?style=for-the-badge&logo=bookstack&logoColor=white" alt="Models" />
+    </p>
+  </a>
+</div>
+
 ## Ollama Integration
 ```bash
 export OPENAI_BASE_URL=http://localhost:11434/v1
@@ -147,267 +481,16 @@ export OPENAI_API_KEY=xxxxxxxxxxx
 export OPENAI_BASE_URL=https://api.groq.com/openai/v1
 ```
 
-## Logging
-```bash
-export LOGLEVEL=info
-```
-
-Advanced logging:
-```bash
-export LOGLEVEL=debug
-```
-
-<div align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="docs/images/architecture-dark.png" />
-    <source media="(prefers-color-scheme: light)" srcset="docs/images/architecture-light.png" />
-    <img alt="PraisonAI Architecture" src="docs/images/architecture-light.png" />
-  </picture>
-</div>
-
-## Different User Interfaces:
-
-| Interface | Description | URL |
-|---|---|---|
-| **UI** | Multi Agents such as CrewAI or AutoGen | [https://docs.praison.ai/ui/ui](https://docs.praison.ai/ui/ui) |
-| **Chat** | Chat with 100+ LLMs, single AI Agent | [https://docs.praison.ai/ui/chat](https://docs.praison.ai/ui/chat) |
-| **Code** | Chat with entire Codebase, single AI Agent | [https://docs.praison.ai/ui/code](https://docs.praison.ai/ui/code) |
-| **Realtime** | Real-time voice interaction with AI | [https://docs.praison.ai/ui/realtime](https://docs.praison.ai/ui/realtime) |
-
-| Other Features | Description | Docs |
-|---|---|---|
-| **Train** | Fine-tune LLMs using your custom data | [https://docs.praison.ai/train](https://docs.praison.ai/train) |
-
-
-## Google Colab Multi Agents
-
-|               | Cookbook        | Open in Colab                                                                                                                                                                                                                                  |
-| ------------- | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Basic         | PraisonAI       | <a target="_blank" href="https://colab.research.google.com/github/MervinPraison/PraisonAI/blob/main/cookbooks/praisonai-googlecolab.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" /></a>       |
-| Include Tools | PraisonAI Tools | <a target="_blank" href="https://colab.research.google.com/github/MervinPraison/PraisonAI/blob/main/cookbooks/praisonai-tools-googlecolab.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" /></a> |
-
-## Installation Options
-
-### Using pip
-```bash
-pip install praisonai
-```
-
-### Framework-specific Installation
-```bash
-# Install with CrewAI support
-pip install "praisonai[crewai]"
-
-# Install with AutoGen support
-pip install "praisonai[autogen]"
-
-# Install with both frameworks
-pip install "praisonai[crewai,autogen]"
-```
-
-### UI and Additional Features
-```bash
-# Install UI support
-pip install "praisonai[ui]"
-
-# Install Chat interface
-pip install "praisonai[chat]"
-
-# Install Code interface
-pip install "praisonai[code]"
-
-# Install Realtime voice interaction
-pip install "praisonai[realtime]"
-
-# Install Call feature
-pip install "praisonai[call]"
-```
-
-## Quick Start
-
-```bash
-# Set your OpenAI API key
-export OPENAI_API_KEY="Enter your API key"
-
-# Initialize with CrewAI (default)
-praisonai --init "create a movie script about dog in moon"
-
-# Or initialize with AutoGen
-praisonai --framework autogen --init "create a movie script about dog in moon"
-
-# Run the agents
-praisonai
-```
-
-## Full Automatic Mode
-
-```bash
-# With CrewAI (default)
-praisonai --auto "create a movie script about Dog in Moon"
-
-# With AutoGen
-praisonai --framework autogen --auto "create a movie script about Dog in Moon"
-```
-
-## Framework-specific Features
-
-### CrewAI
-When installing with `pip install "praisonai[crewai]"`, you get:
-- CrewAI framework support
-- PraisonAI tools integration
-- Task delegation capabilities
-- Sequential and parallel task execution
-
-### AutoGen
-When installing with `pip install "praisonai[autogen]"`, you get:
-- AutoGen framework support
-- PraisonAI tools integration
-- Multi-agent conversation capabilities
-- Code execution environment
-
-
-
-## TL;DR Multi Agents
-
-```bash
-pip install praisonai
-export OPENAI_API_KEY="Enter your API key"
-praisonai --init create a movie script about dog in moon
-praisonai
-```
-
-## Table of Contents
-
-- [Installation](#installation)
-- [Initialise](#initialise)
-- [Run](#run)
-- [Full Automatic Mode](#full-automatic-mode)
-- [User Interface](#user-interface)
-- [Praison AI Chat](#praison-ai-chat)
-- [Create Custom Tools](#create-custom-tools)
-- [Agents Playbook](#agents-playbook)
-- [Include praisonai package in your project](#include-praisonai-package-in-your-project)
-- [Commands to Install Dev Dependencies](#commands-to-install-dependencies)
-- [Other Models](#other-models)
-- [Contributing](#contributing)
-- [Star History](#star-history)
-
-## Installation Multi Agents
-
-```bash
-pip install praisonai
-```
-
-## Initialise
-
-```bash
-export OPENAI_API_KEY="Enter your API key"
-```
-
-Generate your OPENAI API KEY from here: https://platform.openai.com/api-keys
-
-Note: You can use other providers such as Ollama, Mistral ... etc. Details are provided at the bottom.
-
-```bash
-praisonai --init create a movie script about dog in moon
-```
-
-This will automatically create agents.yaml file in the current directory.
-
-### To initialise with a specific agent framework (Optional):
-
-```bash
-praisonai --framework autogen --init create movie script about cat in mars
-```
-
-## Run
-
-```bash
-praisonai
-```
-
-or
-
-```bash
-python -m praisonai
-```
-
-### Specify the agent framework (Optional):
-
-```bash
-praisonai --framework autogen
-```
-
-### Full Automatic Mode
-
-```bash
-praisonai --auto create a movie script about Dog in Moon
-```
-
-## User Interface
-
-## PraisonAI User Interfaces:
-
-| Interface | Description                                | URL                                                                   |
-| --------- | ------------------------------------------ | --------------------------------------------------------------------- |
-| **UI**    | Multi Agents such as CrewAI or AutoGen     | [https://docs.praisonai.com/ui/ui](https://docs.praison.ai/ui/ui)     |
-| **Chat**  | Chat with 100+ LLMs, single AI Agent       | [https://docs.praisonai.com/ui/chat](https://docs.praison.ai/ui/chat) |
-| **Code**  | Chat with entire Codebase, single AI Agent | [https://docs.praisonai.com/ui/code](https://docs.praison.ai/ui/code) |
-
-```bash
-pip install -U "praisonai[ui]"
-export OPENAI_API_KEY="Enter your API key"
-chainlit create-secret
-export CHAINLIT_AUTH_SECRET=xxxxxxxx
-praisonai ui
-```
-
-or
-
-```
-python -m praisonai ui
-```
-
-## Praison AI Chat
-
-- https://docs.praison.ai/chat/
-
-```bash
-pip install "praisonai[chat]"
-export OPENAI_API_KEY="Enter your API key"
-praisonai chat
-```
-
-### Internet Search
-
-Praison AI Chat and Praison AI Code now includes internet search capabilities using Crawl4AI and Tavily, allowing you to retrieve up-to-date information during your conversations.
-
-### Vision Language Model Support
-
-You can now upload images and ask questions based on them using Vision Language Models. This feature enables visual understanding and analysis within your chat sessions.
-
-## Praison AI Code
-
-```bash
-pip install "praisonai[code]"
-export OPENAI_API_KEY="Enter your API key"
-praisonai code
-```
-
-### Internet Search
-
-Praison AI Code also includes internet search functionality, enabling you to find relevant code snippets and programming information online.
-
-## Create Custom Tools
-
-- https://docs.praison.ai/tools/custom/
+## No Code Options
 
 ## Agents Playbook
 
 ### Simple Playbook Example
 
+Create `agents.yaml` file and add the code below:
+
 ```yaml
-framework: crewai
+framework: praisonai
 topic: Artificial Intelligence
 roles:
   screenwriter:
@@ -420,62 +503,25 @@ roles:
         expected_output: "Complete script ready for production."
 ```
 
+*To run the playbook:*
+```bash
+praisonai agents.yaml
+```
+
 ## Use 100+ Models
 
 - https://docs.praison.ai/models/
+<div align="center">
+  <a href="https://docs.praison.ai">
+    <p align="center">
+      <img src="https://img.shields.io/badge/📚_Documentation-Visit_docs.praison.ai-blue?style=for-the-badge&logo=bookstack&logoColor=white" alt="Documentation" />
+    </p>
+  </a>
+</div>
 
-## Include praisonai package in your project
+## Development:
 
-- https://docs.praison.ai/developers/wrapper
-- https://docs.praison.ai/developers/wrapper-tools/
-
-## Option 1: Using RAW YAML
-
-```python
-from praisonai import PraisonAI
-
-# Example agent_yaml content
-agent_yaml = """
-framework: "crewai"
-topic: "Space Exploration"
-
-roles:
-  astronomer:
-    role: "Space Researcher"
-    goal: "Discover new insights about {topic}"
-    backstory: "You are a curious and dedicated astronomer with a passion for unraveling the mysteries of the cosmos."
-    tasks:
-      investigate_exoplanets:
-        description: "Research and compile information about exoplanets discovered in the last decade."
-        expected_output: "A summarized report on exoplanet discoveries, including their size, potential habitability, and distance from Earth."
-"""
-
-# Create a PraisonAI instance with the agent_yaml content
-praisonai = PraisonAI(agent_yaml=agent_yaml)
-
-# Run PraisonAI
-result = praisonai.run()
-
-# Print the result
-print(result)
-```
-
-## Option 2: Using separate agents.yaml file
-
-Note: Please create agents.yaml file before hand.
-
-```python
-from praisonai import PraisonAI
-
-def basic(): # Basic Mode
-    praisonai = PraisonAI(agent_file="agents.yaml")
-    praisonai.run()
-
-if __name__ == "__main__":
-    basic()
-```
-
-## Commands to Install Dependencies:
+Below is used for development only.
 
 ### Using uv
 ```bash
@@ -500,18 +546,34 @@ uv pip install -r pyproject.toml --extra "crewai,autogen"
 - Submit a pull request via GitHub's web interface.
 - Await feedback from project maintainers.
 
+## Other Features
+
+- 🔄 Use CrewAI or AG2 (Formerly AutoGen) Framework
+- 💻 Chat with ENTIRE Codebase
+- 🎨 Interactive UIs
+- 📄 YAML-based Configuration
+- 🛠️ Custom Tool Integration
+- 🔍 Internet Search Capability (using Crawl4AI and Tavily)
+- 🖼️ Vision Language Model (VLM) Support
+- 🎙️ Real-time Voice Interaction
+
 ## Star History
 
 [![Star History Chart](https://api.star-history.com/svg?repos=MervinPraison/PraisonAI&type=Date)](https://docs.praison.ai)
 
-## License
-
-Praison AI is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.
-
 ## Video Tutorials
 
 | Topic | Video |
 |-------|--------|
+| AI Agents with Self Reflection | [![Self Reflection](https://img.youtube.com/vi/vLXobEN2Vc8/0.jpg)](https://www.youtube.com/watch?v=vLXobEN2Vc8) |
+| Reasoning Data Generating Agent | [![Reasoning Data](https://img.youtube.com/vi/fUT332Y2zA8/0.jpg)](https://www.youtube.com/watch?v=fUT332Y2zA8) |
+| AI Agents with Reasoning | [![Reasoning](https://img.youtube.com/vi/KNDVWGN3TpM/0.jpg)](https://www.youtube.com/watch?v=KNDVWGN3TpM) |
+| Multimodal AI Agents | [![Multimodal](https://img.youtube.com/vi/hjAWmUT1qqY/0.jpg)](https://www.youtube.com/watch?v=hjAWmUT1qqY) |
+| AI Agents Workflow | [![Workflow](https://img.youtube.com/vi/yWTH44QPl2A/0.jpg)](https://www.youtube.com/watch?v=yWTH44QPl2A) |
+| Async AI Agents | [![Async](https://img.youtube.com/vi/VhVQfgo00LE/0.jpg)](https://www.youtube.com/watch?v=VhVQfgo00LE) |
+| Mini AI Agents | [![Mini](https://img.youtube.com/vi/OkvYp5aAGSg/0.jpg)](https://www.youtube.com/watch?v=OkvYp5aAGSg) |
+| AI Agents with Memory | [![Memory](https://img.youtube.com/vi/1hVfVxvPnnQ/0.jpg)](https://www.youtube.com/watch?v=1hVfVxvPnnQ) |
+| Repetitive Agents | [![Repetitive](https://img.youtube.com/vi/dAYGxsjDOPg/0.jpg)](https://www.youtube.com/watch?v=dAYGxsjDOPg) |
 | Introduction | [![Introduction](https://img.youtube.com/vi/Fn1lQjC0GO0/0.jpg)](https://www.youtube.com/watch?v=Fn1lQjC0GO0) |
 | Tools Overview | [![Tools Overview](https://img.youtube.com/vi/XaQRgRpV7jo/0.jpg)](https://www.youtube.com/watch?v=XaQRgRpV7jo) |
 | Custom Tools | [![Custom Tools](https://img.youtube.com/vi/JSU2Rndh06c/0.jpg)](https://www.youtube.com/watch?v=JSU2Rndh06c) |
@@ -524,59 +586,5 @@ Praison AI is an open-sourced software licensed under the **[MIT license](https:
 | Training | [![Training](https://img.youtube.com/vi/aLawE8kwCrI/0.jpg)](https://www.youtube.com/watch?v=aLawE8kwCrI) |
 | Realtime Voice Interface | [![Realtime](https://img.youtube.com/vi/frRHfevTCSw/0.jpg)](https://www.youtube.com/watch?v=frRHfevTCSw) |
 | Call Interface | [![Call](https://img.youtube.com/vi/m1cwrUG2iAk/0.jpg)](https://www.youtube.com/watch?v=m1cwrUG2iAk) |
+| Reasoning Extract Agents | [![Reasoning Extract](https://img.youtube.com/vi/2PPamsADjJA/0.jpg)](https://www.youtube.com/watch?v=2PPamsADjJA) |
 
-## License
-
-Praison AI is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.
-
-## Local Docker Development with Live Reload
-
-To facilitate local development with live reload, you can use Docker. Follow the steps below:
-
-1. **Create a `Dockerfile.dev`**:
-    ```dockerfile
-    FROM python:3.11-slim
-
-    WORKDIR /app
-
-    COPY . .
-
-    RUN pip install flask praisonai==2.0.18 watchdog
-
-    EXPOSE 5555
-
-    ENV FLASK_ENV=development
-
-    CMD ["flask", "run", "--host=0.0.0.0"]
-    ```
-
-2. **Create a `docker-compose.yml`**:
-    ```yaml
-    version: '3.8'
-
-    services:
-      app:
-        build:
-          context: .
-          dockerfile: Dockerfile.dev
-        volumes:
-          - .:/app
-        ports:
-          - "5555:5555"
-        environment:
-          FLASK_ENV: development
-        command: flask run --host=0.0.0.0
-
-      watch:
-        image: alpine:latest
-        volumes:
-          - .:/app
-        command: sh -c "apk add --no-cache inotify-tools && while inotifywait -r -e modify,create,delete /app; do kill -HUP 1; done"
-    ```
-
-3. **Run Docker Compose**:
-    ```bash
-    docker-compose up
-    ```
-
-This setup will allow you to develop locally with live reload, making it easier to test and iterate on your code.

agents/.cursorrules

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

agents/praisonaiagents/agent/__init__.py

@@ -1,4 +0,0 @@
-"""Agent module for AI agents"""
-from .agent import Agent
-
-__all__ = ['Agent'] 

agents/praisonaiagents/agent/agent.py

@@ -1,845 +0,0 @@
-import os
-import time
-import json
-import logging
-import asyncio
-from typing import List, Optional, Any, Dict, Union, Literal, TYPE_CHECKING
-from rich.console import Console
-from rich.live import Live
-from openai import AsyncOpenAI
-from ..main import (
-    display_error,
-    display_tool_call,
-    display_instruction,
-    display_interaction,
-    display_generating,
-    display_self_reflection,
-    ReflectionOutput,
-    client,
-    error_logs,
-    adisplay_instruction
-)
-import inspect
-import uuid
-
-if TYPE_CHECKING:
-    from ..task.task import Task
-
-class Agent:
-    def _generate_tool_definition(self, function_name):
-        """
-        Generate a tool definition from a function name by inspecting the function.
-        """
-        logging.debug(f"Attempting to generate tool definition for: {function_name}")
-        
-        # First try to get the tool definition if it exists
-        tool_def_name = f"{function_name}_definition"
-        tool_def = globals().get(tool_def_name)
-        logging.debug(f"Looking for {tool_def_name} in globals: {tool_def is not None}")
-        
-        if not tool_def:
-            import __main__
-            tool_def = getattr(__main__, tool_def_name, None)
-            logging.debug(f"Looking for {tool_def_name} in __main__: {tool_def is not None}")
-        
-        if tool_def:
-            logging.debug(f"Found tool definition: {tool_def}")
-            return tool_def
-
-        # Try to find the function in the agent's tools list first
-        func = None
-        for tool in self.tools:
-            if callable(tool) and getattr(tool, '__name__', '') == function_name:
-                func = tool
-                break
-        
-        logging.debug(f"Looking for {function_name} in agent tools: {func is not None}")
-        
-        # If not found in tools, try globals and main
-        if not func:
-            func = globals().get(function_name)
-            logging.debug(f"Looking for {function_name} in globals: {func is not None}")
-            
-            if not func:
-                import __main__
-                func = getattr(__main__, function_name, None)
-                logging.debug(f"Looking for {function_name} in __main__: {func is not None}")
-
-        if not func or not callable(func):
-            logging.debug(f"Function {function_name} not found or not callable")
-            return None
-
-        import inspect
-        # Langchain tools
-        if inspect.isclass(func) and hasattr(func, 'run') and not hasattr(func, '_run'):
-            original_func = func
-            func = func.run
-            function_name = original_func.__name__
-        # CrewAI tools
-        elif inspect.isclass(func) and hasattr(func, '_run'):
-            original_func = func
-            func = func._run
-            function_name = original_func.__name__
-
-        sig = inspect.signature(func)
-        logging.debug(f"Function signature: {sig}")
-        
-        # Skip self, *args, **kwargs, so they don't get passed in arguments
-        parameters_list = []
-        for name, param in sig.parameters.items():
-            if name == "self":
-                continue
-            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
-                continue
-            parameters_list.append((name, param))
-
-        parameters = {
-            "type": "object",
-            "properties": {},
-            "required": []
-        }
-        
-        # Parse docstring for parameter descriptions
-        docstring = inspect.getdoc(func)
-        logging.debug(f"Function docstring: {docstring}")
-        
-        param_descriptions = {}
-        if docstring:
-            import re
-            param_section = re.split(r'\s*Args:\s*', docstring)
-            logging.debug(f"Param section split: {param_section}")
-            if len(param_section) > 1:
-                param_lines = param_section[1].split('\n')
-                for line in param_lines:
-                    line = line.strip()
-                    if line and ':' in line:
-                        param_name, param_desc = line.split(':', 1)
-                        param_descriptions[param_name.strip()] = param_desc.strip()
-        
-        logging.debug(f"Parameter descriptions: {param_descriptions}")
-
-        for name, param in parameters_list:
-            param_type = "string"  # Default type
-            if param.annotation != inspect.Parameter.empty:
-                if param.annotation == int:
-                    param_type = "integer"
-                elif param.annotation == float:
-                    param_type = "number"
-                elif param.annotation == bool:
-                    param_type = "boolean"
-                elif param.annotation == list:
-                    param_type = "array"
-                elif param.annotation == dict:
-                    param_type = "object"
-            
-            param_info = {"type": param_type}
-            if name in param_descriptions:
-                param_info["description"] = param_descriptions[name]
-            
-            parameters["properties"][name] = param_info
-            if param.default == inspect.Parameter.empty:
-                parameters["required"].append(name)
-        
-        logging.debug(f"Generated parameters: {parameters}")
-
-        # Extract description from docstring
-        description = docstring.split('\n')[0] if docstring else f"Function {function_name}"
-        
-        tool_def = {
-            "type": "function",
-            "function": {
-                "name": function_name,
-                "description": description,
-                "parameters": parameters
-            }
-        }
-        logging.debug(f"Generated tool definition: {tool_def}")
-        return tool_def
-
-    def __init__(
-        self,
-        name: Optional[str] = None,
-        role: Optional[str] = None,
-        goal: Optional[str] = None,
-        backstory: Optional[str] = None,
-        instructions: Optional[str] = None,
-        llm: Optional[Union[str, Any]] = None,
-        tools: Optional[List[Any]] = None,
-        function_calling_llm: Optional[Any] = None,
-        max_iter: int = 20,
-        max_rpm: Optional[int] = None,
-        max_execution_time: Optional[int] = None,
-        memory: Optional[Any] = None,
-        verbose: bool = True,
-        allow_delegation: bool = False,
-        step_callback: Optional[Any] = None,
-        cache: bool = True,
-        system_template: Optional[str] = None,
-        prompt_template: Optional[str] = None,
-        response_template: Optional[str] = None,
-        allow_code_execution: Optional[bool] = False,
-        max_retry_limit: int = 2,
-        respect_context_window: bool = True,
-        code_execution_mode: Literal["safe", "unsafe"] = "safe",
-        embedder_config: Optional[Dict[str, 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,
-        user_id: Optional[str] = None
-    ):
-        # Add check at start if memory is requested
-        if memory is not None:
-            try:
-                from ..memory.memory import Memory
-                MEMORY_AVAILABLE = True
-            except ImportError:
-                raise ImportError(
-                    "Memory features requested in Agent but memory dependencies not installed. "
-                    "Please install with: pip install \"praisonaiagents[memory]\""
-                )
-
-        # Handle backward compatibility for required fields
-        if all(x is None for x in [name, role, goal, backstory, instructions]):
-            raise ValueError("At least one of name, role, goal, backstory, or instructions must be provided")
-
-        # If instructions are provided, use them to set role, goal, and backstory
-        if instructions:
-            self.name = name or "Agent"
-            self.role = role or "Assistant"
-            self.goal = goal or instructions
-            self.backstory = backstory or instructions
-            # Set self_reflect to False by default for instruction-based agents
-            self.self_reflect = False if self_reflect is None else self_reflect
-        else:
-            # Use provided values or defaults
-            self.name = name or "Agent"
-            self.role = role or "Assistant"
-            self.goal = goal or "Help the user with their tasks"
-            self.backstory = backstory or "I am an AI assistant"
-            # Default to True for traditional agents if not specified
-            self.self_reflect = True if self_reflect is None else self_reflect
-        
-        self.instructions = instructions
-        # Check for model name in environment variable if not provided
-        self.llm = llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
-        self.tools = tools if tools else []  # Store original tools
-        self.function_calling_llm = function_calling_llm
-        self.max_iter = max_iter
-        self.max_rpm = max_rpm
-        self.max_execution_time = max_execution_time
-        self.memory = memory
-        self.verbose = verbose
-        self.allow_delegation = allow_delegation
-        self.step_callback = step_callback
-        self.cache = cache
-        self.system_template = system_template
-        self.prompt_template = prompt_template
-        self.response_template = response_template
-        self.allow_code_execution = allow_code_execution
-        self.max_retry_limit = max_retry_limit
-        self.respect_context_window = respect_context_window
-        self.code_execution_mode = code_execution_mode
-        self.embedder_config = embedder_config
-        self.knowledge = knowledge
-        self.use_system_prompt = use_system_prompt
-        self.chat_history = []
-        self.markdown = markdown
-        self.max_reflect = max_reflect
-        self.min_reflect = min_reflect
-        # Use the same model selection logic for reflect_llm
-        self.reflect_llm = reflect_llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
-        self.console = Console()  # Create a single console instance for the agent
-        
-        # Initialize system prompt
-        self.system_prompt = f"""{self.backstory}\n
-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
-
-        # Check if knowledge parameter has any values
-        if not knowledge:
-            self.knowledge = None
-        else:
-            # 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
-        
-        description = self.instructions if self.instructions else f"Execute task as {self.role} with goal: {self.goal}"
-        expected_output = "Complete the assigned task successfully"
-        
-        return Task(
-            name=self.name,
-            description=description,
-            expected_output=expected_output,
-            agent=self,
-            tools=self.tools
-        )
-
-    def execute_tool(self, function_name, arguments):
-        """
-        Execute a tool dynamically based on the function name and arguments.
-        """
-        logging.debug(f"{self.name} executing tool {function_name} with arguments: {arguments}")
-
-        # Try to find the function in the agent's tools list first
-        func = None
-        for tool in self.tools:
-            if (callable(tool) and getattr(tool, '__name__', '') == function_name) or \
-               (inspect.isclass(tool) and tool.__name__ == function_name):
-                func = tool
-                break
-        
-        if func is None:
-            # If not found in tools, try globals and main
-            func = globals().get(function_name)
-            if not func:
-                import __main__
-                func = getattr(__main__, function_name, None)
-
-        if func:
-            try:
-                # Langchain: If it's a class with run but not _run, instantiate and call run
-                if inspect.isclass(func) and hasattr(func, 'run') and not hasattr(func, '_run'):
-                    instance = func()
-                    run_params = {k: v for k, v in arguments.items() 
-                                  if k in inspect.signature(instance.run).parameters 
-                                  and k != 'self'}
-                    return instance.run(**run_params)
-
-                # CrewAI: If it's a class with an _run method, instantiate and call _run
-                elif inspect.isclass(func) and hasattr(func, '_run'):
-                    instance = func()
-                    run_params = {k: v for k, v in arguments.items() 
-                                  if k in inspect.signature(instance._run).parameters 
-                                  and k != 'self'}
-                    return instance._run(**run_params)
-
-                # Otherwise treat as regular function
-                elif callable(func):
-                    return func(**arguments)
-            except Exception as e:
-                error_msg = str(e)
-                logging.error(f"Error executing tool {function_name}: {error_msg}")
-                return {"error": error_msg}
-        
-        error_msg = f"Tool '{function_name}' is not callable"
-        logging.error(error_msg)
-        return {"error": error_msg}
-
-    def clear_history(self):
-        self.chat_history = []
-
-    def __str__(self):
-        return f"Agent(name='{self.name}', role='{self.role}', goal='{self.goal}')"
-
-    def _chat_completion(self, messages, temperature=0.2, tools=None, stream=True):
-        start_time = time.time()
-        logging.debug(f"{self.name} sending messages to LLM: {messages}")
-
-        formatted_tools = []
-        if tools is None:
-            tools = self.tools
-        if tools:
-            for tool in tools:
-                if isinstance(tool, str):
-                    # Generate tool definition for string tool names
-                    tool_def = self._generate_tool_definition(tool)
-                    if tool_def:
-                        formatted_tools.append(tool_def)
-                    else:
-                        logging.warning(f"Could not generate definition for tool: {tool}")
-                elif isinstance(tool, dict):
-                    formatted_tools.append(tool)
-                elif hasattr(tool, "to_openai_tool"):
-                    formatted_tools.append(tool.to_openai_tool())
-                elif callable(tool):
-                    formatted_tools.append(self._generate_tool_definition(tool.__name__))
-                else:
-                    logging.warning(f"Tool {tool} not recognized")
-
-        try:
-            initial_response = client.chat.completions.create(
-                model=self.llm,
-                messages=messages,
-                temperature=temperature,
-                tools=formatted_tools if formatted_tools else None,
-                stream=False
-            )
-
-            tool_calls = getattr(initial_response.choices[0].message, 'tool_calls', None)
-
-            if tool_calls:
-                messages.append({
-                    "role": "assistant",
-                    "content": initial_response.choices[0].message.content,
-                    "tool_calls": tool_calls
-                })
-
-                for tool_call in tool_calls:
-                    function_name = tool_call.function.name
-                    arguments = json.loads(tool_call.function.arguments)
-
-                    if self.verbose:
-                        display_tool_call(f"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}")
-
-                    tool_result = self.execute_tool(function_name, arguments)
-                    results_str = json.dumps(tool_result) if tool_result else "Function returned an empty output"
-
-                    if self.verbose:
-                        display_tool_call(f"Function '{function_name}' returned: {results_str}")
-
-                    messages.append({
-                        "role": "tool",
-                        "tool_call_id": tool_call.id,
-                        "content": results_str
-                    })
-
-            if stream:
-                response_stream = client.chat.completions.create(
-                    model=self.llm,
-                    messages=messages,
-                    temperature=temperature,
-                    stream=True
-                )
-                full_response_text = ""
-                
-                # Create Live display with proper configuration
-                with Live(
-                    display_generating("", start_time),
-                    console=self.console,
-                    refresh_per_second=4,
-                    transient=True,  # Changed to False to preserve output
-                    vertical_overflow="ellipsis",
-                    auto_refresh=True
-                ) as live:
-                    for chunk in response_stream:
-                        if chunk.choices[0].delta.content:
-                            full_response_text += chunk.choices[0].delta.content
-                            live.update(display_generating(full_response_text, start_time))
-                
-                # Clear the last generating display with a blank line
-                self.console.print()
-                
-                final_response = client.chat.completions.create(
-                    model=self.llm,
-                    messages=messages,
-                    temperature=temperature,
-                    stream=False
-                )
-                return final_response
-            else:
-                if tool_calls:
-                    final_response = client.chat.completions.create(
-                        model=self.llm,
-                        messages=messages,
-                        temperature=temperature,
-                        stream=False
-                    )
-                    return final_response
-                else:
-                    return initial_response
-
-        except Exception as e:
-            display_error(f"Error in chat completion: {e}")
-            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
-Your Goal: {self.goal}
-            """
-            if output_json:
-                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_json.model_json_schema())}"
-            elif output_pydantic:
-                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_pydantic.model_json_schema())}"
-        else:
-            system_prompt = None
-
-        messages = []
-        if system_prompt:
-            messages.append({"role": "system", "content": system_prompt})
-        messages.extend(self.chat_history)
-
-        # Modify prompt if output_json or output_pydantic is specified
-        original_prompt = prompt
-        if output_json or output_pydantic:
-            if isinstance(prompt, str):
-                prompt += "\nReturn ONLY a valid JSON object. No other text or explanation."
-            elif isinstance(prompt, list):
-                # For multimodal prompts, append to the text content
-                for item in prompt:
-                    if item["type"] == "text":
-                        item["text"] += "\nReturn ONLY a valid JSON object. No other text or explanation."
-                        break
-
-        if isinstance(prompt, list):
-            # If we receive a multimodal prompt list, place it directly in the user message
-            messages.append({"role": "user", "content": prompt})
-        else:
-            messages.append({"role": "user", "content": prompt})
-
-        final_response_text = None
-        reflection_count = 0
-        start_time = time.time()
-
-        while True:
-            try:
-                if self.verbose:
-                    # Handle both string and list prompts for instruction display
-                    display_text = prompt
-                    if isinstance(prompt, list):
-                        # Extract text content from multimodal prompt
-                        display_text = next((item["text"] for item in prompt if item["type"] == "text"), "")
-                    
-                    if display_text and str(display_text).strip():
-                        # Pass agent information to display_instruction
-                        agent_tools = [t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools]
-                        display_instruction(
-                            f"Agent {self.name} is processing prompt: {display_text}", 
-                            console=self.console,
-                            agent_name=self.name,
-                            agent_role=self.role,
-                            agent_tools=agent_tools
-                        )
-
-                response = self._chat_completion(messages, temperature=temperature, tools=tools if tools else None)
-                if not response:
-                    return None
-
-                tool_calls = getattr(response.choices[0].message, 'tool_calls', None)
-                response_text = response.choices[0].message.content.strip()
-
-                if tool_calls:
-                    messages.append({
-                        "role": "assistant",
-                        "content": response_text,
-                        "tool_calls": tool_calls
-                    })
-                    
-                    for tool_call in tool_calls:
-                        function_name = tool_call.function.name
-                        arguments = json.loads(tool_call.function.arguments)
-
-                        if self.verbose:
-                            display_tool_call(f"Agent {self.name} is calling function '{function_name}' with arguments: {arguments}", console=self.console)
-
-                        tool_result = self.execute_tool(function_name, arguments)
-
-                        if tool_result:
-                            if self.verbose:
-                                display_tool_call(f"Function '{function_name}' returned: {tool_result}", console=self.console)
-                            messages.append({
-                                "role": "tool",
-                                "tool_call_id": tool_call.id,
-                                "content": json.dumps(tool_result)
-                            })
-                        else:
-                            messages.append({
-                                "role": "tool",
-                                "tool_call_id": tool_call.id,
-                                "content": "Function returned an empty output"
-                            })
-                        
-                    response = self._chat_completion(messages, temperature=temperature)
-                    if not response:
-                        return None
-                    response_text = response.choices[0].message.content.strip()
-
-                # Handle output_json or output_pydantic if specified
-                if output_json or output_pydantic:
-                    # Add to chat history and return raw response
-                    self.chat_history.append({"role": "user", "content": original_prompt})
-                    self.chat_history.append({"role": "assistant", "content": response_text})
-                    if self.verbose:
-                        display_interaction(original_prompt, response_text, markdown=self.markdown, 
-                                         generation_time=time.time() - start_time, console=self.console)
-                    return response_text
-
-                if not self.self_reflect:
-                    self.chat_history.append({"role": "user", "content": original_prompt})
-                    self.chat_history.append({"role": "assistant", "content": response_text})
-                    if self.verbose:
-                        logging.debug(f"Agent {self.name} final response: {response_text}")
-                    display_interaction(original_prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
-                    return response_text
-
-                reflection_prompt = f"""
-Reflect on your previous response: '{response_text}'.
-Identify any flaws, improvements, or actions.
-Provide a "satisfactory" status ('yes' or 'no').
-Output MUST be JSON with 'reflection' and 'satisfactory'.
-                """
-                logging.debug(f"{self.name} reflection attempt {reflection_count+1}, sending prompt: {reflection_prompt}")
-                messages.append({"role": "user", "content": reflection_prompt})
-
-                try:
-                    reflection_response = client.beta.chat.completions.parse(
-                        model=self.reflect_llm if self.reflect_llm else self.llm,
-                        messages=messages,
-                        temperature=temperature,
-                        response_format=ReflectionOutput
-                    )
-
-                    reflection_output = reflection_response.choices[0].message.parsed
-
-                    if self.verbose:
-                        display_self_reflection(f"Agent {self.name} self reflection (using {self.reflect_llm if self.reflect_llm else self.llm}): reflection='{reflection_output.reflection}' satisfactory='{reflection_output.satisfactory}'", console=self.console)
-
-                    messages.append({"role": "assistant", "content": f"Self Reflection: {reflection_output.reflection} Satisfactory?: {reflection_output.satisfactory}"})
-
-                    # Only consider satisfactory after minimum reflections
-                    if reflection_output.satisfactory == "yes" and reflection_count >= self.min_reflect - 1:
-                        if self.verbose:
-                            display_self_reflection("Agent marked the response as satisfactory after meeting minimum reflections", console=self.console)
-                        self.chat_history.append({"role": "user", "content": prompt})
-                        self.chat_history.append({"role": "assistant", "content": response_text})
-                        display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
-                        return response_text
-
-                    # Check if we've hit max reflections
-                    if reflection_count >= self.max_reflect - 1:
-                        if self.verbose:
-                            display_self_reflection("Maximum reflection count reached, returning current response", console=self.console)
-                        self.chat_history.append({"role": "user", "content": prompt})
-                        self.chat_history.append({"role": "assistant", "content": response_text})
-                        display_interaction(prompt, response_text, markdown=self.markdown, generation_time=time.time() - start_time, console=self.console)
-                        return response_text
-
-                    logging.debug(f"{self.name} reflection count {reflection_count + 1}, continuing reflection process")
-                    messages.append({"role": "user", "content": "Now regenerate your response using the reflection you made"})
-                    response = self._chat_completion(messages, temperature=temperature, tools=None, stream=True)
-                    response_text = response.choices[0].message.content.strip()
-                    reflection_count += 1
-                    continue  # Continue the loop for more reflections
-
-                except Exception as e:
-                    display_error(f"Error in parsing self-reflection json {e}. Retrying", console=self.console)
-                    logging.error("Reflection parsing failed.", exc_info=True)
-                    messages.append({"role": "assistant", "content": f"Self Reflection failed."})
-                    reflection_count += 1
-                    continue  # Continue even after error to try again
-                
-            except Exception as e:
-                display_error(f"Error in chat: {e}", console=self.console)
-                return None 
-
-    def clean_json_output(self, output: str) -> str:
-        """Clean and extract JSON from response text."""
-        cleaned = output.strip()
-        # Remove markdown code blocks if present
-        if cleaned.startswith("```json"):
-            cleaned = cleaned[len("```json"):].strip()
-        if cleaned.startswith("```"):
-            cleaned = cleaned[len("```"):].strip()
-        if cleaned.endswith("```"):
-            cleaned = cleaned[:-3].strip()
-        return cleaned 
-
-    async def achat(self, prompt, temperature=0.2, tools=None, output_json=None, output_pydantic=None):
-        """Async version of chat method"""
-        try:
-            # Build system prompt
-            system_prompt = self.system_prompt
-            if output_json:
-                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_json.model_json_schema())}"
-            elif output_pydantic:
-                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_pydantic.model_json_schema())}"
-
-            # Build messages
-            if isinstance(prompt, str):
-                messages = [
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": prompt + ("\nReturn ONLY a valid JSON object. No other text or explanation." if (output_json or output_pydantic) else "")}
-                ]
-            else:
-                # For multimodal prompts
-                messages = [
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": prompt}
-                ]
-                if output_json or output_pydantic:
-                    # Add JSON instruction to text content
-                    for item in messages[-1]["content"]:
-                        if item["type"] == "text":
-                            item["text"] += "\nReturn ONLY a valid JSON object. No other text or explanation."
-                            break
-
-            # Display instruction with agent info if verbose
-            if self.verbose:
-                display_text = prompt
-                if isinstance(prompt, list):
-                    display_text = next((item["text"] for item in prompt if item["type"] == "text"), "")
-                
-                if display_text and str(display_text).strip():
-                    agent_tools = [t.__name__ if hasattr(t, '__name__') else str(t) for t in self.tools]
-                    await adisplay_instruction(
-                        f"Agent {self.name} is processing prompt: {display_text}",
-                        console=self.console,
-                        agent_name=self.name,
-                        agent_role=self.role,
-                        agent_tools=agent_tools
-                    )
-
-            # Format tools if provided
-            formatted_tools = []
-            if tools:
-                for tool in tools:
-                    if isinstance(tool, str):
-                        tool_def = self._generate_tool_definition(tool)
-                        if tool_def:
-                            formatted_tools.append(tool_def)
-                    elif isinstance(tool, dict):
-                        formatted_tools.append(tool)
-                    elif hasattr(tool, "to_openai_tool"):
-                        formatted_tools.append(tool.to_openai_tool())
-                    elif callable(tool):
-                        formatted_tools.append(self._generate_tool_definition(tool.__name__))
-
-            # Create async OpenAI client
-            async_client = AsyncOpenAI()
-
-            # Make the API call based on the type of request
-            if tools:
-                response = await async_client.chat.completions.create(
-                    model=self.llm,
-                    messages=messages,
-                    temperature=temperature,
-                    tools=formatted_tools
-                )
-                return await self._achat_completion(response, tools)
-            elif output_json or output_pydantic:
-                response = await async_client.chat.completions.create(
-                    model=self.llm,
-                    messages=messages,
-                    temperature=temperature,
-                    response_format={"type": "json_object"}
-                )
-                # Return the raw response
-                return response.choices[0].message.content
-            else:
-                response = await async_client.chat.completions.create(
-                    model=self.llm,
-                    messages=messages,
-                    temperature=temperature
-                )
-                return response.choices[0].message.content
-        except Exception as e:
-            display_error(f"Error in chat completion: {e}")
-            return None
-
-    async def _achat_completion(self, response, tools):
-        """Async version of _chat_completion method"""
-        try:
-            message = response.choices[0].message
-            if not hasattr(message, 'tool_calls') or not message.tool_calls:
-                return message.content
-
-            results = []
-            for tool_call in message.tool_calls:
-                try:
-                    function_name = tool_call.function.name
-                    arguments = json.loads(tool_call.function.arguments)
-                    
-                    # Find the matching tool
-                    tool = next((t for t in tools if t.__name__ == function_name), None)
-                    if not tool:
-                        display_error(f"Tool {function_name} not found")
-                        continue
-                    
-                    # Check if the tool is async
-                    if asyncio.iscoroutinefunction(tool):
-                        result = await tool(**arguments)
-                    else:
-                        # Run sync function in executor to avoid blocking
-                        loop = asyncio.get_event_loop()
-                        result = await loop.run_in_executor(None, lambda: tool(**arguments))
-                    
-                    results.append(result)
-                except Exception as e:
-                    display_error(f"Error executing tool {function_name}: {e}")
-                    results.append(None)
-
-            # If we have results, format them into a response
-            if results:
-                formatted_results = "\n".join([str(r) for r in results if r is not None])
-                if formatted_results:
-                    messages = [
-                        {"role": "system", "content": self.system_prompt},
-                        {"role": "assistant", "content": "Here are the tool results:"},
-                        {"role": "user", "content": formatted_results + "\nPlease process these results and provide a final response."}
-                    ]
-                    try:
-                        async_client = AsyncOpenAI()
-                        final_response = await async_client.chat.completions.create(
-                            model=self.llm,
-                            messages=messages,
-                            temperature=0.2
-                        )
-                        return final_response.choices[0].message.content
-                    except Exception as e:
-                        display_error(f"Error in final chat completion: {e}")
-                        return formatted_results
-                return formatted_results
-            return None
-        except Exception as e:
-            display_error(f"Error in _achat_completion: {e}")
-            return None 
-
-    def run(self):
-        """Alias for start() method"""
-        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/process/process.py

@@ -1,650 +0,0 @@
-import logging
-import asyncio
-from typing import Dict, Optional, List, Any, AsyncGenerator
-from pydantic import BaseModel
-from ..agent.agent import Agent
-from ..task.task import Task
-from ..main import display_error, client
-import csv
-import os
-
-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, 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:
-                for next_task_name in task.next_tasks:
-                    next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
-                    if next_task:
-                        next_task.previous_tasks.append(task.name)
-
-        # Find start task
-        start_task = None
-        for task_id, task in self.tasks.items():
-            if task.is_start:
-                start_task = task
-                break
-        
-        if not start_task:
-            start_task = list(self.tasks.values())[0]
-            logging.info("No start task marked, using first task")
-        
-        current_task = start_task
-        visited_tasks = set()
-        loop_data = {}  # Store loop-specific data
-        
-        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}")
-            
-            # Add context from previous tasks to description
-            if current_task.previous_tasks or current_task.context:
-                context = "\nInput data from previous tasks:"
-                
-                # Add data from previous tasks in workflow
-                for prev_name in current_task.previous_tasks:
-                    prev_task = next((t for t in self.tasks.values() if t.name == prev_name), None)
-                    if prev_task and prev_task.result:
-                        # Handle loop data
-                        if current_task.task_type == "loop":
-#                             # create a loop manager Agent
-#                             loop_manager = Agent(
-#                                 name="Loop Manager",
-#                                 role="Loop data processor",
-#                                 goal="Process loop data and convert it to list format",
-#                                 backstory="Expert at handling loop data and converting it to proper format",
-#                                 llm=self.manager_llm,
-#                                 verbose=self.verbose,
-#                                 markdown=True
-#                             )
-
-#                             # get the loop data convert it to list using calling Agent class chat
-#                             loop_prompt = f"""
-# Process this data into a list format:
-# {prev_task.result.raw}
-
-# Return a JSON object with an 'items' array containing the items to process.
-# """
-#                             if current_task.async_execution:
-#                                 loop_data_str = await loop_manager.achat(
-#                                     prompt=loop_prompt,
-#                                     output_json=LoopItems
-#                                 )
-#                             else:
-#                                 loop_data_str = loop_manager.chat(
-#                                     prompt=loop_prompt,
-#                                     output_json=LoopItems
-#                                 )
-                            
-#                             try:
-#                                 # The response will already be parsed into LoopItems model
-#                                 loop_data[f"loop_{current_task.name}"] = {
-#                                     "items": loop_data_str.items,
-#                                     "index": 0,
-#                                     "remaining": len(loop_data_str.items)
-#                                 }
-#                                 context += f"\nCurrent loop item: {loop_data_str.items[0]}"
-#                             except Exception as e:
-#                                 display_error(f"Failed to process loop data: {e}")
-#                                 context += f"\n{prev_name}: {prev_task.result.raw}"
-                            context += f"\n{prev_name}: {prev_task.result.raw}"
-                        else:
-                            context += f"\n{prev_name}: {prev_task.result.raw}"
-                
-                # Add data from context tasks
-                if current_task.context:
-                    for ctx_task in current_task.context:
-                        if ctx_task.result and ctx_task.name != current_task.name:
-                            context += f"\n{ctx_task.name}: {ctx_task.result.raw}"
-                
-                # Update task description with context
-                current_task.description = current_task.description + context
-            
-            # Execute task using existing run_task method
-            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}"
-                if loop_key in loop_data:
-                    loop_info = loop_data[loop_key]
-                    loop_info["index"] += 1
-                    has_more = loop_info["remaining"] > 0
-                    
-                    # Update result to trigger correct condition
-                    if current_task.result:
-                        result = current_task.result.raw
-                        if has_more:
-                            result += "\nmore"
-                        else:
-                            result += "\ndone"
-                        current_task.result.raw = result
-                    
-            # Determine next task based on result
-            next_task = None
-            if current_task and current_task.result:
-                if current_task.task_type in ["decision", "loop"]:
-                    # MINIMAL CHANGE: use pydantic decision if present
-                    decision_str = current_task.result.raw.lower()
-                    if current_task.result.pydantic and hasattr(current_task.result.pydantic, "decision"):
-                        decision_str = current_task.result.pydantic.decision.lower()
-
-                    # Check conditions
-                    for condition, tasks in current_task.condition.items():
-                        if condition.lower() == decision_str:
-                            # 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":
-                                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 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:
-                logging.info("Workflow execution completed")
-                break
-
-    async def asequential(self) -> AsyncGenerator[str, None]:
-        """Async version of sequential method"""
-        for task_id in self.tasks:
-            if self.tasks[task_id].status != "completed":
-                yield task_id
-
-    async def ahierarchical(self) -> AsyncGenerator[str, None]:
-        """Async version of hierarchical method"""
-        logging.debug(f"Starting hierarchical task execution with {len(self.tasks)} tasks")
-        manager_agent = Agent(
-            name="Manager",
-            role="Project manager",
-            goal="Manage the entire flow of tasks and delegate them to the right agent",
-            backstory="Expert project manager to coordinate tasks among agents",
-            llm=self.manager_llm,
-            verbose=self.verbose,
-            markdown=True,
-            self_reflect=False
-        )
-
-        class ManagerInstructions(BaseModel):
-            task_id: int
-            agent_name: str
-            action: str
-
-        manager_task = Task(
-            name="manager_task",
-            description="Decide the order of tasks and which agent executes them",
-            expected_output="All tasks completed successfully",
-            agent=manager_agent
-        )
-        manager_task_id = yield manager_task
-        logging.info(f"Created manager task with ID {manager_task_id}")
-
-        completed_count = 0
-        total_tasks = len(self.tasks) - 1
-        logging.info(f"Need to complete {total_tasks} tasks (excluding manager task)")
-
-        while completed_count < total_tasks:
-            tasks_summary = []
-            for tid, tk in self.tasks.items():
-                if tk.name == "manager_task":
-                    continue
-                task_info = {
-                    "task_id": tid,
-                    "name": tk.name,
-                    "description": tk.description,
-                    "status": tk.status if tk.status else "not started",
-                    "agent": tk.agent.name if tk.agent else "No agent"
-                }
-                tasks_summary.append(task_info)
-                logging.info(f"Task {tid} status: {task_info}")
-
-            manager_prompt = f"""
-Here is the current status of all tasks except yours (manager_task):
-{tasks_summary}
-
-Provide a JSON with the structure:
-{{
-   "task_id": <int>,
-   "agent_name": "<string>",
-   "action": "<execute or stop>"
-}}
-"""
-
-            try:
-                logging.info("Requesting manager instructions...")
-                if manager_task.async_execution:
-                    manager_response = await client.beta.chat.completions.parse(
-                        model=self.manager_llm,
-                        messages=[
-                            {"role": "system", "content": manager_task.description},
-                            {"role": "user", "content": manager_prompt}
-                        ],
-                        temperature=0.7,
-                        response_format=ManagerInstructions
-                    )
-                else:
-                    manager_response = client.beta.chat.completions.parse(
-                        model=self.manager_llm,
-                        messages=[
-                            {"role": "system", "content": manager_task.description},
-                            {"role": "user", "content": manager_prompt}
-                        ],
-                        temperature=0.7,
-                        response_format=ManagerInstructions
-                    )
-                parsed_instructions = manager_response.choices[0].message.parsed
-                logging.info(f"Manager instructions: {parsed_instructions}")
-            except Exception as e:
-                display_error(f"Manager parse error: {e}")
-                logging.error(f"Manager parse error: {str(e)}", exc_info=True)
-                break
-
-            selected_task_id = parsed_instructions.task_id
-            selected_agent_name = parsed_instructions.agent_name
-            action = parsed_instructions.action
-
-            logging.info(f"Manager selected task_id={selected_task_id}, agent={selected_agent_name}, action={action}")
-
-            if action.lower() == "stop":
-                logging.info("Manager decided to stop task execution")
-                break
-
-            if selected_task_id not in self.tasks:
-                error_msg = f"Manager selected invalid task id {selected_task_id}"
-                display_error(error_msg)
-                logging.error(error_msg)
-                break
-
-            original_agent = self.tasks[selected_task_id].agent.name if self.tasks[selected_task_id].agent else "None"
-            for a in self.agents:
-                if a.name == selected_agent_name:
-                    self.tasks[selected_task_id].agent = a
-                    logging.info(f"Changed agent for task {selected_task_id} from {original_agent} to {selected_agent_name}")
-                    break
-
-            if self.tasks[selected_task_id].status != "completed":
-                logging.info(f"Starting execution of task {selected_task_id}")
-                yield selected_task_id
-                logging.info(f"Finished execution of task {selected_task_id}, status: {self.tasks[selected_task_id].status}")
-
-            if self.tasks[selected_task_id].status == "completed":
-                completed_count += 1
-                logging.info(f"Task {selected_task_id} completed. Total completed: {completed_count}/{total_tasks}")
-
-        self.tasks[manager_task.id].status = "completed"
-        if self.verbose >= 1:
-            logging.info("All tasks completed under manager supervision.")
-        logging.info("Hierarchical task execution finished") 
-
-    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:
-                for next_task_name in task.next_tasks:
-                    next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
-                    if next_task:
-                        next_task.previous_tasks.append(task.name)
-
-        # Find start task
-        start_task = None
-        for task_id, task in self.tasks.items():
-            if task.is_start:
-                start_task = task
-                break
-        
-        if not start_task:
-            start_task = list(self.tasks.values())[0]
-            logging.info("No start task marked, using first task")
-
-        # If loop type and no input_file, default to tasks.csv 
-        if start_task and start_task.task_type == "loop" and not start_task.input_file:
-            start_task.input_file = "tasks.csv"
-
-        # --- If loop + input_file, read file & create tasks
-        if start_task and start_task.task_type == "loop" and getattr(start_task, "input_file", None):
-            try:
-                file_ext = os.path.splitext(start_task.input_file)[1].lower()
-                new_tasks = []
-                
-                if file_ext == ".csv":
-                    # existing CSV reading logic
-                    with open(start_task.input_file, "r", encoding="utf-8") as f:
-                        # Try as simple CSV first
-                        reader = csv.reader(f)
-                        previous_task = None
-                        for i, row in enumerate(reader):
-                            if row:  # Skip empty rows
-                                task_desc = row[0]  # Take first column
-                                row_task = Task(
-                                    description=task_desc,  # Keep full row as description
-                                    agent=start_task.agent,
-                                    name=task_desc,       # Use first column as name
-                                    is_start=(i == 0),
-                                    task_type="task",
-                                    condition={
-                                        "complete": ["next"],
-                                        "retry": ["current"]
-                                    }
-                                )
-                                self.tasks[row_task.id] = row_task
-                                new_tasks.append(row_task)
-                                
-                                if previous_task:
-                                    previous_task.next_tasks = [row_task.name]
-                                    previous_task.condition["complete"] = [row_task.name]
-                                previous_task = row_task
-                else:
-                    # If not CSV, read lines
-                    with open(start_task.input_file, "r", encoding="utf-8") as f:
-                        lines = f.read().splitlines()
-                        previous_task = None
-                        for i, line in enumerate(lines):
-                            row_task = Task(
-                                description=line.strip(),
-                                agent=start_task.agent,
-                                name=line.strip(),
-                                is_start=(i == 0),
-                                task_type="task",
-                                condition={
-                                    "complete": ["next"],
-                                    "retry": ["current"]
-                                }
-                            )
-                            self.tasks[row_task.id] = row_task
-                            new_tasks.append(row_task)
-                            
-                            if previous_task:
-                                previous_task.next_tasks = [row_task.name]
-                                previous_task.condition["complete"] = [row_task.name]
-                            previous_task = row_task
-
-                if new_tasks:
-                    start_task = new_tasks[0]
-                    logging.info(f"Created {len(new_tasks)} tasks from: {start_task.input_file}")
-            except Exception as e:
-                logging.error(f"Failed to read file tasks: {e}")
-
-        # end of the new block
-        current_task = start_task
-        visited_tasks = set()
-        loop_data = {}  # Store loop-specific data
-        
-        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}")
-            
-            # Add context from previous tasks to description
-            if current_task.previous_tasks or current_task.context:
-                context = "\nInput data from previous tasks:"
-                
-                # Add data from previous tasks in workflow
-                for prev_name in current_task.previous_tasks:
-                    prev_task = next((t for t in self.tasks.values() if t.name == prev_name), None)
-                    if prev_task and prev_task.result:
-                        # Handle loop data
-                        if current_task.task_type == "loop":
-#                             # create a loop manager Agent
-#                             loop_manager = Agent(
-#                                 name="Loop Manager",
-#                                 role="Loop data processor",
-#                                 goal="Process loop data and convert it to list format",
-#                                 backstory="Expert at handling loop data and converting it to proper format",
-#                                 llm=self.manager_llm,
-#                                 verbose=self.verbose,
-#                                 markdown=True
-#                             )
-
-#                             # get the loop data convert it to list using calling Agent class chat
-#                             loop_prompt = f"""
-# Process this data into a list format:
-# {prev_task.result.raw}
-
-# Return a JSON object with an 'items' array containing the items to process.
-# """
-#                             loop_data_str = loop_manager.chat(
-#                                 prompt=loop_prompt,
-#                                 output_json=LoopItems
-#                             )
-                            
-#                             try:
-#                                 # The response will already be parsed into LoopItems model
-#                                 loop_data[f"loop_{current_task.name}"] = {
-#                                     "items": loop_data_str.items,
-#                                     "index": 0,
-#                                     "remaining": len(loop_data_str.items)
-#                                 }
-#                                 context += f"\nCurrent loop item: {loop_data_str.items[0]}"
-#                             except Exception as e:
-#                                 display_error(f"Failed to process loop data: {e}")
-#                                 context += f"\n{prev_name}: {prev_task.result.raw}"
-                            context += f"\n{prev_name}: {prev_task.result.raw}"
-                        else:
-                            context += f"\n{prev_name}: {prev_task.result.raw}"
-                
-                # Add data from context tasks
-                if current_task.context:
-                    for ctx_task in current_task.context:
-                        if ctx_task.result and ctx_task.name != current_task.name:
-                            context += f"\n{ctx_task.name}: {ctx_task.result.raw}"
-                
-                # Update task description with context
-                current_task.description = current_task.description + context
-            
-            # Execute task using existing run_task method
-            yield task_id
-            visited_tasks.add(task_id)
-            
-            # Reset completed task to "not started" so it can run again: Only for workflow because some tasks may be revisited
-            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}"
-                if loop_key in loop_data:
-                    loop_info = loop_data[loop_key]
-                    loop_info["index"] += 1
-                    has_more = loop_info["remaining"] > 0
-                    
-                    # Update result to trigger correct condition
-                    if current_task.result:
-                        result = current_task.result.raw
-                        if has_more:
-                            result += "\nmore"
-                        else:
-                            result += "\ndone"
-                        current_task.result.raw = result
-                    
-            # Determine next task based on result
-            next_task = None
-            if current_task and current_task.result:
-                if current_task.task_type in ["decision", "loop"]:
-                    # MINIMAL CHANGE: use pydantic decision if present
-                    decision_str = current_task.result.raw.lower()
-                    if current_task.result.pydantic and hasattr(current_task.result.pydantic, "decision"):
-                        decision_str = current_task.result.pydantic.decision.lower()
-
-                    # Check conditions
-                    for condition, tasks in current_task.condition.items():
-                        if condition.lower() == decision_str:
-                            # 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":
-                                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 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:
-                logging.info("Workflow execution completed")
-                break
-
-    def sequential(self):
-        """Synchronous version of sequential method"""
-        for task_id in self.tasks:
-            if self.tasks[task_id].status != "completed":
-                yield task_id
-
-    def hierarchical(self):
-        """Synchronous version of hierarchical method"""
-        logging.debug(f"Starting hierarchical task execution with {len(self.tasks)} tasks")
-        manager_agent = Agent(
-            name="Manager",
-            role="Project manager",
-            goal="Manage the entire flow of tasks and delegate them to the right agent",
-            backstory="Expert project manager to coordinate tasks among agents",
-            llm=self.manager_llm,
-            verbose=self.verbose,
-            markdown=True,
-            self_reflect=False
-        )
-
-        class ManagerInstructions(BaseModel):
-            task_id: int
-            agent_name: str
-            action: str
-
-        manager_task = Task(
-            name="manager_task",
-            description="Decide the order of tasks and which agent executes them",
-            expected_output="All tasks completed successfully",
-            agent=manager_agent
-        )
-        manager_task_id = yield manager_task
-        logging.info(f"Created manager task with ID {manager_task_id}")
-
-        completed_count = 0
-        total_tasks = len(self.tasks) - 1
-        logging.info(f"Need to complete {total_tasks} tasks (excluding manager task)")
-
-        while completed_count < total_tasks:
-            tasks_summary = []
-            for tid, tk in self.tasks.items():
-                if tk.name == "manager_task":
-                    continue
-                task_info = {
-                    "task_id": tid,
-                    "name": tk.name,
-                    "description": tk.description,
-                    "status": tk.status if tk.status else "not started",
-                    "agent": tk.agent.name if tk.agent else "No agent"
-                }
-                tasks_summary.append(task_info)
-                logging.info(f"Task {tid} status: {task_info}")
-
-            manager_prompt = f"""
-Here is the current status of all tasks except yours (manager_task):
-{tasks_summary}
-
-Provide a JSON with the structure:
-{{
-   "task_id": <int>,
-   "agent_name": "<string>",
-   "action": "<execute or stop>"
-}}
-"""
-
-            try:
-                logging.info("Requesting manager instructions...")
-                manager_response = client.beta.chat.completions.parse(
-                    model=self.manager_llm,
-                    messages=[
-                        {"role": "system", "content": manager_task.description},
-                        {"role": "user", "content": manager_prompt}
-                    ],
-                    temperature=0.7,
-                    response_format=ManagerInstructions
-                )
-                parsed_instructions = manager_response.choices[0].message.parsed
-                logging.info(f"Manager instructions: {parsed_instructions}")
-            except Exception as e:
-                display_error(f"Manager parse error: {e}")
-                logging.error(f"Manager parse error: {str(e)}", exc_info=True)
-                break
-
-            selected_task_id = parsed_instructions.task_id
-            selected_agent_name = parsed_instructions.agent_name
-            action = parsed_instructions.action
-
-            logging.info(f"Manager selected task_id={selected_task_id}, agent={selected_agent_name}, action={action}")
-
-            if action.lower() == "stop":
-                logging.info("Manager decided to stop task execution")
-                break
-
-            if selected_task_id not in self.tasks:
-                error_msg = f"Manager selected invalid task id {selected_task_id}"
-                display_error(error_msg)
-                logging.error(error_msg)
-                break
-
-            original_agent = self.tasks[selected_task_id].agent.name if self.tasks[selected_task_id].agent else "None"
-            for a in self.agents:
-                if a.name == selected_agent_name:
-                    self.tasks[selected_task_id].agent = a
-                    logging.info(f"Changed agent for task {selected_task_id} from {original_agent} to {selected_agent_name}")
-                    break
-
-            if self.tasks[selected_task_id].status != "completed":
-                logging.info(f"Starting execution of task {selected_task_id}")
-                yield selected_task_id
-                logging.info(f"Finished execution of task {selected_task_id}, status: {self.tasks[selected_task_id].status}")
-
-            if self.tasks[selected_task_id].status == "completed":
-                completed_count += 1
-                logging.info(f"Task {selected_task_id} completed. Total completed: {completed_count}/{total_tasks}")
-
-        self.tasks[manager_task.id].status = "completed"
-        if self.verbose >= 1:
-            logging.info("All tasks completed under manager supervision.")
-        logging.info("Hierarchical task execution finished") 

docker/Dockerfile

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

docker/Dockerfile.chat

@@ -13,7 +13,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN pip install --no-cache-dir \
     praisonaiagents>=0.0.4 \
     praisonai_tools \
-    "praisonai==2.0.18" \
+    "praisonai==2.2.1" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -15,7 +15,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN pip install --no-cache-dir \
     praisonaiagents>=0.0.4 \
     praisonai_tools \
-    "praisonai==2.0.18" \
+    "praisonai==2.2.1" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -13,7 +13,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN pip install --no-cache-dir \
     praisonaiagents>=0.0.4 \
     praisonai_tools \
-    "praisonai==2.0.18" \
+    "praisonai==2.2.1" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

docs/api-reference/index.mdx

@@ -30,7 +30,7 @@ Features:
 - Built-in tools
 - Structured workflows
 
-### AutoGen Integration
+### AG2 (Formerly AutoGen) Integration
 Requires installation with:
 ```bash
 pip install "praisonai[autogen]"

docs/api.mdx

@@ -23,7 +23,7 @@ from praisonai.auto import AutoGenerator
 ### praisonai.agents_generator
 Framework-specific agent generation and orchestration:
 - CrewAI support (requires `praisonai[crewai]`)
-- AutoGen support (requires `praisonai[autogen]`)
+- AG2 (Formerly AutoGen) support (requires `praisonai[autogen]`)
 
 ```python
 from praisonai.agents_generator import AgentsGenerator
@@ -51,7 +51,7 @@ pip install praisonai
 
 # Framework-specific installations
 pip install "praisonai[crewai]"    # Install with CrewAI support
-pip install "praisonai[autogen]"   # Install with AutoGen support
+pip install "praisonai[autogen]"   # Install with AG2 support
 pip install "praisonai[crewai,autogen]"  # Install both frameworks
 
 # Additional features
@@ -71,9 +71,9 @@ When installing with `pip install "praisonai[crewai]"`, you get:
 - Task delegation capabilities
 - Sequential and parallel task execution
 
-### AutoGen
+### AG2 (Formerly AutoGen)
 When installing with `pip install "praisonai[autogen]"`, you get:
-- AutoGen framework support
+- AG2 framework support
 - PraisonAI tools integration
 - Multi-agent conversation capabilities
 - Code execution environment

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.55 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.2.1 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

@@ -112,86 +112,22 @@ graph LR
   <Step title="Create Agent">
     Create `app.py`:
 <CodeGroup>
-  ```python Single Agent
-  from praisonaiagents import Agent, Task, PraisonAIAgents
+```python Single Agent
+from praisonaiagents import Agent
 
-  # Create an agent
-  researcher = Agent(
-      name="Researcher",
-      role="Senior Research Analyst",
-      goal="Uncover cutting-edge developments in AI",
-      backstory="You are an expert at a technology research group",
-      verbose=True,
-      llm="gpt-4o"
-  )
+agent = Agent(instructions="Your are a helpful AI assistant")
+agent.start("Write a movie script about a robot in Mars")
+```
 
-  # Define a task
-  task = Task(
-      name="research_task",
-      description="Analyze 2024's AI advancements",
-      expected_output="A detailed report",
-      agent=researcher
-  )
+```python Multi Agents
+from praisonaiagents import Agent, PraisonAIAgents
 
-  # Run the agents
-  agents = PraisonAIAgents(
-      agents=[researcher],
-      tasks=[task],
-      verbose=False
-  )
+research_agent = Agent(instructions="Research about AI")
+summarise_agent = Agent(instructions="Summarise research agent's findings")
 
-  result = agents.start()
-  ```
-
-  ```python Multiple Agents
-  from praisonaiagents import Agent, Task, PraisonAIAgents
-
-  # Create multiple agents
-  researcher = Agent(
-      name="Researcher",
-      role="Senior Research Analyst",
-      goal="Uncover cutting-edge developments in AI",
-      backstory="You are an expert at a technology research group",
-      verbose=True,
-      llm="gpt-4o",
-      markdown=True
-  )
-
-  writer = Agent(
-      name="Writer",
-      role="Tech Content Strategist",
-      goal="Craft compelling content on tech advancements",
-      backstory="You are a content strategist",
-      llm="gpt-4o",
-      markdown=True
-  )
-
-  # Define multiple tasks
-  task1 = Task(
-      name="research_task",
-      description="Analyze 2024's AI advancements",
-      expected_output="A detailed report",
-      agent=researcher
-  )
-
-  task2 = Task(
-      name="writing_task",
-      description="Create a blog post about AI advancements",
-      expected_output="A blog post",
-      agent=writer
-  )
-
-  # Run with hierarchical process
-  agents = PraisonAIAgents(
-      agents=[researcher, writer],
-      tasks=[task1, task2],
-      verbose=False,
-      process="hierarchical",
-      manager_llm="gpt-4o"
-  )
-
-  result = agents.start()
-  ```
+agents = PraisonAIAgents(agents=[research_agent, summarise_agent])
+agents.start()
+```
 </CodeGroup>
   </Step>
 

docs/course/agents/01-introduction.mdx

@@ -0,0 +1,71 @@
+---
+title: "Introduction to AI Agents"
+description: "Welcome to the beginner's course on AI Agents"
+icon: "book-open"
+---
+
+# Introduction to AI Agents
+
+Welcome to the beginners' course on AI Agents! This course is designed to help you understand and build your own AI agents, even if you have little to no programming experience.
+
+## What Are AI Agents?
+
+An AI agent is a software program that can:
+- Understand information from its environment
+- Make decisions based on that information
+- Take actions to achieve specific goals
+
+Think of an AI agent like a helpful assistant that can perform tasks for you automatically.
+
+```mermaid
+graph TD
+    A[Perceive Information] --> B[Make Decisions]
+    B --> C[Take Actions]
+    C --> A
+```
+
+## Examples in Daily Life
+
+You might already be using AI agents without realizing it:
+
+- **Virtual Assistants**: Siri, Alexa, and Google Assistant are AI agents that respond to your voice commands
+- **Recommendation Systems**: Netflix, YouTube, and Amazon use AI agents to suggest content you might like
+- **Smart Home Devices**: Devices that adjust temperature or lighting based on your preferences
+
+## What You'll Learn in This Course
+
+Throughout this course, you will:
+
+1. Understand the basic concepts of AI agents
+2. Learn about different types of AI agents
+3. Explore how AI agents make decisions
+4. Discover how to build simple AI agents without complex programming
+5. Create your own functional AI agents
+
+## Who This Course Is For
+
+This course is perfect for:
+- Complete beginners with no prior knowledge of AI
+- Non-technical professionals interested in how AI can solve problems
+- Students curious about artificial intelligence
+- Anyone who wants to understand and use AI agents in practical ways
+
+Let's begin our journey into the fascinating world of AI agents!
+<iframe 
+  id="codeExecutionFrame"
+  src="https://code-execution-server-praisonai.replit.app/?code=import%20openai%0A%0Aclient%20%3D%20openai.OpenAI()%0Aresult%20%3D%20client.chat.completions.create(%0A%20%20%20%20model%3D%22gpt-3.5-turbo%22%2C%0A%20%20%20%20messages%3D%5B%0A%20%20%20%20%20%20%20%20%7B%22role%22%3A%20%22user%22%2C%20%22content%22%3A%20%22Hello%20World%22%7D%0A%20%20%20%20%5D%0A)%0A%0Aprint(result.choices%5B0%5D.message.content)" 
+  width="100%" 
+  height="600px" 
+  frameborder="0"
+  allow="clipboard-read; clipboard-write"
+  scrolling="yes"
+  onload="resizeIframe(this)"
+></iframe>
+
+<IframeWithAutoHeight />
+
+<CardGroup cols={1}>
+  <Card title="Ready to Start?" icon="rocket">
+    Continue to the next lesson to learn about the different types of AI agents.
+  </Card>
+</CardGroup>

docs/course/agents/02-types-of-agents.mdx

@@ -0,0 +1,113 @@
+---
+title: "Types of AI Agents"
+description: "Understanding the different categories of AI agents"
+icon: "sitemap"
+---
+
+# Types of AI Agents
+
+AI agents come in different forms, each designed for specific purposes and with varying levels of complexity. Understanding these types will help you choose the right approach for your needs.
+
+## Simple Reflex Agents
+
+These are the most basic type of AI agents that operate using simple if-then rules.
+
+<CardGroup cols={1}>
+  <Card title="Key Characteristics" icon="lightbulb">
+    - React directly to current input only
+    - No memory of past events
+    - No prediction of future states
+    - Use predefined rules to determine actions
+  </Card>
+</CardGroup>
+
+**Real-world example**: A basic thermostat that turns heating on when temperature drops below a set point.
+
+```mermaid
+graph LR
+    A[Sensor Input] --> B{If-Then Rules}
+    B --> C[Action]
+```
+
+## Model-Based Agents
+
+These agents maintain an internal model of their environment to make better decisions.
+
+<CardGroup cols={1}>
+  <Card title="Key Characteristics" icon="brain">
+    - Build and maintain an internal representation of the world
+    - Can work with partial information
+    - Can consider "what if" scenarios
+    - Make decisions based on their understanding of how the world works
+  </Card>
+</CardGroup>
+
+**Real-world example**: A GPS navigation system that models roads and traffic conditions.
+
+## Goal-Based Agents
+
+These agents make decisions based on how their actions will help achieve specific goals.
+
+<CardGroup cols={1}>
+  <Card title="Key Characteristics" icon="bullseye">
+    - Consider future consequences of actions
+    - Evaluate which actions will lead toward goals
+    - Can plan sequences of actions
+    - Choose actions that maximize goal attainment
+  </Card>
+</CardGroup>
+
+**Real-world example**: A chess-playing AI that plans moves to achieve checkmate.
+
+## Utility-Based Agents
+
+These agents choose actions that maximize a specific utility (or happiness) function.
+
+<CardGroup cols={1}>
+  <Card title="Key Characteristics" icon="chart-line">
+    - Assign a utility value to different possible outcomes
+    - Consider probability and risk
+    - Choose actions that maximize expected utility
+    - Can balance competing objectives
+  </Card>
+</CardGroup>
+
+**Real-world example**: An investment robo-advisor that balances risk and return.
+
+## Learning Agents
+
+These agents improve their performance over time through experience.
+
+<CardGroup cols={1}>
+  <Card title="Key Characteristics" icon="graduation-cap">
+    - Learn from past experiences
+    - Adapt to changing environments
+    - Improve decision-making over time
+    - Can discover new strategies
+  </Card>
+</CardGroup>
+
+**Real-world example**: Recommendation systems that learn your preferences over time.
+
+## Understanding Agent Complexity
+
+<Tip>
+As you move from Simple Reflex Agents toward Learning Agents, both capability and complexity increase. For beginners, starting with simpler agent types is often best.
+</Tip>
+
+## Which Agent Type Should You Build?
+
+The best type of agent for your project depends on:
+
+1. **The problem complexity**: Simple problems may only need reflex agents
+2. **Available data**: Learning agents need training data
+3. **Required adaptability**: Will your agent need to adapt to new situations?
+4. **Available resources**: More complex agents require more computational power
+
+In this course, we'll focus primarily on goal-based and simple learning agents as they provide a good balance of capability and complexity for beginners.
+
+<CardGroup cols={1}>
+  <Card title="Next Steps" icon="arrow-right">
+    In the next lesson, we'll explore how agents process information and make decisions.
+  </Card>
+</CardGroup>

docs/course/agents/03-agent-architecture.mdx

@@ -0,0 +1,157 @@
+---
+title: "Agent Architecture"
+description: "Understanding how AI agents are structured"
+icon: "layer-group"
+---
+
+# Agent Architecture
+
+Understanding how AI agents are structured will help you build more effective agents. This lesson covers the fundamental components of an agent's architecture.
+
+## Basic Components of an AI Agent
+
+Every AI agent, regardless of complexity, has these basic components:
+
+```mermaid
+graph TD
+    A[Sensors/Input] --> B[Processing Unit]
+    B --> C[Decision-Making]
+    C --> D[Actions/Output]
+```
+
+### 1. Input (Sensors)
+
+This is how agents receive information from their environment.
+
+<CardGroup cols={1}>
+  <Card title="Examples of Input" icon="eye">
+    - Text input from users
+    - Data from databases
+    - Image or audio input
+    - API responses
+    - Sensor readings (in physical agents)
+  </Card>
+</CardGroup>
+
+### 2. Processing Unit
+
+This component processes information and converts it into a format the agent can understand.
+
+<CardGroup cols={1}>
+  <Card title="Processing Functions" icon="gears">
+    - Data cleaning and transformation
+    - Feature extraction
+    - Context building
+    - Information retrieval
+    - Pattern recognition
+  </Card>
+</CardGroup>
+
+### 3. Decision-Making Core
+
+The "brain" of the agent that determines what actions to take.
+
+<CardGroup cols={1}>
+  <Card title="Decision Components" icon="brain">
+    - Language models (like GPT-4)
+    - Rule systems
+    - Planning algorithms
+    - Knowledge base
+    - Memory systems
+  </Card>
+</CardGroup>
+
+### 4. Output (Actions)
+
+The actions the agent can perform to achieve its goals.
+
+<CardGroup cols={1}>
+  <Card title="Action Examples" icon="hand">
+    - Generating text responses
+    - Creating visual content
+    - Making API calls
+    - Controlling other systems
+    - Updating databases
+  </Card>
+</CardGroup>
+
+## The Agent Loop
+
+Agents operate in a continuous loop:
+
+```mermaid
+graph LR
+    A[Perceive] --> B[Process]
+    B --> C[Decide]
+    C --> D[Act]
+    D --> A
+```
+
+This cycle allows agents to continuously:
+1. Gather information
+2. Update their understanding
+3. Make new decisions
+4. Take appropriate actions
+
+## PraisonAI Agent Architecture
+
+In the PraisonAI framework, agents follow a specific architecture:
+
+<CardGroup cols={1}>
+  <Card title="PraisonAI Agent Components" icon="puzzle-piece">
+    - **Instructions**: Defines the agent's purpose and behavior
+    - **Language Model**: Powers the agent's intelligence (e.g., GPT-4)
+    - **Memory**: Stores context and previous interactions
+    - **Tools**: Specialized capabilities an agent can use
+  </Card>
+</CardGroup>
+
+### Simple Agent Structure
+
+```python
+from praisonaiagents import Agent
+
+# Create a simple agent
+research_agent = Agent(
+    instructions="Research the latest developments in renewable energy",
+    name="ResearchAgent"
+)
+
+# Start the agent
+research_agent.start()
+```
+
+## Understanding Agent Communication
+
+Multi-agent systems allow agents to communicate with each other:
+
+```mermaid
+graph LR
+    A[Agent 1] --> B[Agent 2]
+    B --> C[Agent 3]
+    C --> A
+```
+
+Each agent can:
+- Pass information to other agents
+- Request assistance from specialized agents
+- Collaborate on complex tasks
+
+## Key Takeaways
+
+<CardGroup cols={2}>
+  <Card title="Component Importance" icon="check">
+    Each component plays a vital role in the agent's functionality
+  </Card>
+  <Card title="Agent Customization" icon="gear">
+    You can customize each component based on your specific needs
+  </Card>
+  <Card title="Component Balance" icon="scale-balanced">
+    A well-designed agent balances all components effectively
+  </Card>
+  <Card title="Continuous Improvement" icon="arrow-trend-up">
+    Agents can be improved by enhancing individual components
+  </Card>
+</CardGroup>
+
+In the next lesson, we'll explore how to define effective instructions for your AI agents.

docs/course/agents/04-agent-instructions.mdx

@@ -0,0 +1,187 @@
+---
+title: "Creating Effective Agent Instructions"
+description: "How to write clear instructions for your AI agents"
+icon: "file-lines"
+---
+
+# Creating Effective Agent Instructions
+
+The instructions you give to your AI agent are crucial to its performance. Well-crafted instructions lead to agents that understand their purpose and execute tasks effectively.
+
+## Why Instructions Matter
+
+Instructions serve as the agent's "job description" and guide its behavior:
+
+<CardGroup cols={2}>
+  <Card title="Clarity" icon="glasses">
+    Clear instructions reduce confusion and misinterpretation
+  </Card>
+  <Card title="Focus" icon="bullseye">
+    Specific instructions keep the agent on task
+  </Card>
+  <Card title="Boundaries" icon="border-all">
+    Good instructions define what an agent should and shouldn't do
+  </Card>
+  <Card title="Personality" icon="face-smile">
+    Instructions can shape how an agent communicates
+  </Card>
+</CardGroup>
+
+## Elements of Effective Instructions
+
+### 1. Role Definition
+
+Tell the agent who it is and what its expertise should be.
+
+<CodeGroup>
+```text Good Example
+You are a financial analyst with expertise in market trends and investment strategies.
+```
+
+```text Weak Example
+You are a helper.
+```
+</CodeGroup>
+
+### 2. Purpose and Goals
+
+Clearly state what the agent should accomplish.
+
+<CodeGroup>
+```text Good Example
+Your goal is to analyze company quarterly reports and provide actionable investment insights.
+```
+
+```text Weak Example
+Help with finance stuff.
+```
+</CodeGroup>
+
+### 3. Process Guidelines
+
+Explain how the agent should approach tasks.
+
+<CodeGroup>
+```text Good Example
+First analyze the data trends, then identify key risk factors, and finally make recommendations based on the client's risk tolerance.
+```
+
+```text Weak Example
+Just do a good analysis.
+```
+</CodeGroup>
+
+### 4. Response Format
+
+Specify how you want information presented.
+
+<CodeGroup>
+```text Good Example
+Present your analysis in a structured format with: Summary, Key Findings, Risk Assessment, and Recommendations.
+```
+
+```text Weak Example
+Tell me what you find.
+```
+</CodeGroup>
+
+## Instructions Template
+
+Here's a template you can use to create effective agent instructions:
+
+```
+You are a [ROLE] specializing in [EXPERTISE AREAS].
+
+Your goal is to [MAIN OBJECTIVE].
+
+When approaching tasks:
+1. [FIRST STEP/APPROACH]
+2. [SECOND STEP/APPROACH]
+3. [THIRD STEP/APPROACH]
+
+Present your results in [FORMAT PREFERENCES].
+
+Additional guidelines:
+- [SPECIFIC BEHAVIOR 1]
+- [SPECIFIC BEHAVIOR 2]
+- [SPECIFIC BEHAVIOR 3]
+```
+
+## Examples in PraisonAI
+
+Let's look at how instructions are implemented in PraisonAI:
+
+<CodeGroup>
+```python Simple Example
+from praisonaiagents import Agent
+
+research_agent = Agent(
+    instructions="You are a research assistant specializing in climate science. Your goal is to find the latest research on rising sea levels and summarize key findings in bullet points."
+)
+
+research_agent.start()
+```
+
+```python Detailed Example
+from praisonaiagents import Agent
+
+content_agent = Agent(
+    name="ContentCreator",
+    instructions="""
+    You are a content creation specialist with expertise in digital marketing.
+    
+    Your goal is to create engaging blog content that drives traffic and conversions.
+    
+    When creating content:
+    1. Research the target keyword thoroughly
+    2. Create an attention-grabbing headline
+    3. Develop well-structured content with clear sections
+    4. Include actionable takeaways for readers
+    
+    Present content in markdown format with proper headings, bullet points, and emphasis where appropriate.
+    
+    Additional guidelines:
+    - Maintain a conversational but professional tone
+    - Include 2-3 relevant statistics to support key points
+    - Add a call-to-action at the end of each piece
+    """
+)
+
+content_agent.start("Create a blog post about sustainable living tips")
+```
+</CodeGroup>
+
+## Common Instruction Mistakes
+
+<CardGroup cols={2}>
+  <Card title="Being Too Vague" icon="cloud">
+    Vague instructions lead to unpredictable outputs
+  </Card>
+  <Card title="Information Overload" icon="bomb">
+    Too many details can confuse the agent's priorities
+  </Card>
+  <Card title="Contradictory Guidelines" icon="arrows-split-up-and-left">
+    Conflicting instructions create confusion
+  </Card>
+  <Card title="Missing Context" icon="puzzle-piece-missing">
+    Insufficient background information leads to generic outputs
+  </Card>
+</CardGroup>
+
+## Refining Your Instructions
+
+<Tip>
+Good instructions often require iteration. Start with basic instructions, review the agent's performance, and refine as needed.
+</Tip>
+
+Effective instruction improvement follows this cycle:
+
+```mermaid
+graph TD
+    A[Write Initial Instructions] --> B[Test Agent Performance]
+    B --> C[Identify Issues/Gaps]
+    C --> D[Refine Instructions]
+    D --> B
+```
+
+In the next lesson, we'll explore how agents use tools to extend their capabilities.

docs/course/agents/05-agent-tools.mdx

@@ -0,0 +1,183 @@
+---
+title: "Agent Tools"
+description: "Understanding how tools extend agent capabilities"
+icon: "screwdriver-wrench"
+---
+
+# Agent Tools
+
+Tools allow AI agents to interact with the world and perform specific actions. Think of tools as the "hands" of your agent that let it accomplish tasks beyond just generating text.
+
+## What Are Agent Tools?
+
+<CardGroup cols={1}>
+  <Card title="Definition" icon="toolbox">
+    Tools are functions or capabilities that agents can access to perform specific actions, retrieve information, or interact with external systems.
+  </Card>
+</CardGroup>
+
+Just as humans use tools to extend their physical abilities, AI agents use digital tools to extend their capabilities.
+
+## Why Tools Matter
+
+Tools transform agents from simple chat interfaces into powerful assistants that can:
+
+<CardGroup cols={2}>
+  <Card title="Access Information" icon="database">
+    Retrieve data from various sources
+  </Card>
+  <Card title="Perform Calculations" icon="calculator">
+    Analyze numbers and data accurately
+  </Card>
+  <Card title="Create Content" icon="pen-to-square">
+    Generate images, code, or other media
+  </Card>
+  <Card title="Control Systems" icon="gears">
+    Interact with other software or hardware
+  </Card>
+</CardGroup>
+
+## Common Types of Tools
+
+### 1. Information Retrieval Tools
+
+These tools help agents access information beyond their training data.
+
+**Examples:**
+- Web search tools
+- Database query tools
+- Document retrieval tools
+
+```python
+# Example of a simple web search tool
+from praisonaiagents import Agent
+
+def web_search(query):
+    # Simplified example
+    return f"Results for: {query}"
+
+agent = Agent(
+    instructions="Research assistant",
+    tools=[web_search]
+)
+```
+
+### 2. Computation Tools
+
+These tools perform calculations or data processing.
+
+**Examples:**
+- Calculator tools
+- Data analysis tools
+- Conversion tools
+
+### 3. Content Creation Tools
+
+These tools help generate or modify various types of content.
+
+**Examples:**
+- Image generation tools
+- Code writing tools
+- Document formatting tools
+
+### 4. External API Tools
+
+These tools connect to third-party services.
+
+**Examples:**
+- Weather API tools
+- Translation API tools
+- E-commerce API tools
+
+## How Tools Work in PraisonAI
+
+In the PraisonAI framework, tools follow a simple pattern:
+
+1. Tools are defined as functions
+2. Tools are registered with an agent
+3. The agent decides when to use appropriate tools
+4. Tool results are incorporated into the agent's reasoning
+
+```mermaid
+graph TD
+    A[Agent Receives Task] --> B{Needs a Tool?}
+    B -->|Yes| C[Select Appropriate Tool]
+    C --> D[Execute Tool]
+    D --> E[Process Tool Results]
+    E --> F[Continue Task]
+    B -->|No| F
+```
+
+## Creating Basic Tools
+
+Here's a simple example of creating and using tools in PraisonAI:
+
+```python
+from praisonaiagents import Agent
+
+# Define a simple calculator tool
+def calculator(expression):
+    try:
+        return str(eval(expression))
+    except:
+        return "Error: Could not calculate"
+
+# Create an agent with the tool
+math_agent = Agent(
+    instructions="You are a math tutor helping students solve problems",
+    tools=[calculator]
+)
+
+# Use the agent
+math_agent.start("Calculate 24 * 17 and explain the steps")
+```
+
+## Tool Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Clear Descriptions" icon="comment">
+    Provide detailed descriptions so the agent knows when to use each tool
+  </Card>
+  <Card title="Error Handling" icon="shield">
+    Make tools robust with proper error handling
+  </Card>
+  <Card title="Focused Purpose" icon="bullseye">
+    Each tool should do one thing well
+  </Card>
+  <Card title="Input Validation" icon="check-double">
+    Validate inputs to prevent misuse
+  </Card>
+</CardGroup>
+
+## Building a Toolbox
+
+As you advance, you'll want to create a collection of tools your agent can use:
+
+```python
+from praisonaiagents import Agent, Tool
+
+# Define multiple tools
+def weather(location):
+    return f"Weather in {location}: Sunny, 75°F"
+
+def translator(text, target_language):
+    return f"Translated to {target_language}: {text} (placeholder)"
+
+def reminder(message, time):
+    return f"Reminder set for {time}: {message}"
+
+# Create tool collection
+tools = [
+    Tool(name="weather", function=weather, description="Get weather for a location"),
+    Tool(name="translator", function=translator, description="Translate text"),
+    Tool(name="reminder", function=reminder, description="Set a reminder")
+]
+
+# Create agent with multiple tools
+assistant = Agent(
+    instructions="You are a helpful personal assistant",
+    tools=tools
+)
+```
+
+In the next lesson, we'll explore how agents use memory to maintain context across interactions.

docs/course/agents/06-agent-memory.mdx

@@ -0,0 +1,167 @@
+---
+title: "Agent Memory"
+description: "Understanding how agents maintain context and learn"
+icon: "brain"
+---
+
+# Agent Memory
+
+Memory enables AI agents to remember past interactions, maintain context, and provide more coherent responses over time. Without memory, agents would treat each interaction as if it was their first.
+
+## Why Memory Matters
+
+<CardGroup cols={2}>
+  <Card title="Context Awareness" icon="comments">
+    Remembers previous parts of a conversation
+  </Card>
+  <Card title="Personalization" icon="user-gear">
+    Recalls user preferences and history
+  </Card>
+  <Card title="Continuous Learning" icon="graduation-cap">
+    Builds on past experiences
+  </Card>
+  <Card title="Task Persistence" icon="list-check">
+    Maintains progress on long-running tasks
+  </Card>
+</CardGroup>
+
+## Types of Agent Memory
+
+### 1. Short-Term Memory (Conversation Memory)
+
+This type of memory stores recent interactions within a session.
+
+```mermaid
+graph LR
+    A[User Input 1] --> B[Agent Response 1]
+    B --> C[User Input 2]
+    C --> D[Agent Response 2]
+    D --> E[User Input 3]
+```
+
+The agent can refer back to earlier messages in the same conversation.
+
+### 2. Long-Term Memory
+
+This allows agents to remember information across different sessions.
+
+<CardGroup cols={1}>
+  <Card title="Use Cases" icon="clock">
+    - Remembering user preferences
+    - Recalling previous tasks completed
+    - Storing learned information
+    - Maintaining relationship history
+  </Card>
+</CardGroup>
+
+### 3. Working Memory
+
+This is where agents process current information and combine it with retrieved memories.
+
+```mermaid
+graph TD
+    A[Current Input] --> D[Working Memory]
+    B[Short-Term Memory] --> D
+    C[Long-Term Memory] --> D
+    D --> E[Agent Response]
+```
+
+## How Memory Works in PraisonAI
+
+In the PraisonAI framework, memory is handled automatically for basic cases and can be customized for more advanced needs:
+
+```python
+from praisonaiagents import Agent
+
+# Basic agent with default memory handling
+agent = Agent(
+    instructions="You are a helpful assistant that remembers our conversations"
+)
+
+# The conversation history is maintained automatically
+agent.start("My name is Alex")
+agent.continue("What's my name?")# Note: TODO: This Feature yet to be developed  # Agent will remember "Alex"
+```
+
+## Memory Limitations
+
+<Tip>
+All AI memories have limitations. They aren't perfect and may occasionally forget or misremember information.
+</Tip>
+
+Common limitations include:
+
+<CardGroup cols={2}>
+  <Card title="Memory Capacity" icon="database">
+    Limit to how much information can be stored
+  </Card>
+  <Card title="Context Window" icon="window">
+    Only a portion of memory fits in the active context
+  </Card>
+  <Card title="Memory Decay" icon="hourglass-half">
+    Older memories may become less accessible
+  </Card>
+  <Card title="Memory Retrieval" icon="magnifying-glass">
+    Finding the right memory at the right time
+  </Card>
+</CardGroup>
+
+## Implementing Persistent Memory
+
+For more advanced applications, you can implement custom memory systems:
+
+```python
+# Note: TODO: This Feature yet to be tested
+from praisonaiagents import Agent, Memory
+
+# Create a simple memory store
+memory = Memory()
+
+# Add information to memory
+memory.add("user_name", "Alex")
+memory.add("favorite_color", "blue")
+
+# Create agent with this memory
+agent = Agent(
+    instructions="You are a personal assistant",
+    memory=memory
+)
+
+# The agent can now access these memories
+agent.start("What's my favorite color?")  # Agent should respond "blue"
+```
+
+## Memory Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Prioritize Important Info" icon="star">
+    Not everything needs to be remembered
+  </Card>
+  <Card title="Verify When Uncertain" icon="question">
+    Have agents confirm uncertain memories
+  </Card>
+  <Card title="Structured Storage" icon="folder-tree">
+    Organize memories by categories
+  </Card>
+  <Card title="Regular Updates" icon="arrows-rotate">
+    Update memories when information changes
+  </Card>
+</CardGroup>
+
+## Memory in Multi-Agent Systems
+
+In systems with multiple agents, memory can be:
+
+1. **Private**: Each agent has its own memories
+2. **Shared**: Agents have access to a common memory store
+3. **Hybrid**: Some memories are private, others are shared
+
+```mermaid
+graph TD
+    A[Agent 1] --> B[Private Memory 1]
+    C[Agent 2] --> D[Private Memory 2]
+    A -.-> E[Shared Memory]
+    C -.-> E
+```
+
+In the next lesson, we'll learn about how to set up multiple agents to work together effectively.

docs/course/agents/07-multi-agent-systems.mdx

@@ -0,0 +1,171 @@
+---
+title: "Multi-Agent Systems"
+description: "How multiple agents can work together"
+icon: "users"
+---
+
+# Multi-Agent Systems
+
+Multi-agent systems allow multiple AI agents to work together, each handling different parts of a complex task. This approach mirrors how human teams collaborate, with each member contributing their specialized skills.
+
+## Why Use Multiple Agents?
+
+<CardGroup cols={2}>
+  <Card title="Specialization" icon="star">
+    Each agent can focus on its area of expertise
+  </Card>
+  <Card title="Complex Tasks" icon="puzzle-piece">
+    Break down difficult problems into manageable pieces
+  </Card>
+  <Card title="Scalability" icon="arrows-up-down">
+    Add more agents as tasks become more complex
+  </Card>
+  <Card title="Diverse Perspectives" icon="lightbulb">
+    Different agents can approach problems differently
+  </Card>
+</CardGroup>
+
+## Basic Multi-Agent Architecture
+
+```mermaid
+graph LR
+    A[Research Agent] --> B[Analysis Agent]
+    B --> C[Writing Agent]
+    C --> D[Final Output]
+```
+
+In this example:
+1. The Research Agent gathers information
+2. The Analysis Agent processes and interprets the data
+3. The Writing Agent creates the final content
+
+## Multi-Agent Patterns
+
+### 1. Pipeline Pattern
+
+Agents work in sequence, with each agent handling a specific stage of the process.
+
+```mermaid
+graph LR
+    A[Agent 1] --> B[Agent 2]
+    B --> C[Agent 3]
+```
+
+**Example Use Case**: Content creation where one agent researches, another drafts, and a third edits.
+
+### 2. Expert Panel Pattern
+
+Multiple specialist agents work in parallel on the same problem, then their outputs are combined.
+
+```mermaid
+graph TD
+    Task --> A[Expert Agent 1]
+    Task --> B[Expert Agent 2]
+    Task --> C[Expert Agent 3]
+    A --> D[Coordination Agent]
+    B --> D
+    C --> D
+    D --> Result
+```
+
+**Example Use Case**: Financial analysis where different experts analyze market trends, economic indicators, and company performance.
+
+### 3. Hierarchical Pattern
+
+A manager agent delegates tasks to worker agents and coordinates their efforts.
+
+```mermaid
+graph TD
+    A[Manager Agent] --> B[Worker Agent 1]
+    A --> C[Worker Agent 2]
+    A --> D[Worker Agent 3]
+    B --> A
+    C --> A
+    D --> A
+```
+
+**Example Use Case**: Project management where a coordinator assigns tasks and integrates results.
+
+## Implementing Multi-Agent Systems in PraisonAI
+
+Here's a simple example of creating a multi-agent system:
+
+```python
+from praisonaiagents import Agent, PraisonAIAgents
+
+# Create individual agents
+research_agent = Agent(
+    name="Researcher",
+    instructions="Research the latest trends in renewable energy"
+)
+
+analysis_agent = Agent(
+    name="Analyst",
+    instructions="Analyze the research findings and identify key insights"
+)
+
+writing_agent = Agent(
+    name="Writer", 
+    instructions="Create a clear, engaging report based on the analysis"
+)
+
+# Create a multi-agent system
+agents = PraisonAIAgents(
+    agents=[research_agent, analysis_agent, writing_agent]
+)
+
+# Start the agents
+agents.start()
+```
+
+## Agent Communication
+
+For agents to work together effectively, they need to communicate. This happens through:
+
+<CardGroup cols={2}>
+  <Card title="Output Passing" icon="arrow-right">
+    One agent's output becomes another's input
+  </Card>
+  <Card title="Shared Memory" icon="database">
+    Agents can access common information
+  </Card>
+  <Card title="Message Exchange" icon="comments">
+    Agents can send specific messages to each other
+  </Card>
+  <Card title="Coordination Protocols" icon="traffic-light">
+    Rules that determine how agents interact
+  </Card>
+</CardGroup>
+
+## Challenges in Multi-Agent Systems
+
+<CardGroup cols={2}>
+  <Card title="Coordination" icon="shuffle">
+    Ensuring agents work together smoothly
+  </Card>
+  <Card title="Conflicting Goals" icon="arrows-split-up-and-left">
+    Managing agents with different objectives
+  </Card>
+  <Card title="Information Transfer" icon="exchange">
+    Passing information effectively between agents
+  </Card>
+  <Card title="Resource Management" icon="microchip">
+    Allocating computational resources efficiently
+  </Card>
+</CardGroup>
+
+## Designing Effective Multi-Agent Systems
+
+<Tip>
+Start simple with just 2-3 agents and a clear workflow before scaling to more complex systems.
+</Tip>
+
+Key principles for effective design:
+
+1. **Clear Role Definition**: Each agent should have a specific and well-defined role
+2. **Minimized Dependencies**: Reduce complex interdependencies between agents
+3. **Standardized Communication**: Use consistent formats for information exchange
+4. **Failure Handling**: Plan for cases where an agent fails to complete its task
+5. **Performance Monitoring**: Track how well each agent and the overall system performs
+
+In the next lesson, we'll explore how to create effective agent workflows using the Process component.

docs/course/agents/08-agent-process.mdx

@@ -0,0 +1,152 @@
+---
+title: "Agent Process"
+description: "Understanding agent workflows and processes"
+icon: "diagram-project"
+---
+
+# Agent Process
+
+The Process component in AI agent systems defines how agents work together and the flow of information between them. Think of it as the "playbook" that coordinates how agents complete tasks.
+
+## What is an Agent Process?
+
+<CardGroup cols={1}>
+  <Card title="Definition" icon="route">
+    A process is a structured workflow that defines the sequence of steps, decision points, and information flow between agents to complete a task.
+  </Card>
+</CardGroup>
+
+## Process Flow Basics
+
+A simple process flow might look like this:
+
+```mermaid
+graph LR
+    A[Start] --> B[Gather Information]
+    B --> C[Process Information]
+    C --> D[Make Decision]
+    D --> E[Take Action]
+    E --> F[Report Results]
+```
+
+Each step could be handled by a different agent or by the same agent in different stages.
+
+## Types of Process Flows
+
+### 1. Sequential Process
+
+Agents work in a straight line, one after another.
+
+```mermaid
+graph LR
+    A[Agent 1] --> B[Agent 2]
+    B --> C[Agent 3]
+    C --> D[Complete]
+```
+
+**Best for**: Tasks with clear, linear stages
+
+### 2. Parallel Process
+
+Multiple agents work simultaneously on different parts of a task.
+
+```mermaid
+graph TD
+    A[Start] --> B[Agent 1]
+    A --> C[Agent 2]
+    A --> D[Agent 3]
+    B --> E[Combine Results]
+    C --> E
+    D --> E
+    E --> F[Complete]
+```
+
+**Best for**: Tasks that can be broken into independent pieces
+
+### 3. Conditional Process
+
+The workflow changes based on decisions or conditions.
+
+```mermaid
+graph TD
+    A[Start] --> B{Decision Point}
+    B -->|Condition A| C[Agent 1]
+    B -->|Condition B| D[Agent 2]
+    C --> E[Complete]
+    D --> E
+```
+
+**Best for**: Tasks requiring different approaches based on circumstances
+
+## Implementing Process in PraisonAI
+
+Here's a simple example of creating a process in PraisonAI:
+
+```python
+from praisonaiagents import Agent, Process, PraisonAIAgents
+
+# Create agents
+research_agent = Agent(
+    name="Researcher",
+    instructions="Research the topic and gather key information about AI"
+)
+
+writing_agent = Agent(
+    name="Writer",
+    instructions="Create content based on the research"
+)
+
+editing_agent = Agent(
+    name="Editor",
+    instructions="Review and improve the content"
+)
+
+# Create the multi-agent system with the process
+agents = PraisonAIAgents(
+    agents=[research_agent, writing_agent, editing_agent],
+    process="hierarchical"
+)
+
+# Start the process
+agents.start()
+```
+
+## Process Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Clear Step Definitions" icon="list-check">
+    Define exactly what each step should accomplish
+  </Card>
+  <Card title="Error Handling" icon="bug">
+    Include steps for handling unexpected situations
+  </Card>
+  <Card title="Feedback Loops" icon="repeat">
+    Allow agents to request clarification when needed
+  </Card>
+  <Card title="Modular Design" icon="cubes">
+    Create reusable process components
+  </Card>
+</CardGroup>
+
+<Tip>
+Start with simple processes and gradually add complexity as you become more comfortable with the system.
+</Tip>
+
+## Monitoring Process Execution
+
+It's important to track how your processes are running:
+
+```python
+agents = PraisonAIAgents(
+    agents=[research_agent, writing_agent, editing_agent],
+    process=content_process,
+    verbose=True  # Enables detailed logging
+)
+```
+
+This will provide information about:
+- Which step is currently running
+- The inputs and outputs of each step
+- Any errors or issues encountered
+
+In the next lesson, we'll explore how to use knowledge bases to enhance agent capabilities.

docs/course/agents/09-knowledge-bases.mdx

@@ -0,0 +1,190 @@
+---
+title: "Knowledge Bases"
+description: "Enhancing agents with specialized knowledge"
+icon: "book"
+---
+
+# Knowledge Bases
+
+Knowledge bases provide agents with specialized information beyond their training data. They help agents answer specific questions, follow guidelines, or work within defined domains.
+
+## What is a Knowledge Base?
+
+<CardGroup cols={1}>
+  <Card title="Definition" icon="database">
+    A knowledge base is a structured collection of information that an agent can access to answer questions or make decisions.
+  </Card>
+</CardGroup>
+
+Think of a knowledge base as a specialized reference library for your agent.
+
+## Why Use Knowledge Bases?
+
+<CardGroup cols={2}>
+  <Card title="Domain Expertise" icon="user-graduate">
+    Provide specialized information for specific fields
+  </Card>
+  <Card title="Current Information" icon="clock">
+    Include data beyond the agent's training cutoff
+  </Card>
+  <Card title="Custom Guidelines" icon="list">
+    Define rules and policies for the agent to follow
+  </Card>
+  <Card title="Consistent Responses" icon="equals">
+    Ensure agents provide standardized answers
+  </Card>
+</CardGroup>
+
+## Types of Knowledge Bases
+
+### 1. Document Collections
+
+Text documents, articles, guides, or manuals that agents can reference.
+
+```mermaid
+graph TD
+    A[Query] --> B[Search Documents]
+    B --> C[Find Relevant Content]
+    C --> D[Generate Response]
+```
+
+### 2. Structured Data
+
+Databases, tables, or other structured formats that organize information systematically.
+
+<CardGroup cols={1}>
+  <Card title="Examples" icon="table">
+    - Product catalogs with specifications
+    - Customer information databases
+    - Statistical data collections
+    - Reference tables for compliance information
+  </Card>
+</CardGroup>
+
+### 3. Vector Databases
+
+Special databases that store information as numerical representations (vectors) for semantic search.
+
+```mermaid
+graph TD
+    A[User Question] --> B[Convert to Vector]
+    B --> C[Find Similar Vectors]
+    C --> D[Retrieve Related Information]
+    D --> E[Generate Answer]
+```
+
+## Implementing Knowledge Bases in PraisonAI
+
+Here's an example of how to use a knowledge base with an agent:
+
+```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?")
+```
+
+## Knowledge Retrieval Process
+
+When an agent uses a knowledge base, this typical process occurs:
+
+```mermaid
+graph LR
+    A[User Question] --> B[Query Processing]
+    B --> C[Search Knowledge Base]
+    C --> D[Rank Results]
+    D --> E[Synthesize Answer]
+```
+
+1. **Query Processing**: The user's question is analyzed
+2. **Search**: The system searches the knowledge base for relevant information
+3. **Ranking**: Results are ranked by relevance
+4. **Synthesis**: The agent creates an answer using the retrieved information
+
+## Best Practices for Knowledge Bases
+
+<CardGroup cols={2}>
+  <Card title="Keep Information Current" icon="arrows-rotate">
+    Regularly update your knowledge base
+  </Card>
+  <Card title="Organize Logically" icon="folder-tree">
+    Structure information in intuitive categories
+  </Card>
+  <Card title="Prioritize Quality" icon="star">
+    Focus on accurate, high-quality information
+  </Card>
+  <Card title="Include Examples" icon="list">
+    Add examples to illustrate complex concepts
+  </Card>
+</CardGroup>
+
+## When to Use Knowledge Bases
+
+Knowledge bases are particularly valuable when:
+
+1. Your agent needs to reference specific information that may change over time
+2. You need to ensure consistent answers to common questions
+3. Your agent needs to follow specific guidelines or protocols
+4. You want to provide expertise in specialized domains
+
+<Tip>
+Start with a small knowledge base focusing on the most important information, then expand as needed.
+</Tip>
+
+## Creating a Simple Knowledge Base
+
+For beginners, you can start with a simple text-based knowledge base:
+
+```
+# Company FAQ Knowledge Base
+
+## Return Policy
+Our return policy allows customers to return products within 30 days of purchase for a full refund.
+
+## Shipping Information
+Standard shipping takes 3-5 business days. Express shipping takes 1-2 business days.
+
+## Product Warranty
+All products come with a 1-year limited warranty covering manufacturing defects.
+```
+
+Save this as a text file and add it to your knowledge base:
+
+```python
+kb = KnowledgeBase()
+kb.add_document("company_faq.txt")
+```
+
+In the next lesson, we'll explore how agents handle tasks and the task management process.

docs/course/agents/10-agent-tasks.mdx

@@ -0,0 +1,274 @@
+---
+title: "Agent Tasks"
+description: "Understanding how agents handle and manage tasks"
+icon: "clipboard-list"
+---
+
+# Agent Tasks
+
+Tasks are the specific units of work that AI agents perform. Understanding how to define and manage tasks is essential for creating effective agent systems.
+
+## What is an Agent Task?
+
+<CardGroup cols={1}>
+  <Card title="Definition" icon="list-check">
+    A task is a specific, well-defined piece of work assigned to an agent with clear inputs, expected outputs, and success criteria.
+  </Card>
+</CardGroup>
+
+Just as human jobs are broken into specific responsibilities, agent systems work best when complex goals are divided into manageable tasks.
+
+## Anatomy of a Task
+
+A well-defined task includes:
+
+<CardGroup cols={2}>
+  <Card title="Objective" icon="bullseye">
+    What the task should accomplish
+  </Card>
+  <Card title="Inputs" icon="arrow-right-to-bracket">
+    Information provided to complete the task
+  </Card>
+  <Card title="Process" icon="gears">
+    Steps to follow or approach to take
+  </Card>
+  <Card title="Outputs" icon="arrow-right-from-bracket">
+    Expected results or deliverables
+  </Card>
+</CardGroup>
+
+## Task Types
+
+### 1. Information Tasks
+
+These tasks involve finding, analyzing, or summarizing information.
+
+**Examples:**
+- Research a topic
+- Summarize a document
+- Extract data from text
+- Answer questions
+
+### 2. Creation Tasks
+
+These tasks involve generating new content.
+
+**Examples:**
+- Write an article
+- Create a marketing plan
+- Generate images (with appropriate tools)
+- Design a workflow
+
+### 3. Analysis Tasks
+
+These tasks involve evaluating information and drawing conclusions.
+
+**Examples:**
+- Analyze data trends
+- Review content for quality
+- Evaluate options
+- Identify patterns
+
+### 4. Interaction Tasks
+
+These tasks involve communicating or working with users or other systems.
+
+**Examples:**
+- Answer customer questions
+- Guide users through processes
+- Collect information from users
+- Notify about events
+
+## Creating Tasks in PraisonAI
+
+### Task Flow
+
+The typical lifecycle of a task follows this pattern:
+
+```mermaid
+graph LR
+    A[Define Task] --> B[Assign to Agent]
+    B --> C[Execute Task]
+    C --> D[Return Results]
+    D --> E[Evaluate Success]
+```
+
+### Task Configuration
+
+<CodeGroup>
+  ```python Basic
+  task = Task(
+      description="Research AI trends",
+      expected_output="Summary report",
+      agent=research_agent
+  )
+  ```
+  ```python Advanced
+  task = Task(
+      description="Analyze market data",
+      expected_output="Detailed analysis",
+      agent=analyst_agent,
+      tools=[AnalysisTool()],
+      output_file="analysis.md",
+      async_execution=True
+  )
+  ```
+</CodeGroup>
+
+# Understanding Tasks
+<br />
+```mermaid
+graph LR
+    %% Task Flow Steps
+    Start([▶ Start]) --> TaskDef
+    TaskDef --> AgentAssign
+    AgentAssign --> Exec
+    Exec --> Output([✓ Output])
+    
+    %% Define subgraphs for each step
+    subgraph TaskDef[" "]
+        TD_Icon[📋 Task Definition]
+        TD_Desc[Description & Requirements]
+        
+        TD_Icon --- TD_Desc
+        
+        style TD_Icon fill:#2D3047,stroke:#7C90A0,color:#fff
+        style TD_Desc fill:#5C80BC,stroke:#7C90A0,color:#fff
+    end
+    
+    subgraph AgentAssign[" "]
+        AA_Icon[🤖 Agent Assignment]
+        AA_Desc[Matching & Delegation]
+        
+        AA_Icon --- AA_Desc
+        
+        style AA_Icon fill:#2D3047,stroke:#7C90A0,color:#fff
+        style AA_Desc fill:#5C80BC,stroke:#7C90A0,color:#fff
+    end
+    
+    subgraph Exec[" "]
+        E_Icon[⚙️ Execution]
+        E_Desc[Processing & Tools]
+        
+        E_Icon --- E_Desc
+        
+        style E_Icon fill:#2D3047,stroke:#7C90A0,color:#fff
+        style E_Desc fill:#5C80BC,stroke:#7C90A0,color:#fff
+    end
+    
+    %% Styling for main elements
+    style Start fill:#2D3047,stroke:#7C90A0,color:#fff
+    style Output fill:#2D3047,stroke:#7C90A0,color:#fff
+    
+    %% Style for containers
+    style TaskDef fill:#1B1F3B,stroke:#7C90A0,color:#fff
+    style AgentAssign fill:#1B1F3B,stroke:#7C90A0,color:#fff
+    style Exec fill:#1B1F3B,stroke:#7C90A0,color:#fff
+    
+    %% Global styles
+    classDef default fill:#2D3047,stroke:#7C90A0,color:#fff
+    linkStyle default stroke:#7C90A0,stroke-width:2px
+```
+<br /><br />
+```mermaid
+graph LR
+    %% Task States
+    Pending([📥 Pending]) --> InProgress([⚡ In Progress])
+    InProgress --> Completed([✅ Completed])
+    InProgress --> Failed([❌ Failed])
+    
+    %% Styling
+    style Pending fill:#2D3047,stroke:#7C90A0,color:#fff
+    style InProgress fill:#5C80BC,stroke:#7C90A0,color:#fff
+    style Completed fill:#2D3047,stroke:#7C90A0,color:#fff
+    style Failed fill:#2D3047,stroke:#7C90A0,color:#fff
+    
+    %% Global styles
+    classDef default fill:#2D3047,stroke:#7C90A0,color:#fff
+    linkStyle default stroke:#7C90A0,stroke-width:2px
+```
+
+## Task Types
+
+<Steps>
+  <Step title="Basic Task">
+    Simple, single-operation tasks with clear inputs and outputs
+  </Step>
+  <Step title="Decision Task">
+    Tasks involving choices and conditional paths
+    ```python
+    decision_task = Task(
+        type="decision",
+        conditions={
+            "success": ["next_task"],
+            "failure": ["error_task"]
+        }
+    )
+    ```
+  </Step>
+  <Step title="Loop Task">
+    Repetitive operations over collections
+    ```python
+    loop_task = Task(
+        type="loop",
+        items=data_list,
+        operation="process_item"
+    )
+    ```
+  </Step>
+</Steps>
+
+## Task Relationships
+
+<Warning>
+  Properly managing task dependencies is crucial for complex workflows. Always ensure proper context sharing and error handling.
+</Warning>
+
+### Context Sharing
+```python
+task_a = Task(name="research")
+task_b = Task(
+    name="analyze",
+    context=[task_a]  # Uses task_a's output
+)
+```
+
+## Task Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Be Specific" icon="magnifying-glass">
+    Clearly define what the task should accomplish
+  </Card>
+  <Card title="One Goal Per Task" icon="check-double">
+    Each task should focus on a single objective
+  </Card>
+  <Card title="Provide Context" icon="circle-info">
+    Include necessary background information
+  </Card>
+  <Card title="Define Success" icon="trophy">
+    Specify what a successful outcome looks like
+  </Card>
+</CardGroup>
+
+<Tip>
+Break complex goals into multiple smaller tasks rather than creating one large, complex task.
+</Tip>
+
+## Common Task Mistakes
+
+<CardGroup cols={2}>
+  <Card title="Vague Instructions" icon="question">
+    Unclear about what the agent should do
+  </Card>
+  <Card title="Too Many Objectives" icon="list-ol">
+    Asking for too many things in one task
+  </Card>
+  <Card title="Missing Context" icon="puzzle-piece-missing">
+    Not providing necessary background information
+  </Card>
+  <Card title="Unrealistic Expectations" icon="mountain-sun">
+    Asking for tasks beyond agent capabilities
+  </Card>
+</CardGroup>
+
+In the next lesson, we'll learn about creating your first complete agent application.

docs/course/agents/11-creating-your-first-agent.mdx

@@ -0,0 +1,172 @@
+---
+title: "Creating Your First Agent"
+description: "A step-by-step guide to building your first AI agent"
+icon: "robot"
+---
+
+# Creating Your First Agent
+
+In this lesson, we'll walk through the process of building a simple AI agent. We'll focus on practical implementation without complex programming.
+
+## What We'll Build
+
+We'll create a basic research assistant agent that can:
+- Understand simple instructions
+- Respond to questions
+- Provide helpful information
+
+## Prerequisites
+
+Before you begin, make sure you have:
+
+1. A basic understanding of the concepts from previous lessons
+2. Python installed on your computer (if following the code examples)
+3. An OpenAI API key (or access to another supported language model)
+
+## Step 1: Installation
+
+First, install the PraisonAI package:
+
+```bash
+pip install praisonaiagents
+```
+
+## Step 2: Setup Your Environment
+
+Create a file called `first_agent.py` and set up your API key:
+
+```python
+import os
+from praisonaiagents import Agent
+
+# Set your API key
+# Option 1: Set it in your environment (recommended)
+# export OPENAI_API_KEY=your_key_here
+
+# Option 2: Set it in your code (not recommended for production)
+# os.environ["OPENAI_API_KEY"] = "your_key_here"
+```
+
+## Step 3: Define Your Agent
+
+Now, let's create a simple agent:
+
+```python
+# Create a research assistant agent
+research_assistant = Agent(
+    name="ResearchAssistant",
+    instructions="""
+    You are a helpful research assistant that provides clear, 
+    accurate information on various topics. When answering:
+    
+    1. Be concise and to the point
+    2. Explain complex concepts in simple terms
+    3. When appropriate, organize information with bullet points
+    4. If you don't know something, admit it instead of guessing
+    """
+)
+```
+
+## Step 4: Start Your Agent
+
+Now let's use our agent to answer a question:
+
+```python
+# Start the agent with a specific query
+response = research_assistant.start("Explain how solar panels work in simple terms")
+
+# Print the response
+print(response)
+```
+
+## Step 5: Run Your Agent
+
+Save the file and run it from your terminal:
+
+```bash
+python first_agent.py
+```
+
+You should see the agent's response explaining how solar panels work in simple terms.
+
+## Experimenting with Your Agent
+
+Try changing the question to see how your agent responds to different topics:
+
+```python
+# Try different questions
+response = research_assistant.start("What are the benefits of exercise?")
+# or
+response = research_assistant.start("How does artificial intelligence work?")
+```
+
+## Modifying Agent Behavior
+
+You can change how your agent behaves by adjusting its instructions:
+
+```python
+# Create an agent with different instructions
+creative_writer = Agent(
+    name="CreativeWriter",
+    instructions="""
+    You are a creative writer that specializes in short, engaging stories.
+    Your writing should:
+    
+    1. Include vivid descriptions
+    2. Have interesting characters
+    3. Include some dialogue
+    4. Have a clear beginning, middle, and end
+    """
+)
+
+# Ask for a story
+story = creative_writer.start("Write a short story about a lost dog finding its way home")
+print(story)
+```
+
+## Examining How It Works
+
+What's happening behind the scenes:
+
+1. The agent receives your instructions and query
+2. The language model (like GPT-4) processes the information
+3. The model generates a response based on the instructions and query
+4. The response is returned to you
+
+```mermaid
+graph TD
+    A[Your Instructions] --> B[Agent]
+    C[Your Query] --> B
+    B --> D[Language Model]
+    D --> E[Generated Response]
+    E --> F[Output to You]
+```
+
+## Common Challenges
+
+If you encounter issues, check these common problems:
+
+<CardGroup cols={2}>
+  <Card title="API Key Issues" icon="key">
+    Make sure your API key is set correctly
+  </Card>
+  <Card title="Connection Problems" icon="wifi">
+    Check your internet connection
+  </Card>
+  <Card title="Unclear Instructions" icon="circle-question">
+    Try making your instructions more specific
+  </Card>
+  <Card title="Rate Limits" icon="hand">
+    You might be making too many API calls
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+Now that you've created your first agent, you can:
+- Experiment with different instructions
+- Try more complex queries
+- Add specialized capabilities (we'll cover this in upcoming lessons)
+- Create agents for specific use cases
+
+Congratulations on creating your first AI agent! In the next lesson, we'll explore how to add tools to enhance your agent's capabilities.

docs/course/agents/12-adding-tools-to-agents.mdx

@@ -0,0 +1,275 @@
+---
+title: "Adding Tools to Agents"
+description: "Enhancing your agents with specialized capabilities"
+icon: "screwdriver-wrench"
+---
+
+# Adding Tools to Agents
+
+In this lesson, we'll learn how to enhance your agents by adding tools. Tools allow agents to perform specific actions beyond just generating text, making them much more useful for real-world tasks.
+
+## What You'll Learn
+
+By the end of this lesson, you'll understand:
+- What agent tools are and why they're useful
+- How to create simple tools for your agents
+- How to integrate tools with your agents
+- Best practices for tool design
+
+## Understanding Agent Tools
+
+Tools give your agents the ability to:
+- Perform calculations
+- Access specific information
+- Interact with external systems
+- Generate different types of content
+
+<Tabs>
+
+<Tab title="Code">
+<Steps>
+
+  <Step title="Install PraisonAI">
+Install the core package:
+```bash Terminal
+pip install praisonaiagents duckduckgo-search
+```
+  </Step>
+
+  <Step title="Configure Environment">
+  ```bash Terminal
+  export OPENAI_API_KEY=your_openai_key
+  ```
+  Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
+  Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
+  </Step>
+
+  <Step title="Create Agent with Tool">
+    Create `app.py`
+<CodeGroup>
+```python Single Agent
+from praisonaiagents import Agent
+from duckduckgo_search import DDGS
+
+# 1. Define the tool
+def internet_search_tool(query: str):
+    results = []
+    ddgs = DDGS()
+    for result in ddgs.text(keywords=query, max_results=5):
+        results.append({
+            "title": result.get("title", ""),
+            "url": result.get("href", ""),
+            "snippet": result.get("body", "")
+        })
+    return results
+
+# 2. Assign the tool to an agent
+search_agent = Agent(
+    instructions="Perform internet searches to collect relevant information.",
+    tools=[internet_search_tool] # <--- Tool Assignment
+)
+
+# 3. Start Agent
+search_agent.start("Search about AI job trends in 2025")
+```
+
+```python Multiple Agents
+from praisonaiagents import Agent, PraisonAIAgents
+from duckduckgo_search import DDGS
+
+# 1. Define the tool
+def internet_search_tool(query: str):
+    results = []
+    ddgs = DDGS()
+    for result in ddgs.text(keywords=query, max_results=5):
+        results.append({
+            "title": result.get("title", ""),
+            "url": result.get("href", ""),
+            "snippet": result.get("body", "")
+        })
+    return results
+
+# 2. Assign the tool to an agent
+search_agent = Agent(
+    instructions="Search about AI job trends in 2025",
+    tools=[internet_search_tool] # <--- Tool Assignment
+)
+
+blog_agent = Agent(
+    instructions="Write a blog article based on the previous agent's search results."
+)
+
+# 3. Start Agents
+agents = PraisonAIAgents(agents=[search_agent, blog_agent])
+agents.start()
+```
+</CodeGroup>
+  </Step>
+
+  <Step title="Start Agents">
+    Execute your script:
+```bash Terminal
+python app.py
+```
+  </Step>
+</Steps>
+
+</Tab>
+<Tab title="No Code">
+<Steps>
+<Step title="Install PraisonAI">
+Install the core package and duckduckgo_search package:
+```bash Terminal
+pip install praisonai duckduckgo_search
+```
+</Step>
+<Step title="Create Custom Tool">
+<Info>
+To add additional tools/features you need some coding which can be generated using ChatGPT or any LLM
+</Info>
+Create a new file `tools.py` with the following content:
+```python
+from duckduckgo_search import DDGS
+from typing import List, Dict
+
+# 1. Tool
+def internet_search_tool(query: str) -> List[Dict]:
+    """
+    Perform Internet Search
+    """
+    results = []
+    ddgs = DDGS()
+    for result in ddgs.text(keywords=query, max_results=5):
+        results.append({
+            "title": result.get("title", ""),
+            "url": result.get("href", ""),
+            "snippet": result.get("body", "")
+        })
+    return results  
+```
+</Step>
+<Step title="Create Agent">
+
+Create a new file `agents.yaml` with the following content:
+```yaml
+framework: praisonai
+topic: create movie script about cat in mars
+roles:
+  scriptwriter:
+    backstory: Expert in dialogue and script structure, translating concepts into
+      scripts.
+    goal: Write a movie script about a cat in Mars
+    role: Scriptwriter
+    tools:
+      - internet_search_tool # <-- Tool assigned to Agent here
+    tasks:
+      scriptwriting_task:
+        description: Turn the story concept into a production-ready movie script,
+          including dialogue and scene details.
+        expected_output: Final movie script with dialogue and scene details.
+```
+</Step>
+
+<Step title="Start Agents">
+
+Execute your script:
+```bash Terminal
+praisonai agents.yaml
+```
+</Step>
+</Steps>
+</Tab>
+</Tabs>
+
+
+## Creating Custom Tool
+<Steps>
+<Step>
+Create any function that you want to use as a tool, that performs a specific task.
+```python
+from duckduckgo_search import DDGS
+
+def internet_search_tool(query: str):
+    results = []
+    ddgs = DDGS()
+    for result in ddgs.text(keywords=query, max_results=5):
+        results.append({
+            "title": result.get("title", ""),
+            "url": result.get("href", ""),
+            "snippet": result.get("body", "")
+        })
+    return results
+```
+</Step>
+<Step>
+Assign the tool to an agent
+```python
+    data_agent = Agent(
+        instructions="Search about AI job trends in 2025",
+        tools=[internet_search_tool], # <-- Tool Assignment
+    )
+```
+</Step>
+</Steps>
+
+<Card title="That's it!">
+<Check>You have created a custom tool and assigned it to an agent.</Check>
+</Card>
+
+## When Does the Agent Use Tools?
+
+The agent decides when to use tools based on:
+1. The nature of the user's request
+2. The tools available to it
+3. The instructions you've provided
+
+If your agent isn't using tools when expected, you might need to:
+- Make your instructions more explicit about when to use tools
+- Provide more descriptive tool definitions
+- Ensure the tools are appropriate for the task
+
+## Tool Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Specific Purpose" icon="bullseye">
+    Each tool should have a clear, specific purpose
+  </Card>
+  <Card title="Error Handling" icon="shield-check">
+    Tools should handle errors gracefully
+  </Card>
+  <Card title="Descriptive Names" icon="tag">
+    Use clear names that indicate functionality
+  </Card>
+  <Card title="Clear Documentation" icon="file-lines">
+    Include detailed descriptions and examples
+  </Card>
+</CardGroup>
+
+## Real-World Tool Examples
+
+In production systems, you might create tools for:
+
+<CardGroup cols={2}>
+  <Card title="Database Access" icon="database">
+    Retrieve or store information in databases
+  </Card>
+  <Card title="API Integration" icon="link">
+    Connect to external services
+  </Card>
+  <Card title="File Operations" icon="folder">
+    Read from or write to files
+  </Card>
+  <Card title="Image Generation" icon="image">
+    Create images based on descriptions
+  </Card>
+</CardGroup>
+
+## Advanced Tool Concepts
+
+As you become more comfortable with tools, you can explore:
+- Tools that call other tools
+- Tools with complex parameters
+- Tools that maintain state
+- Dynamically generated tools
+
+In the next lesson, we'll explore how to create a multi-agent system for more complex tasks.

docs/course/agents/13-building-multi-agent-system.mdx

@@ -0,0 +1,218 @@
+---
+title: "Building a Multi-Agent System"
+description: "Creating a system with multiple cooperative agents"
+icon: "users"
+---
+
+# Building a Multi-Agent System
+
+In this lesson, we'll create a simple multi-agent system where several agents work together to accomplish a task. This approach allows you to divide complex problems into smaller, more manageable pieces.
+
+## What We'll Build
+
+We'll create a content creation system with three specialized agents:
+1. A research agent to gather information
+2. A writing agent to create content
+3. An editing agent to improve and refine the content
+
+## Step 1: Setting Up
+
+First, let's import the necessary modules and set up our environment:
+
+```python
+from praisonaiagents import Agent, PraisonAIAgents
+
+# Make sure your API key is set in your environment:
+# export OPENAI_API_KEY=your_openai_key
+```
+
+## Step 2: Creating Specialized Agents
+
+Now, let's create our three specialized agents:
+
+```python
+# Research Agent
+research_agent = Agent(
+    name="Researcher",
+    instructions="""
+    You are a research specialist who excels at finding relevant information.
+    Your job is to:
+    1. Thoroughly research the given topic
+    2. Identify key facts, statistics, and insights
+    3. Organize the information in a clear, structured format
+    4. Provide accurate information with no fabrications
+    5. Focus on the most relevant and current information
+    """
+)
+
+# Writing Agent
+writing_agent = Agent(
+    name="Writer",
+    instructions="""
+    You are a content writer who creates engaging, reader-friendly content.
+    Your job is to:
+    1. Use the research provided to create well-structured content
+    2. Write in a clear, engaging style
+    3. Include an attention-grabbing introduction
+    4. Organize the content with appropriate headings
+    5. Conclude with a summary and call-to-action when appropriate
+    """
+)
+
+# Editing Agent
+editing_agent = Agent(
+    name="Editor",
+    instructions="""
+    You are an editor who refines and improves content.
+    Your job is to:
+    1. Correct any grammatical or spelling errors
+    2. Improve clarity and flow
+    3. Ensure consistency in tone and style
+    4. Check for logical structure and organization
+    5. Enhance readability for the target audience
+    """
+)
+```
+
+## Step 3: Creating the Multi-Agent System
+
+Now, let's combine these agents into a multi-agent system:
+
+```python
+# Create a multi-agent system
+content_team = PraisonAIAgents(
+    agents=[research_agent, writing_agent, editing_agent]
+)
+```
+
+## Step 4: Setting Up the Workflow
+
+Next, we need to define how our agents will work together:
+
+```python
+# Define a topic
+topic = "The Benefits of Regular Exercise"
+
+# Start the multi-agent process
+results = content_team.start(
+    f"""
+    Task: Create a comprehensive blog post about {topic}
+    
+    Process:
+    1. Researcher: Research {topic} and provide key information including:
+       - Main benefits of exercise (physical and mental)
+       - Recommended exercise guidelines
+       - Scientific studies supporting the benefits
+       - Common misconceptions
+    
+    2. Writer: Use the research to create a 500-word blog post about {topic} with:
+       - An engaging introduction
+       - Clear sections with headings
+       - Practical advice for readers
+       - A compelling conclusion
+    
+    3. Editor: Review and improve the blog post by:
+       - Correcting any errors
+       - Enhancing clarity and flow
+       - Ensuring a consistent tone
+       - Making the content more engaging
+    """
+)
+
+# Print the final result
+print(results)
+```
+
+## Understanding the Workflow
+
+Let's examine how the multi-agent system works:
+
+```mermaid
+graph TD
+    A[Start] --> B[Research Agent]
+    B --> C[Writing Agent]
+    C --> D[Editing Agent]
+    D --> E[Final Output]
+```
+
+1. The research agent gathers and organizes relevant information
+2. The writing agent uses that research to create the initial content
+3. The editing agent refines and improves the content
+4. The final polished content is returned
+
+## Customizing Agent Interactions
+
+You can customize how agents interact by modifying the process instructions. For example, you could add feedback loops:
+
+```python
+process_with_feedback = """
+Task: Create a comprehensive blog post about {topic}
+
+Process:
+1. Researcher: Research {topic} and provide key information
+
+2. Writer: Use the research to create a blog post
+
+3. Editor: Review the blog post and provide feedback
+
+4. Writer: Revise the blog post based on the editor's feedback
+
+5. Editor: Make final improvements to the revised blog post
+"""
+```
+
+## Alternative Agent Configurations
+
+You can organize multi-agent systems in different ways:
+
+### Parallel Processing
+
+```python
+parallel_process = """
+Task: Create a marketing campaign for a new product
+
+Process:
+1. Market Researcher: Research the target market and competitors
+   Content Researcher: Research the product features and benefits
+   [These tasks happen in parallel]
+
+2. Strategy Agent: Use both research results to create a marketing strategy
+
+3. Content Creator: Create the marketing materials based on the strategy
+"""
+```
+
+### Expert Panel
+
+```python
+expert_panel = """
+Task: Evaluate a business idea
+
+Process:
+1. Financial Expert: Analyze financial viability
+   Market Expert: Analyze market potential
+   Technical Expert: Analyze technical feasibility
+   [These assessments happen in parallel]
+
+2. Coordinator: Compile all expert opinions into a final recommendation
+"""
+```
+
+## Best Practices for Multi-Agent Systems
+
+<CardGroup cols={2}>
+  <Card title="Clear Role Definition" icon="user-tag">
+    Define exactly what each agent is responsible for
+  </Card>
+  <Card title="Explicit Handoffs" icon="arrow-right-arrow-left">
+    Specify how information passes between agents
+  </Card>
+  <Card title="Avoid Redundancy" icon="copy">
+    Don't have multiple agents do the same work
+  </Card>
+  <Card title="Include Error Handling" icon="triangle-exclamation">
+    Plan for cases where an agent might fail
+  </Card>
+</CardGroup>
+
+In the next lesson, we'll learn how to create a conversational agent that can maintain context across multiple interactions.

docs/course/agents/14-conversational-agents.mdx

@@ -0,0 +1,193 @@
+---
+title: "Building Conversational Agents"
+description: "Creating agents that maintain context in conversations"
+icon: "comments"
+---
+
+# Building Conversational Agents
+
+In this lesson, we'll learn how to create conversational agents that can maintain context across multiple interactions. This is essential for creating assistants that feel natural to interact with.
+
+## What Makes a Good Conversational Agent?
+
+A good conversational agent should:
+- Remember previous parts of the conversation
+- Understand context and references
+- Provide coherent, relevant responses
+- Maintain a consistent personality
+
+## Creating a Simple Conversational Agent
+
+Let's build a basic conversational agent:
+
+```python
+# Note: TODO: This Feature yet to be developed
+from praisonaiagents import Agent
+
+# Create a conversational agent
+chat_agent = Agent(
+    name="Conversational Assistant",
+    instructions="""
+    You are a friendly, helpful conversational assistant.
+    
+    When chatting with users:
+    1. Maintain a warm, friendly tone
+    2. Remember information shared earlier in the conversation
+    3. Ask clarifying questions when needed
+    4. Keep responses concise but informative
+    5. Be helpful while respecting boundaries
+    """
+)
+
+# Start a conversation
+response = chat_agent.start("Hi there! My name is Jamie.")
+print(response)
+
+# Continue the conversation
+response = chat_agent.continue("What can you help me with today?")
+print(response)
+
+# The agent should remember the user's name
+response = chat_agent.continue("Can you remember my name?")
+print(response)
+```
+
+## How Context Works
+
+PraisonAI automatically manages conversation context for you:
+
+```mermaid
+graph TD
+    A[User Message 1] --> B[Agent]
+    B --> C[Response 1]
+    D[User Message 2] --> E[Agent + Context]
+    E --> F[Response 2]
+    G[User Message 3] --> H[Agent + More Context]
+    H --> I[Response 3]
+```
+
+The agent maintains a memory of the conversation, allowing it to refer back to previous messages.
+
+## Conversation Settings
+
+You can customize how your conversational agent behaves:
+
+```python
+# Create an agent with specific conversation settings
+custom_chat_agent = Agent(
+    name="Custom Chat Assistant",
+    instructions="You are a helpful assistant",
+    memory_size=10,  # Remember the last 10 messages
+    temperature=0.7  # Slightly more creative in responses
+)
+```
+
+## Handling Different Types of Conversations
+
+Different use cases require different conversation styles:
+
+<CardGroup cols={2}>
+  <Card title="Customer Support" icon="headset">
+    - Professional and helpful tone
+    - Focus on problem resolution
+    - Remember customer details
+  </Card>
+  <Card title="Educational Tutor" icon="graduation-cap">
+    - Patient and explanatory
+    - Builds on previous lessons
+    - Adjusts to learning pace
+  </Card>
+  <Card title="Personal Assistant" icon="calendar">
+    - Remembers preferences
+    - Provides reminders
+    - Handles scheduling
+  </Card>
+  <Card title="Companion Chat" icon="user-group">
+    - More casual tone
+    - Focuses on engagement
+    - Shows personality
+  </Card>
+</CardGroup>
+
+## Example: Customer Support Agent
+
+Let's create a specialized customer support agent:
+
+```python
+support_agent = Agent(
+    name="Support Agent",
+    instructions="""
+    You are a customer support specialist for a tech company.
+    
+    When helping customers:
+    1. Greet them professionally
+    2. Show empathy for their issues
+    3. Ask for necessary information to troubleshoot
+    4. Provide clear step-by-step solutions
+    5. Confirm if the issue is resolved
+    6. End with an offer for additional help
+    
+    Remember product details and customer information throughout the conversation.
+    """
+)
+
+# Example conversation
+print(support_agent.start("Hi, I'm having trouble logging into my account."))
+print(support_agent.continue("My username is user123."))
+print(support_agent.continue("I've tried resetting my password but I'm not receiving the email."))
+```
+
+## Building Multi-Turn Conversations
+
+To create engaging multi-turn conversations, consider:
+
+1. **Appropriate follow-up questions**: Keep the conversation flowing
+2. **Acknowledgment**: Reference what the user has said
+3. **Progressive disclosure**: Don't overwhelm with information at once
+4. **Conversation repair**: Gracefully handle misunderstandings
+
+## Example: Multi-Turn Educational Conversation
+
+```python
+tutor_agent = Agent(
+    name="Math Tutor",
+    instructions="""
+    You are a patient, encouraging math tutor.
+    
+    When teaching:
+    1. Gauge the student's current understanding
+    2. Explain concepts using clear, simple language
+    3. Provide examples to illustrate points
+    4. Ask questions to check understanding
+    5. Give positive reinforcement for progress
+    
+    Adapt your explanations based on the student's responses.
+    """
+)
+
+# Example tutoring session
+print(tutor_agent.start("Can you help me understand algebra?"))
+print(tutor_agent.continue("I'm struggling with equations like 2x + 5 = 13"))
+print(tutor_agent.continue("So I subtract 5 from both sides first?"))
+print(tutor_agent.continue("Then I divide by 2 to get x = 4?"))
+print(tutor_agent.continue("Could you give me another example to practice?"))
+```
+
+## Conversation Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Clear Transitions" icon="arrow-right">
+    Signal when changing topics
+  </Card>
+  <Card title="Manageable Chunks" icon="layer-group">
+    Break complex information into smaller pieces
+  </Card>
+  <Card title="Engagement Checks" icon="hand">
+    Periodically confirm understanding
+  </Card>
+  <Card title="Personality Consistency" icon="masks-theater">
+    Maintain a consistent tone and style
+  </Card>
+</CardGroup>
+
+In the next lesson, we'll explore how to build agents that can search and retrieve information from external sources.

docs/course/agents/15-research-agents.mdx

@@ -0,0 +1,216 @@
+---
+title: "Building Research Agents"
+description: "Creating agents that can gather and analyze information"
+icon: "magnifying-glass"
+---
+
+# Building Research Agents
+
+In this lesson, we'll build agents specialized in gathering, analyzing, and summarizing information. Research agents are valuable for quickly obtaining insights on various topics.
+
+## What is a Research Agent?
+
+A research agent is designed to:
+- Find relevant information on specific topics
+- Analyze and synthesize data
+- Present findings in a clear, structured format
+- Answer questions based on gathered information
+
+## Creating a Basic Research Agent
+
+Let's start by building a simple research agent:
+
+```python
+from praisonaiagents import Agent
+
+# Create a basic research agent
+research_agent = Agent(
+    name="ResearchAgent",
+    instructions="""
+    You are a research specialist who finds and summarizes information.
+    
+    When researching topics:
+    1. Focus on finding accurate, current information
+    2. Organize findings in a logical structure
+    3. Identify key points and insights
+    4. Cite sources when available
+    5. Present information in a clear, concise format
+    """
+)
+
+# Use the research agent
+research_results = research_agent.start("Research the impact of renewable energy on reducing carbon emissions")
+print(research_results)
+```
+
+## Adding Web Search Capability
+
+To make our research agent more powerful, let's add web search capability:
+
+```python
+from praisonaiagents import Agent, Tool
+
+# Define a web search function (simulated for this example)
+def web_search(query):
+    """
+    Simulated web search function.
+    In a real application, this would connect to a search API.
+    
+    Args:
+        query (str): The search query
+        
+    Returns:
+        str: Search results
+    """
+    # This is just a simulation - in a real application, you'd call a search API
+    if "renewable energy" in query.lower():
+        return """
+        Search results for 'renewable energy carbon emissions':
+        
+        1. According to the IEA, renewable energy prevented 2.1 billion tonnes of CO2 emissions in 2022.
+        
+        2. Solar and wind power generate electricity with 95-98% lower carbon emissions than coal-based electricity.
+        
+        3. The IPCC reports that renewable energy could deliver more than half of the emission reductions needed by 2030.
+        """
+    else:
+        return f"Search results for '{query}' (simulated data)"
+
+# Create the web search tool
+search_tool = Tool(
+    name="web_search",
+    function=web_search,
+    description="Search the web for current information on a topic"
+)
+
+# Create a research agent with web search capability
+enhanced_research_agent = Agent(
+    name="EnhancedResearchAgent",
+    instructions="""
+    You are a research specialist who finds and summarizes information.
+    
+    When researching topics:
+    1. Use the web_search tool to find current information
+    2. Analyze and synthesize the search results
+    3. Organize findings in a logical structure
+    4. Identify key points and insights
+    5. Present information in a clear, concise format
+    """,
+    tools=[search_tool]
+)
+
+# Use the enhanced research agent
+enhanced_results = enhanced_research_agent.start("What is the impact of renewable energy on carbon emissions?")
+print(enhanced_results)
+```
+
+## Research Agent with Structured Output
+
+For more organized research results, we can instruct the agent to provide structured output:
+
+```python
+structured_research_agent = Agent(
+    name="StructuredResearchAgent",
+    instructions="""
+    You are a research specialist who finds and organizes information.
+    
+    When researching topics:
+    1. Use available tools to find current information
+    2. Analyze and synthesize the findings
+    
+    Always structure your response in this format:
+    
+    ## Summary
+    [Brief 2-3 sentence overview of the topic]
+    
+    ## Key Facts
+    - [Important fact 1]
+    - [Important fact 2]
+    - [Important fact 3]
+    
+    ## Analysis
+    [Deeper analysis of the information, including implications]
+    
+    ## Sources
+    [List of sources if available]
+    """,
+    tools=[search_tool]
+)
+
+# Use the structured research agent
+structured_results = structured_research_agent.start("Research the latest advancements in quantum computing")
+print(structured_results)
+```
+
+## Specialized Research Agents
+
+Different research tasks require different approaches. Here are some specialized research agents:
+
+### Comparison Research Agent
+
+```python
+comparison_agent = Agent(
+    name="ComparisonAgent",
+    instructions="""
+    You are a research specialist who compares different options or topics.
+    
+    When comparing items:
+    1. Identify the key criteria for comparison
+    2. Research each option thoroughly
+    3. Create a clear side-by-side comparison
+    4. Highlight advantages and disadvantages of each option
+    5. Provide a balanced conclusion
+    
+    Present your findings in a structured table format when appropriate.
+    """,
+    tools=[search_tool]
+)
+
+# Use the comparison agent
+comparison_results = comparison_agent.start("Compare solar and wind energy for residential use")
+print(comparison_results)
+```
+
+### Literature Review Agent
+
+```python
+literature_agent = Agent(
+    name="LiteratureAgent",
+    instructions="""
+    You are a research specialist who reviews academic and professional literature.
+    
+    When reviewing literature:
+    1. Identify key papers, articles, and studies on the topic
+    2. Summarize the main findings and methodologies
+    3. Identify trends, agreements, and contradictions
+    4. Evaluate the strength of evidence
+    5. Highlight gaps in current research
+    
+    Structure your review in a clear, academic format.
+    """,
+    tools=[search_tool]
+)
+
+# Use the literature review agent
+literature_results = literature_agent.start("Review recent research on artificial intelligence in healthcare")
+print(literature_results)
+```
+
+## Research Process Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Define Scope" icon="bullseye">
+    Set clear boundaries for the research
+  </Card>
+  <Card title="Verify Information" icon="check-double">
+    Cross-check facts from multiple sources
+  </Card>
+  <Card title="Consider Bias" icon="scale-balanced">
+    Be aware of potential biases in sources
+  </Card>
+  <Card title="Prioritize Relevance" icon="filter">
+    Focus on information most relevant to the query
+  </Card>
+</CardGroup>
+
+In the next lesson, we'll explore how to build agents that can assist with creative tasks like content creation.

docs/course/agents/16-content-creation-agents.mdx

@@ -0,0 +1,252 @@
+---
+title: "Content Creation Agents"
+description: "Building agents that generate various types of content"
+icon: "pen-to-square"
+---
+
+# Content Creation Agents
+
+Content creation agents can help generate various types of content, from blog posts to marketing materials. In this lesson, we'll learn how to build effective content creation agents.
+
+## What is a Content Creation Agent?
+
+A content creation agent is designed to:
+- Generate written content based on specific requirements
+- Structure content in appropriate formats
+- Adapt tone and style to match the target audience
+- Create content that achieves specific goals (inform, persuade, entertain)
+
+## Creating a Basic Content Creation Agent
+
+Let's start with a simple content creation agent:
+
+```python
+from praisonaiagents import Agent
+
+# Create a basic content creation agent
+content_agent = Agent(
+    name="ContentCreator",
+    instructions="""
+    You are a versatile content creator who specializes in writing engaging material.
+    
+    When creating content:
+    1. Understand the purpose and target audience
+    2. Create a logical structure with clear sections
+    3. Use an engaging, appropriate writing style
+    4. Include a strong introduction and conclusion
+    5. Format content for easy readability
+    """
+)
+
+# Use the content creation agent
+blog_post = content_agent.start(
+    """
+    Create a blog post about the benefits of meditation.
+    Target audience: Busy professionals
+    Length: Approximately 500 words
+    Tone: Informative but conversational
+    """
+)
+print(blog_post)
+```
+
+## Specialized Content Creation Agents
+
+Different types of content require different approaches. Let's create specialized agents for various content needs:
+
+### Blog Post Agent
+
+```python
+blog_agent = Agent(
+    name="BlogWriter",
+    instructions="""
+    You are a blog post writer who creates engaging, informative articles.
+    
+    When writing blog posts:
+    1. Create attention-grabbing headlines
+    2. Start with a compelling introduction
+    3. Use subheadings to organize content
+    4. Include relevant examples and evidence
+    5. Incorporate a clear call-to-action at the end
+    
+    Format your content with proper Markdown formatting including:
+    - Headings (## for main sections, ### for subsections)
+    - Bullet points for lists
+    - *Italic* for emphasis
+    - **Bold** for important points
+    - > Blockquotes for notable quotes
+    """
+)
+
+# Use the blog agent
+blog_content = blog_agent.start(
+    """
+    Topic: 5 Ways to Improve Your Productivity
+    Target audience: Remote workers
+    Style: Practical, actionable advice
+    Length: 800 words
+    Include: Tips, examples, and research-backed information
+    """
+)
+print(blog_content)
+```
+
+### Social Media Content Agent
+
+```python
+social_media_agent = Agent(
+    name="SocialMediaCreator",
+    instructions="""
+    You are a social media content creator who crafts engaging posts.
+    
+    When creating social media content:
+    1. Create attention-grabbing, concise content
+    2. Adapt to the specific platform requirements
+    3. Include relevant hashtags when appropriate
+    4. Craft content that encourages engagement
+    5. Consider visual elements that would pair well with the text
+    
+    For each platform, follow these guidelines:
+    - Twitter/X: 280 characters max, punchy, relevant hashtags
+    - LinkedIn: Professional tone, industry insights, 1-3 paragraphs
+    - Instagram: Visual-focused descriptions, emoji-friendly, hashtags
+    - Facebook: Conversational, can be longer, question-based engagement
+    """
+)
+
+# Use the social media agent
+social_content = social_media_agent.start(
+    """
+    Create posts for Twitter, LinkedIn, and Facebook announcing:
+    
+    Event: Free Webinar on "Future of AI in Business"
+    Date: March 15, 2025
+    Time: 2:00 PM EST
+    Registration link: example.com/webinar
+    Key speakers: Dr. Jane Smith, AI Ethics Expert & Tom Johnson, Business AI Implementation Specialist
+    """
+)
+print(social_content)
+```
+
+### Email Campaign Agent
+
+```python
+email_agent = Agent(
+    name="EmailWriter",
+    instructions="""
+    You are an email marketing specialist who creates effective email campaigns.
+    
+    When writing marketing emails:
+    1. Create compelling subject lines that increase open rates
+    2. Write engaging opening lines that hook the reader
+    3. Keep content concise and focused on a single main message
+    4. Include clear calls-to-action
+    5. Use a tone appropriate for the brand and audience
+    
+    Structure your emails with:
+    - Subject line
+    - Greeting
+    - Opening hook
+    - Main content (2-3 paragraphs maximum)
+    - Call-to-action
+    - Sign-off
+    """
+)
+
+# Use the email agent
+email_content = email_agent.start(
+    """
+    Create a promotional email for:
+    
+    Product: Premium Fitness Subscription
+    Key benefit: Personalized workout plans and nutrition advice
+    Special offer: 30% off first 3 months
+    Target audience: Health-conscious professionals aged 25-45
+    CTA: Sign up for the discounted offer
+    Tone: Motivational but not aggressive
+    """
+)
+print(email_content)
+```
+
+## Content Creation with Templates
+
+Templates can help create more consistent content. Let's build an agent that works with templates:
+
+```python
+template_agent = Agent(
+    name="TemplateWriter",
+    instructions="""
+    You are a content creator who works with templates to create consistent content.
+    
+    When filling a template:
+    1. Maintain the overall structure of the template
+    2. Replace placeholder text with appropriate content
+    3. Ensure consistency in tone and style
+    4. Adapt content to the specific requirements
+    5. Review for coherence and flow
+    
+    Always preserve formatting elements like headings, lists, and emphasis.
+    """
+)
+
+# Example template
+product_review_template = """
+# {Product Name} Review: {Brief Opinion}
+
+## Quick Summary
+**Rating:** {Rating}/10
+**Price:** {Price Range}
+**Recommended For:** {Target User}
+
+## What We Liked
+- {Positive Point 1}
+- {Positive Point 2}
+- {Positive Point 3}
+
+## What Could Be Better
+- {Negative Point 1}
+- {Negative Point 2}
+
+## Bottom Line
+{Conclusion Paragraph}
+
+"""
+
+# Use the template agent
+filled_template = template_agent.start(
+    f"""
+    Fill the following template for a product review:
+    
+    {product_review_template}
+    
+    Product: Wireless Noise-Cancelling Headphones XZ200
+    Key features: 30-hour battery life, active noise cancellation, voice assistant integration
+    Price: $249.99
+    Target audience: Commuters and office workers
+    Notable pros: Sound quality, comfort, battery life
+    Notable cons: Price, occasional Bluetooth connectivity issues
+    """
+)
+print(filled_template)
+```
+
+## Content Creation Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Know Your Audience" icon="users">
+    Understand who will consume the content
+  </Card>
+  <Card title="Clear Purpose" icon="bullseye">
+    Define what the content should achieve
+  </Card>
+  <Card title="Consistent Voice" icon="comment">
+    Maintain a consistent tone and style
+  </Card>
+  <Card title="Readability" icon="eye">
+    Make content easy to scan and understand
+  </Card>
+</CardGroup>
+
+In the next lesson, we'll explore how to build AI agents that can analyze and work with data.

docs/course/agents/17-data-analysis-agents.mdx

@@ -0,0 +1,333 @@
+---
+title: "Data Analysis Agents"
+description: "Creating agents that analyze and interpret data"
+icon: "chart-line"
+---
+
+# Data Analysis Agents
+
+Data analysis agents can help process, analyze, and extract insights from data. In this lesson, we'll learn how to build agents that can work with data effectively.
+
+## What is a Data Analysis Agent?
+
+A data analysis agent is designed to:
+- Process and interpret data
+- Identify patterns and trends
+- Generate insights and recommendations
+- Present findings in an understandable format
+
+## Creating a Basic Data Analysis Agent
+
+Let's start by building a simple data analysis agent:
+
+```python
+from praisonaiagents import Agent
+
+# Create a basic data analysis agent
+data_analysis_agent = Agent(
+    name="DataAnalyst",
+    instructions="""
+    You are a data analysis specialist who interprets and explains data.
+    
+    When analyzing data:
+    1. First understand what the data represents
+    2. Identify key patterns, trends, or anomalies
+    3. Generate meaningful insights
+    4. Explain findings in simple, clear language
+    5. Provide actionable recommendations when appropriate
+    """
+)
+
+# Use the data analysis agent with sample data
+sample_data = """
+Monthly Sales Data (2024):
+January: $12,500
+February: $13,200
+March: $15,800
+April: $14,300
+May: $16,700
+June: $18,900
+"""
+
+analysis = data_analysis_agent.start(
+    f"""
+    Analyze the following sales data and provide insights:
+    
+    {sample_data}
+    
+    Questions to answer:
+    1. What is the overall sales trend?
+    2. Which month had the highest sales?
+    3. What is the average monthly sales?
+    4. What recommendations would you make based on this data?
+    """
+)
+print(analysis)
+```
+
+## Adding Data Processing Tools
+
+Let's enhance our agent with basic data processing capabilities:
+
+```python
+from praisonaiagents import Agent, Tool
+
+# Define a simple calculation tool
+def calculate_statistics(data_string):
+    """
+    Calculate basic statistics from a string of numbers.
+    
+    Args:
+        data_string (str): A string with numbers separated by commas
+        
+    Returns:
+        str: Statistical summary
+    """
+    try:
+        # Convert string to list of numbers
+        data = [float(x.strip()) for x in data_string.split(',')]
+        
+        # Calculate statistics
+        total = sum(data)
+        average = total / len(data)
+        minimum = min(data)
+        maximum = max(data)
+        
+        return f"""
+        Statistical summary:
+        - Count: {len(data)}
+        - Sum: {total}
+        - Average: {average:.2f}
+        - Minimum: {minimum}
+        - Maximum: {maximum}
+        - Range: {maximum - minimum}
+        """
+    except Exception as e:
+        return f"Error processing data: {str(e)}"
+
+# Create the tool
+stats_tool = Tool(
+    name="calculate_statistics",
+    function=calculate_statistics,
+    description="Calculate basic statistics from a list of numbers (comma-separated)"
+)
+
+# Create an agent with the statistics tool
+enhanced_data_agent = Agent(
+    name="EnhancedDataAnalyst",
+    instructions="""
+    You are a data analysis specialist who interprets and explains data.
+    
+    When analyzing data:
+    1. First understand what the data represents
+    2. Use the calculate_statistics tool for numerical data
+    3. Identify key patterns, trends, or anomalies
+    4. Generate meaningful insights
+    5. Explain findings in simple, clear language
+    6. Provide actionable recommendations when appropriate
+    """,
+    tools=[stats_tool]
+)
+
+# Use the enhanced data agent
+numerical_data = "12500, 13200, 15800, 14300, 16700, 18900"
+enhanced_analysis = enhanced_data_agent.start(
+    f"""
+    Analyze the following monthly sales data for the first half of 2024:
+    
+    {numerical_data}
+    
+    Provide a complete analysis with trends and recommendations.
+    """
+)
+print(enhanced_analysis)
+```
+
+## Specialized Data Analysis Agents
+
+Different analysis tasks require specialized approaches. Let's create some specialized agents:
+
+### Market Trend Analysis Agent
+
+```python
+market_analysis_agent = Agent(
+    name="MarketAnalyst",
+    instructions="""
+    You are a market trend analyst who specializes in identifying patterns and making predictions.
+    
+    When analyzing market data:
+    1. Identify long-term trends and short-term patterns
+    2. Compare data points to industry benchmarks
+    3. Identify potential causes for changes
+    4. Assess future implications
+    5. Provide strategic recommendations
+    
+    Present your analysis with clear sections for:
+    - Overall Market Assessment
+    - Key Trends Identified
+    - Growth Opportunities
+    - Risk Factors
+    - Strategic Recommendations
+    """,
+    tools=[stats_tool]
+)
+
+# Use the market analysis agent
+market_data = """
+Industry Growth Rates (2021-2024):
+2021: 3.2%
+2022: 2.8%
+2023: 4.5%
+2024: 5.1%
+
+Our Company Growth:
+2021: 2.9%
+2022: 3.1%
+2023: 4.8%
+2024: 6.3%
+
+Competitor A Growth:
+2021: 3.5%
+2022: 3.7%
+2023: 4.2%
+2024: 4.5%
+
+Competitor B Growth:
+2021: 3.0%
+2022: 2.5%
+2023: 5.0%
+2024: 5.8%
+"""
+
+market_analysis = market_analysis_agent.start(
+    f"""
+    Analyze the following market and company growth data:
+    
+    {market_data}
+    
+    Provide a comprehensive market analysis and strategic recommendations.
+    """
+)
+print(market_analysis)
+```
+
+### Customer Data Analysis Agent
+
+```python
+customer_analysis_agent = Agent(
+    name="CustomerAnalyst",
+    instructions="""
+    You are a customer data analyst who specializes in understanding customer behavior.
+    
+    When analyzing customer data:
+    1. Identify customer segments and patterns
+    2. Analyze purchasing behavior
+    3. Evaluate customer satisfaction metrics
+    4. Identify opportunities to improve customer experience
+    5. Recommend strategies for customer retention and growth
+    
+    Present your analysis with sections for:
+    - Customer Segmentation
+    - Behavior Patterns
+    - Key Insights
+    - Recommended Actions
+    """,
+    tools=[stats_tool]
+)
+
+# Use the customer analysis agent
+customer_data = """
+Customer Segments by Age:
+18-24: 15% of customers (Avg. Purchase: $45)
+25-34: 32% of customers (Avg. Purchase: $78)
+35-44: 28% of customers (Avg. Purchase: $92)
+45-54: 18% of customers (Avg. Purchase: $85)
+55+: 7% of customers (Avg. Purchase: $65)
+
+Customer Satisfaction:
+Very Satisfied: 42%
+Satisfied: 35%
+Neutral: 15%
+Dissatisfied: 6%
+Very Dissatisfied: 2%
+
+Repeat Purchase Rate:
+One-time: 40%
+2-5 purchases: 35%
+6-10 purchases: 15%
+10+ purchases: 10%
+"""
+
+customer_analysis = customer_analysis_agent.start(
+    f"""
+    Analyze the following customer data:
+    
+    {customer_data}
+    
+    Provide insights on customer segments, behavior patterns, and recommendations to improve customer retention.
+    """
+)
+print(customer_analysis)
+```
+
+## Data Visualization Recommendations
+
+While our agents can't directly create visualizations, they can recommend appropriate visualization types:
+
+```python
+visualization_agent = Agent(
+    name="VisualizationAdvisor",
+    instructions="""
+    You are a data visualization specialist who helps select the best ways to visually represent data.
+    
+    When recommending visualizations:
+    1. Understand the nature of the data (categorical, numerical, time-series, etc.)
+    2. Consider the key relationships or patterns to highlight
+    3. Recommend the most appropriate chart or graph type
+    4. Explain why your recommendation is effective
+    5. Provide suggestions for layout, color scheme, and labeling
+    
+    Common visualization types to consider:
+    - Line charts (for trends over time)
+    - Bar charts (for comparing categories)
+    - Pie charts (for showing composition, use sparingly)
+    - Scatter plots (for showing relationships between variables)
+    - Heatmaps (for showing patterns in complex data)
+    - Box plots (for showing distributions)
+    """
+)
+
+# Use the visualization agent
+viz_recommendations = visualization_agent.start(
+    """
+    I have the following data and need visualization recommendations:
+    
+    1. Monthly sales data for the past year
+    2. Customer satisfaction ratings across 5 product categories
+    3. Market share compared to 3 competitors
+    4. Customer age distribution
+    
+    What visualizations would you recommend for each of these datasets and why?
+    """
+)
+print(viz_recommendations)
+```
+
+## Data Analysis Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Data Quality" icon="shield-check">
+    Ensure data is accurate and complete
+  </Card>
+  <Card title="Context Matters" icon="circle-info">
+    Consider external factors affecting data
+  </Card>
+  <Card title="Clear Communication" icon="comments">
+    Present findings in understandable terms
+  </Card>
+  <Card title="Actionable Insights" icon="bolt">
+    Focus on insights that lead to action
+  </Card>
+</CardGroup>
+
+In the next lesson, we'll explore how to build AI agents that can assist with customer support tasks.

docs/course/agents/18-customer-support-agents.mdx

@@ -0,0 +1,260 @@
+---
+title: "Customer Support Agents"
+description: "Building agents that handle customer inquiries and issues"
+icon: "headset"
+---
+
+# Customer Support Agents
+
+Customer support agents can handle inquiries, resolve issues, and provide assistance to users. In this lesson, we'll learn how to build effective customer support agents.
+
+## What is a Customer Support Agent?
+
+A customer support agent is designed to:
+- Answer frequently asked questions
+- Troubleshoot common problems
+- Provide information about products or services
+- Collect information for support tickets
+- Guide users through processes or procedures
+
+## Creating a Basic Customer Support Agent
+
+Let's start by building a simple customer support agent:
+
+```python
+from praisonaiagents import Agent
+
+# Create a basic customer support agent
+support_agent = Agent(
+    name="SupportAgent",
+    instructions="""
+    You are a helpful customer support representative for a software company.
+    
+    When helping customers:
+    1. Greet them professionally and warmly
+    2. Understand their issue completely before attempting to solve it
+    3. Provide clear, step-by-step solutions when possible
+    4. Maintain a friendly, patient tone throughout
+    5. If you cannot solve the issue, explain how to escalate it
+    
+    Our software product is a productivity app with features for:
+    - Task management
+    - Calendar scheduling
+    - Note-taking
+    - Team collaboration
+    """
+)
+
+# Use the support agent
+response = support_agent.start("I'm having trouble syncing my calendar with my phone. Can you help?")
+print(response)
+```
+
+## Adding a Knowledge Base
+
+Let's enhance our agent with a simple knowledge base to answer common questions:
+
+```python
+from praisonaiagents import Agent, KnowledgeBase
+
+# Create a simple knowledge base
+faq_kb = KnowledgeBase()
+
+# Add FAQ content (in a real scenario, you would load this from files)
+faq_kb.add_text("""
+# Frequently Asked Questions
+
+## Account Issues
+
+### How do I reset my password?
+To reset your password:
+1. Go to the login page
+2. Click on "Forgot Password"
+3. Enter your email address
+4. Follow the instructions sent to your email
+
+### How do I change my email address?
+To change your email address:
+1. Log in to your account
+2. Go to Settings > Account
+3. Click on "Change Email"
+4. Enter your new email and confirm with your password
+
+## Subscription and Billing
+
+### What subscription plans do you offer?
+We offer three plans:
+- Basic: $9.99/month - Includes core features for individuals
+- Pro: $19.99/month - Includes advanced features and team capabilities for up to 5 users
+- Enterprise: Custom pricing - Full feature set with advanced security and support
+
+### How do I cancel my subscription?
+To cancel your subscription:
+1. Log in to your account
+2. Go to Settings > Billing
+3. Click "Cancel Subscription"
+4. Follow the confirmation steps
+
+## Technical Issues
+
+### Why isn't my calendar syncing?
+Common reasons for calendar sync issues:
+1. Outdated app version - Try updating the app
+2. Account permission issues - Check sync permissions in Settings > Integrations
+3. Internet connectivity problems - Ensure you have a stable connection
+
+### How do I export my data?
+To export your data:
+1. Go to Settings > Data
+2. Click "Export Data"
+3. Choose the data types you want to export
+4. Select your preferred format (CSV or JSON)
+5. Click "Export" and save the file
+""")
+
+# Create an agent with the knowledge base
+kb_support_agent = Agent(
+    name="KnowledgeBaseAgent",
+    instructions="""
+    You are a helpful customer support representative with access to our FAQ knowledge base.
+    
+    When helping customers:
+    1. Greet them professionally and warmly
+    2. Search the knowledge base for relevant information
+    3. Provide clear, accurate answers based on the knowledge base
+    4. If the knowledge base doesn't cover the question, provide general helpful guidance
+    5. Maintain a friendly, supportive tone throughout
+    """,
+    knowledge_base=faq_kb
+)
+
+# Use the knowledge base support agent
+kb_response = kb_support_agent.start("How do I cancel my subscription?")
+print(kb_response)
+```
+
+## Creating a Troubleshooting Agent
+
+Let's create an agent specialized in technical troubleshooting:
+
+```python
+troubleshooting_agent = Agent(
+    name="TroubleshootingAgent",
+    instructions="""
+    You are a technical support specialist who helps users troubleshoot problems.
+    
+    When troubleshooting:
+    1. Ask clarifying questions to understand the exact issue
+    2. Identify the most likely causes of the problem
+    3. Provide step-by-step solutions, starting with the simplest fixes
+    4. Explain what each step does and why it might help
+    5. Confirm if the issue is resolved or suggest next steps
+    
+    Common troubleshooting areas:
+    - Login and account access issues
+    - App installation and updates
+    - Feature functionality problems
+    - Data synchronization
+    - Performance issues
+    """
+)
+
+# Use the troubleshooting agent
+troubleshooting_response = troubleshooting_agent.start("The app keeps crashing when I try to open it on my iPhone")
+print(troubleshooting_response)
+```
+
+## Building a Conversational Support Agent
+
+Let's create a support agent that can handle multi-turn conversations:
+
+```python
+conversational_support = Agent(
+    name="ConversationalSupport",
+    instructions="""
+    You are a customer support representative who handles support conversations.
+    
+    When handling support conversations:
+    1. Maintain context throughout the conversation
+    2. Ask follow-up questions when needed
+    3. Verify understanding before providing solutions
+    4. Be patient with users who may be frustrated
+    5. Summarize the conversation and next steps at the end
+    
+    Our product is a mobile banking app with features for:
+    - Account balance checking
+    - Money transfers
+    - Bill payments
+    - Mobile check deposits
+    - Budget tracking
+    """
+)
+
+# Start a support conversation
+initial_response = conversational_support.start("I can't find where to deposit checks in the app")
+print("Initial Response:", initial_response)
+
+# Continue the conversation
+follow_up_response = conversational_support.continue("I'm using version 2.5 of the app on Android")
+print("Follow-up Response:", follow_up_response)
+
+# Further continuation
+resolution_response = conversational_support.continue("I found the deposit button now, but it's giving me an error when I try to take a photo")
+print("Resolution Response:", resolution_response)
+```
+
+## Support Ticket Creation Agent
+
+Let's create an agent that can gather information for support tickets:
+
+```python
+ticket_agent = Agent(
+    name="TicketCreationAgent",
+    instructions="""
+    You are a support ticket creation specialist who gathers the necessary information to create support tickets.
+    
+    When creating a ticket:
+    1. Collect the customer's name and contact information
+    2. Identify the category of the issue
+    3. Gather a detailed description of the problem
+    4. Determine the severity level
+    5. Collect relevant technical details (device, software version, etc.)
+    6. Organize all information in a structured ticket format
+    
+    Present the final ticket in a clearly formatted structure.
+    """
+)
+
+# Use the ticket creation agent
+ticket = ticket_agent.start(
+    """
+    Create a support ticket for the following issue:
+    
+    Customer: Jane Smith
+    Email: [email protected]
+    Issue: Cannot access premium features after payment
+    Details: Completed payment yesterday, received confirmation email, but premium features are still locked in the app
+    Using: iPhone 13, app version 3.2.1
+    """
+)
+print(ticket)
+```
+
+## Customer Support Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Empathy First" icon="heart">
+    Show understanding before offering solutions
+  </Card>
+  <Card title="Clear Communication" icon="comment">
+    Use simple language, avoid jargon
+  </Card>
+  <Card title="Consistent Responses" icon="equals">
+    Provide consistent answers to similar questions
+  </Card>
+  <Card title="Know Escalation Paths" icon="arrow-up-right">
+    Have clear processes for escalating complex issues
+  </Card>
+</CardGroup>
+
+In the next lesson, we'll explore how to build AI agents that can assist with personal productivity tasks.

docs/course/agents/19-personal-assistant-agents.mdx

@@ -0,0 +1,270 @@
+---
+title: "Personal Assistant Agents"
+description: "Building agents that help with personal tasks and productivity"
+icon: "calendar-check"
+---
+
+# Personal Assistant Agents
+
+Personal assistant agents can help users manage tasks, organize information, and increase productivity. In this lesson, we'll learn how to build effective personal assistant agents.
+
+## What is a Personal Assistant Agent?
+
+A personal assistant agent is designed to:
+- Manage tasks and reminders
+- Organize information
+- Answer questions
+- Provide recommendations
+- Help with personal productivity
+
+## Creating a Basic Personal Assistant Agent
+
+Let's start by building a simple personal assistant agent:
+
+```python
+from praisonaiagents import Agent
+
+# Create a basic personal assistant agent
+assistant_agent = Agent(
+    name="PersonalAssistant",
+    instructions="""
+    You are a helpful personal assistant who helps users manage tasks and information.
+    
+    When assisting users:
+    1. Be concise and efficient in your responses
+    2. Prioritize user requests based on importance and urgency
+    3. Maintain a helpful, friendly tone
+    4. Remember important information the user shares
+    5. Proactively suggest relevant information when appropriate
+    """,
+    llm="gpt-4o-mini"  # Using the specified model
+)
+
+# Use the personal assistant agent
+response = assistant_agent.start("I need to plan a meeting with my team next Tuesday at 2 PM")
+print(response)
+```
+
+## Task Management Assistant
+
+Let's create an agent specialized in task management:
+
+```python
+task_agent = Agent(
+    name="TaskManager",
+    instructions="""
+    You are a task management assistant who helps users organize and prioritize tasks.
+    
+    When managing tasks:
+    1. Help identify and clarify tasks
+    2. Assist with prioritization
+    3. Break down complex tasks into manageable steps
+    4. Track deadlines and progress
+    5. Provide reminders and follow-ups
+    
+    For each task, collect:
+    - Task description
+    - Priority (High, Medium, Low)
+    - Deadline (if applicable)
+    - Dependencies (other tasks that must be completed first)
+    - Estimated time required
+    """,
+    llm="gpt-4o-mini"  # Using the specified model
+)
+
+# Use the task management agent
+task_response = task_agent.start(
+    """
+    I need help organizing these tasks for the week:
+    
+    - Prepare quarterly report (due Friday)
+    - Meet with client about new project (Wednesday, 2 PM)
+    - Review team's project proposals
+    - Finish budget planning for next quarter
+    - Send feedback on marketing materials
+    """
+)
+print(task_response)
+```
+
+## Information Organization Assistant
+
+Let's create an agent that helps organize information:
+
+```python
+info_agent = Agent(
+    name="InformationOrganizer",
+    instructions="""
+    You are an information organization assistant who helps users structure and categorize information.
+    
+    When organizing information:
+    1. Identify the main categories and topics
+    2. Create logical groupings
+    3. Suggest clear labels and headers
+    4. Establish relationships between different pieces of information
+    5. Present information in a structured, easily navigable format
+    """,
+    llm="gpt-4o-mini"  # Using the specified model
+)
+
+# Use the information organization agent
+info_response = info_agent.start(
+    """
+    Help me organize my research notes on climate change:
+    
+    - Rising sea levels affecting coastal cities
+    - Carbon dioxide levels increasing annually
+    - Renewable energy adoption statistics by country
+    - Impact of deforestation on carbon sequestration
+    - Climate policy differences between EU and US
+    - Economic impacts of extreme weather events
+    - Public opinion polls on climate action
+    - Arctic ice sheet measurements over 50 years
+    - Agricultural adaptations to changing climate
+    """
+)
+print(info_response)
+```
+
+## Daily Planning Assistant
+
+Let's create an agent that helps with daily planning:
+
+```python
+planning_agent = Agent(
+    name="DailyPlanner",
+    instructions="""
+    You are a daily planning assistant who helps users organize their day efficiently.
+    
+    When helping with daily planning:
+    1. Prioritize tasks based on importance and deadlines
+    2. Consider time constraints and commitments
+    3. Suggest efficient scheduling
+    4. Allow for breaks and transitions
+    5. Balance work tasks with personal needs
+    
+    Create a structured daily plan with time blocks and priorities.
+    """,
+    llm="gpt-4o-mini"  # Using the specified model
+)
+
+# Use the daily planning agent
+planning_response = planning_agent.start(
+    """
+    Help me plan my day tomorrow. I have:
+    
+    - A team meeting from 9:30-10:30 AM
+    - A report due by end of day
+    - Emails to catch up on (about 1 hour's worth)
+    - Lunch with a colleague at 12:30 PM
+    - A dentist appointment at 3:00 PM (will take about 1 hour including travel)
+    - Need to prepare a presentation for Friday
+    
+    I typically work from 8:30 AM to 5:30 PM and prefer to have short breaks between tasks.
+    """
+)
+print(planning_response)
+```
+
+## Decision Support Assistant
+
+Let's create an agent that helps with decision-making:
+
+```python
+decision_agent = Agent(
+    name="DecisionSupport",
+    instructions="""
+    You are a decision support assistant who helps users make informed choices.
+    
+    When supporting decisions:
+    1. Help clarify the decision to be made
+    2. Identify relevant criteria and factors
+    3. Present pros and cons for each option
+    4. Ask questions to understand preferences and priorities
+    5. Provide a structured analysis without making the final decision
+    
+    Present options with balanced information to help the user make their own informed choice.
+    """,
+    llm="gpt-4o-mini"  # Using the specified model
+)
+
+# Use the decision support agent
+decision_response = decision_agent.start(
+    """
+    I'm trying to decide whether to buy a new laptop now or wait 3 months. 
+    
+    Current situation:
+    - My current laptop is 4 years old and running slow
+    - It still works but has battery issues
+    - I use it daily for work (programming and video calls)
+    - I've heard new models are coming out in 3 months
+    - My budget is around $1,500
+    
+    What should I consider in making this decision?
+    """
+)
+print(decision_response)
+```
+
+## Recommendation Assistant
+
+Let's create an agent that provides personalized recommendations:
+
+```python
+recommendation_agent = Agent(
+    name="RecommendationAssistant",
+    instructions="""
+    You are a recommendation assistant who provides personalized suggestions.
+    
+    When making recommendations:
+    1. Understand the user's preferences and requirements
+    2. Consider constraints (budget, time, location, etc.)
+    3. Provide diverse options that match the criteria
+    4. Explain why each recommendation might be suitable
+    5. Give enough detail for the user to evaluate options
+    
+    For each recommendation, include:
+    - A brief description
+    - Key features or highlights
+    - Why it matches the user's needs
+    """,
+    llm="gpt-4o-mini"  # Using the specified model
+)
+
+# Use the recommendation agent
+recommendation_response = recommendation_agent.start(
+    """
+    Can you recommend some books for me? I enjoy:
+    
+    - Science fiction and fantasy
+    - Books with complex, morally gray characters
+    - Intricate world-building
+    - Books that explore philosophical themes
+    
+    I've recently read and enjoyed:
+    - "The Fifth Season" by N.K. Jemisin
+    - "Dune" by Frank Herbert
+    - "The Lies of Locke Lamora" by Scott Lynch
+    """
+)
+print(recommendation_response)
+```
+
+## Personal Assistant Best Practices
+
+<CardGroup cols={2}>
+  <Card title="Respect Privacy" icon="lock">
+    Be careful with personal information
+  </Card>
+  <Card title="Customize Interactions" icon="sliders">
+    Adapt to the user's preferences
+  </Card>
+  <Card title="Clear Communication" icon="comment">
+    Keep responses direct and easy to understand
+  </Card>
+  <Card title="Contextual Awareness" icon="puzzle-piece">
+    Remember relevant context from previous interactions
+  </Card>
+</CardGroup>
+
+In the next lesson, we'll explore how to deploy and share your AI agents with others.

docs/course/agents/20-deploying-agents.mdx

@@ -0,0 +1,342 @@
+---
+title: "Deploying Agents"
+description: "How to deploy and share your AI agents with others"
+icon: "rocket"
+---
+
+# Deploying Agents
+
+After creating your AI agents, the next step is deploying them for use by yourself or others. In this final lesson, we'll explore different deployment options and best practices.
+
+## Deployment Options
+
+There are several ways to deploy your AI agents:
+
+### 1. Local Deployment
+
+Running your agents locally is the simplest approach:
+
+```python
+from praisonaiagents import Agent
+
+def run_local_agent():
+    agent = Agent(
+        name="SimpleAgent",
+        instructions="You are a helpful assistant that answers questions concisely.",
+        llm="gpt-4o-mini"  # Using the specified model
+    )
+    
+    while True:
+        user_input = input("Ask a question (type 'exit' to quit): ")
+        if user_input.lower() == 'exit':
+            break
+        
+        response = agent.start(user_input)
+        print("\nAgent response:")
+        print(response)
+        print("\n" + "-"*50 + "\n")
+
+if __name__ == "__main__":
+    run_local_agent()
+```
+
+### 2. Web Application Deployment
+
+You can deploy your agents as part of a web application:
+
+```python
+from flask import Flask, request, jsonify
+from praisonaiagents import Agent
+import os
+
+app = Flask(__name__)
+
+# Create agent once at startup
+support_agent = Agent(
+    name="SupportAgent",
+    instructions="You are a customer support agent that helps users with product questions.",
+    llm="gpt-4o-mini"  # Using the specified model
+)
+
+@app.route('/api/support', methods=['POST'])
+def get_support():
+    data = request.json
+    user_query = data.get('query', '')
+    
+    if not user_query:
+        return jsonify({"error": "No query provided"}), 400
+    
+    try:
+        response = support_agent.start(user_query)
+        return jsonify({"response": response})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == "__main__":
+    app.run(debug=True, port=5000)
+```
+
+### 3. Serverless Function Deployment
+
+For scalable, event-driven deployments, serverless functions work well:
+
+```python
+# Example AWS Lambda function
+import json
+from praisonaiagents import Agent
+
+# Initialize agent outside the handler for reuse across invocations
+agent = Agent(
+    name="ServerlessAgent",
+    instructions="You provide concise, helpful responses to user questions.",
+    llm="gpt-4o-mini"  # Using the specified model
+)
+
+def lambda_handler(event, context):
+    try:
+        # Get the user query from the event
+        body = json.loads(event.get('body', '{}'))
+        user_query = body.get('query', '')
+        
+        if not user_query:
+            return {
+                'statusCode': 400,
+                'body': json.dumps({'error': 'No query provided'})
+            }
+        
+        # Process with the agent
+        response = agent.start(user_query)
+        
+        return {
+            'statusCode': 200,
+            'body': json.dumps({'response': response})
+        }
+    except Exception as e:
+        return {
+            'statusCode': 500,
+            'body': json.dumps({'error': str(e)})
+        }
+```
+
+## Environment Variables and Security
+
+When deploying agents, it's crucial to handle API keys and secrets securely:
+
+```python
+import os
+from dotenv import load_dotenv
+from praisonaiagents import Agent
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Access API key from environment variable
+api_key = os.getenv("OPENAI_API_KEY")
+
+# Create agent with API key
+agent = Agent(
+    name="SecureAgent",
+    instructions="You are a helpful assistant.",
+    llm="gpt-4o-mini",  # Using the specified model
+    api_key=api_key  # Pass API key securely
+)
+```
+
+## Creating a Simple Chat Interface
+
+Here's a simple command-line chat interface for your agent:
+
+```python
+import os
+from praisonaiagents import Agent
+
+def create_chat_interface():
+    # Initialize agent
+    agent = Agent(
+        name="ChatAgent",
+        instructions="""
+        You are a conversational assistant that maintains context throughout the conversation.
+        Respond in a helpful, concise manner.
+        """,
+        llm="gpt-4o-mini"  # Using the specified model
+    )
+    
+    print("Chat with AI Assistant (type 'exit' to quit)")
+    print("-" * 50)
+    
+    # Start conversation
+    conversation_active = True
+    first_message = True
+    
+    while conversation_active:
+        # Get user input
+        user_message = input("You: ")
+        
+        # Check if user wants to exit
+        if user_message.lower() == 'exit':
+            print("Goodbye!")
+            conversation_active = False
+            continue
+        
+        # Get agent response
+        try:
+            if first_message:
+                response = agent.start(user_message)
+                first_message = False
+            else:
+                response = agent.continue(user_message)
+            
+            print("\nAssistant:", response)
+            print("\n" + "-" * 50)
+        except Exception as e:
+            print(f"Error: {str(e)}")
+    
+if __name__ == "__main__":
+    create_chat_interface()
+```
+
+## Scaling Considerations
+
+As you deploy agents for wider use, consider these scaling factors:
+
+<CardGroup cols={2}>
+  <Card title="Rate Limiting" icon="gauge-high">
+    Implement rate limiting to manage API usage and costs
+  </Card>
+  <Card title="Caching" icon="database">
+    Cache common responses to improve performance and reduce API calls
+  </Card>
+  <Card title="Error Handling" icon="triangle-exclamation">
+    Implement robust error handling for API failures
+  </Card>
+  <Card title="Monitoring" icon="chart-line">
+    Set up monitoring for usage patterns and performance issues
+  </Card>
+</CardGroup>
+
+## Best Practices for Deployment
+
+### 1. Testing Before Deployment
+
+Always test your agents thoroughly before deployment:
+
+```python
+def test_agent_functionality():
+    """Test basic agent functionality with various inputs"""
+    agent = Agent(
+        name="TestAgent",
+        instructions="You are a helpful assistant for testing.",
+        llm="gpt-4o-mini"  # Using the specified model
+    )
+    
+    test_cases = [
+        "What is artificial intelligence?",
+        "How do I reset my password?",
+        "Tell me about machine learning"
+    ]
+    
+    for test_case in test_cases:
+        print(f"\nTesting: {test_case}")
+        response = agent.start(test_case)
+        print(f"Response: {response[:100]}...")  # Print first 100 chars
+        
+        # Add assertions or validation logic here
+        assert len(response) > 0, "Response should not be empty"
+```
+
+### 2. Documentation
+
+Create clear documentation for users of your agent:
+
+```python
+"""
+# Customer Support Agent API
+
+This API provides access to an AI customer support agent
+that can answer questions about our products.
+
+## Authentication
+
+Include your API key in the request header:
+```
+Authorization: Bearer YOUR_API_KEY
+```
+
+## Endpoints
+
+POST /api/support
+- Request body: {"query": "Your question here"}
+- Response: {"response": "Agent's answer"}
+
+## Example
+
+```python
+import requests
+
+response = requests.post(
+    "https://api.example.com/api/support",
+    headers={"Authorization": "Bearer YOUR_API_KEY"},
+    json={"query": "How do I reset my password?"}
+)
+
+print(response.json())
+```
+"""
+```
+
+### 3. Version Control
+
+Implement version control for your agents to track changes:
+
+```python
+class VersionedAgent:
+    def __init__(self, name, version, instructions):
+        self.name = name
+        self.version = version
+        self.agent = Agent(
+            name=f"{name}_v{version}",
+            instructions=instructions,
+            llm="gpt-4o-mini"  # Using the specified model
+        )
+    
+    def get_response(self, query):
+        response = self.agent.start(query)
+        return {
+            "agent_name": self.name,
+            "version": self.version,
+            "response": response,
+            "timestamp": datetime.now().isoformat()
+        }
+```
+
+## Conclusion
+
+Congratulations on completing the AI Agents Course! You've learned how to:
+
+1. Understand different types of AI agents and their architectures
+2. Create effective agent instructions and tools
+3. Implement memory and context for your agents
+4. Build specialized agents for various tasks
+5. Create multi-agent systems
+6. Deploy your agents for real-world use
+
+As AI agent technology continues to evolve, keep experimenting with new capabilities and use cases. Remember that the best agents are those that effectively solve real problems for users while being trustworthy, reliable, and helpful.
+
+We hope this course has provided you with the knowledge and skills to build powerful AI agents that enhance productivity and creativity!
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Join the Community" icon="users">
+    Participate in discussions and share your agent projects
+  </Card>
+  <Card title="Stay Updated" icon="newspaper">
+    Follow updates in AI agent technology and new features
+  </Card>
+  <Card title="Share Your Feedback" icon="comment">
+    Let us know how you're using agents and what you'd like to learn next
+  </Card>
+  <Card title="Build Real Solutions" icon="lightbulb">
+    Apply your knowledge to build solutions for real-world problems
+  </Card>
+</CardGroup>

docs/deploy/aws.mdx

@@ -0,0 +1,416 @@
+---
+title: "Deploying to AWS"
+sidebarTitle: "AWS"
+description: "Deploy PraisonAI agents to Amazon Web Services for scalable production environments"
+icon: "aws"
+---
+
+# Deploying PraisonAI Agents to AWS
+
+This guide provides step-by-step instructions for deploying PraisonAI agents to Amazon Web Services (AWS), offering multiple deployment options to suit different requirements.
+
+## Prerequisites
+
+- AWS account with appropriate permissions
+- AWS CLI installed and configured
+- Docker installed on your local machine (for container-based deployments)
+- Basic knowledge of AWS services and cloud deployment
+
+## Deployment Options
+
+There are several ways to deploy PraisonAI agents to AWS:
+
+1. **AWS Lambda with API Gateway** (for serverless deployments)
+2. **Amazon ECS/Fargate** (for containerized deployments)
+3. **Amazon EC2** (for traditional VM-based deployments)
+4. **AWS App Runner** (for simplified container deployments)
+
+## Option 1: Deploying to EC2 (Traditional VM)
+
+<Steps>
+    <Step title="Launch an EC2 Instance">
+        1. Go to the AWS Management Console
+        2. Navigate to EC2 and click "Launch Instance"
+        3. Choose Amazon Linux 2 or Ubuntu Server
+        4. Select an instance type (t2.micro for testing, t2.medium or larger for production)
+        5. Configure security groups to allow HTTP/HTTPS traffic
+        6. Launch the instance and connect to it via SSH
+    </Step>
+
+    <Step title="Set Up the Environment">
+        ```bash
+        # Update system packages
+        sudo apt update && sudo apt upgrade -y
+        
+        # Install Python and pip
+        sudo apt install -y python3 python3-pip
+        
+        # Install required packages
+        pip3 install "praisonaiagents[api]>=0.0.79"
+        ```
+    </Step>
+
+    <Step title="Create the API Application">
+        Create a file named `api.py`:
+        
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=8080, host="0.0.0.0")
+        ```
+    </Step>
+
+    <Step title="Set Up a Systemd Service">
+        Create a systemd service file to run your application as a background service:
+        
+        ```bash
+        sudo nano /etc/systemd/system/praisonai-agent.service
+        ```
+        
+        Add the following content:
+        
+        ```ini
+        [Unit]
+        Description=PraisonAI Agent API Service
+        After=network.target
+
+        [Service]
+        User=ubuntu
+        WorkingDirectory=/home/ubuntu
+        Environment="OPENAI_API_KEY=your_api_key"
+        ExecStart=/usr/bin/python3 /home/ubuntu/api.py
+        Restart=always
+
+        [Install]
+        WantedBy=multi-user.target
+        ```
+        
+        Enable and start the service:
+        
+        ```bash
+        sudo systemctl daemon-reload
+        sudo systemctl enable praisonai-agent
+        sudo systemctl start praisonai-agent
+        ```
+    </Step>
+
+    <Step title="Set Up Nginx as a Reverse Proxy">
+        ```bash
+        # Install Nginx
+        sudo apt install -y nginx
+        
+        # Create a configuration file
+        sudo nano /etc/nginx/sites-available/praisonai-agent
+        ```
+        
+        Add the following configuration:
+        
+        ```nginx
+        server {
+            listen 80;
+            server_name your_domain.com;
+
+            location / {
+                proxy_pass http://localhost:8080;
+                proxy_set_header Host $host;
+                proxy_set_header X-Real-IP $remote_addr;
+                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+                proxy_set_header X-Forwarded-Proto $scheme;
+            }
+        }
+        ```
+        
+        Enable the site and restart Nginx:
+        
+        ```bash
+        sudo ln -s /etc/nginx/sites-available/praisonai-agent /etc/nginx/sites-enabled/
+        sudo nginx -t
+        sudo systemctl restart nginx
+        ```
+    </Step>
+</Steps>
+
+## Option 2: Deploying with Docker and ECS/Fargate
+
+<Steps>
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        # Install dependencies
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        # Copy application code
+        COPY . .
+
+        # Run the application
+        CMD ["python", "api.py"]
+        ```
+        
+        Create a `requirements.txt` file:
+        ```
+        praisonaiagents[api]>=0.0.79
+        ```
+        
+        Create your `api.py` file:
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=8080, host="0.0.0.0")
+        ```
+    </Step>
+
+    <Step title="Build and Push the Docker Image to ECR">
+        ```bash
+        # Create an ECR repository
+        aws ecr create-repository --repository-name praisonai-agent
+        
+        # Get the login command
+        aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com
+        
+        # Build the Docker image
+        docker build -t praisonai-agent .
+        
+        # Tag the image
+        docker tag praisonai-agent:latest YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/praisonai-agent:latest
+        
+        # Push the image to ECR
+        docker push YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/praisonai-agent:latest
+        ```
+    </Step>
+
+    <Step title="Create an ECS Cluster and Task Definition">
+        ```bash
+        # Create an ECS cluster
+        aws ecs create-cluster --cluster-name praisonai-cluster
+        
+        # Create a task definition (JSON file)
+        cat > task-definition.json << EOF
+        {
+          "family": "praisonai-agent",
+          "networkMode": "awsvpc",
+          "executionRoleArn": "arn:aws:iam::YOUR_AWS_ACCOUNT_ID:role/ecsTaskExecutionRole",
+          "containerDefinitions": [
+            {
+              "name": "praisonai-agent",
+              "image": "YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/praisonai-agent:latest",
+              "essential": true,
+              "portMappings": [
+                {
+                  "containerPort": 8080,
+                  "hostPort": 8080,
+                  "protocol": "tcp"
+                }
+              ],
+              "environment": [
+                {
+                  "name": "OPENAI_API_KEY",
+                  "value": "your_api_key"
+                }
+              ],
+              "logConfiguration": {
+                "logDriver": "awslogs",
+                "options": {
+                  "awslogs-group": "/ecs/praisonai-agent",
+                  "awslogs-region": "us-east-1",
+                  "awslogs-stream-prefix": "ecs"
+                }
+              }
+            }
+          ],
+          "requiresCompatibilities": [
+            "FARGATE"
+          ],
+          "cpu": "256",
+          "memory": "512"
+        }
+        EOF
+        
+        # Register the task definition
+        aws ecs register-task-definition --cli-input-json file://task-definition.json
+        ```
+    </Step>
+
+    <Step title="Create a Fargate Service">
+        ```bash
+        # Create a service
+        aws ecs create-service \
+          --cluster praisonai-cluster \
+          --service-name praisonai-service \
+          --task-definition praisonai-agent:1 \
+          --desired-count 1 \
+          --launch-type FARGATE \
+          --network-configuration "awsvpcConfiguration={subnets=[subnet-12345678],securityGroups=[sg-12345678],assignPublicIp=ENABLED}" \
+          --load-balancers "targetGroupArn=arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/praisonai-tg/1234567890abcdef,containerName=praisonai-agent,containerPort=8080"
+        ```
+        
+        Note: You'll need to create an Application Load Balancer and target group before running this command.
+    </Step>
+</Steps>
+
+## Multi-Agent Deployment
+
+For deploying multiple agents, you can use a single service with different endpoints:
+
+```python
+# multi-agent-api.py
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=8080, host="0.0.0.0")
+stock_agent.launch(path="/stock", port=8080, host="0.0.0.0")
+travel_agent.launch(path="/travel", port=8080, host="0.0.0.0")
+```
+
+## Option 3: Serverless Deployment with AWS Lambda
+
+For lightweight agents that don't require long-running processes, you can use AWS Lambda with API Gateway:
+
+```python
+# lambda_function.py
+from praisonaiagents import Agent
+import json
+
+# Initialize the agent outside the handler for better cold start performance
+agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+
+def lambda_handler(event, context):
+    try:
+        # Extract the message from the event
+        body = json.loads(event.get('body', '{}'))
+        message = body.get('message', '')
+        
+        # Process the message with the agent
+        response = agent.process(message)
+        
+        # Return the response
+        return {
+            'statusCode': 200,
+            'headers': {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*'
+            },
+            'body': json.dumps({
+                'response': response
+            })
+        }
+    except Exception as e:
+        return {
+            'statusCode': 500,
+            'headers': {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*'
+            },
+            'body': json.dumps({
+                'error': str(e)
+            })
+        }
+```
+
+## Scaling and Performance
+
+### Auto Scaling
+
+For EC2 deployments, set up an Auto Scaling group:
+
+```bash
+# Create a launch template
+aws ec2 create-launch-template \
+  --launch-template-name praisonai-template \
+  --version-description "Initial version" \
+  --launch-template-data '{"ImageId":"ami-12345678","InstanceType":"t2.medium","UserData":"#!/bin/bash\ncd /home/ubuntu\npython3 api.py &"}'  
+
+# Create an Auto Scaling group
+aws autoscaling create-auto-scaling-group \
+  --auto-scaling-group-name praisonai-asg \
+  --launch-template "LaunchTemplateName=praisonai-template,Version=1" \
+  --min-size 1 \
+  --max-size 5 \
+  --desired-capacity 2 \
+  --vpc-zone-identifier "subnet-12345678,subnet-87654321" \
+  --target-group-arns "arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/praisonai-tg/1234567890abcdef"
+```
+
+### Load Balancing
+
+Set up an Application Load Balancer to distribute traffic:
+
+```bash
+# Create a load balancer
+aws elbv2 create-load-balancer \
+  --name praisonai-alb \
+  --subnets subnet-12345678 subnet-87654321 \
+  --security-groups sg-12345678
+
+# Create a target group
+aws elbv2 create-target-group \
+  --name praisonai-tg \
+  --protocol HTTP \
+  --port 8080 \
+  --vpc-id vpc-12345678 \
+  --target-type instance
+
+# Create a listener
+aws elbv2 create-listener \
+  --load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:loadbalancer/app/praisonai-alb/1234567890abcdef \
+  --protocol HTTP \
+  --port 80 \
+  --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/praisonai-tg/1234567890abcdef
+```
+
+## Security Best Practices
+
+1. **Secret Management**: Use AWS Secrets Manager for API keys
+   ```bash
+   # Store a secret
+   aws secretsmanager create-secret \
+     --name OPENAI_API_KEY \
+     --secret-string "your_api_key"
+   ```
+
+2. **IAM Roles**: Use the principle of least privilege
+3. **VPC**: Deploy in a private subnet with controlled access
+4. **WAF**: Set up AWS WAF to protect against common web exploits
+5. **API Gateway**: Implement request validation and throttling
+
+## Monitoring and Logging
+
+1. **CloudWatch**: Set up dashboards and alarms
+   ```bash
+   # Create a CloudWatch alarm for high CPU utilization
+   aws cloudwatch put-metric-alarm \
+     --alarm-name praisonai-high-cpu \
+     --alarm-description "Alarm when CPU exceeds 80%" \
+     --metric-name CPUUtilization \
+     --namespace AWS/EC2 \
+     --statistic Average \
+     --period 300 \
+     --threshold 80 \
+     --comparison-operator GreaterThanThreshold \
+     --dimensions Name=AutoScalingGroupName,Value=praisonai-asg \
+     --evaluation-periods 2 \
+     --alarm-actions arn:aws:sns:us-east-1:YOUR_AWS_ACCOUNT_ID:praisonai-alerts
+   ```
+
+2. **X-Ray**: Enable tracing for detailed request analysis
+3. **CloudTrail**: Monitor API calls for security analysis
+4. **Log Insights**: Query and analyze logs with CloudWatch Log Insights

docs/deploy/deploy.mdx

@@ -0,0 +1,223 @@
+---
+title: "Deploying PraisonAI Agents as APIs"
+sidebarTitle: "API Deployment"
+description: "Learn how to deploy PraisonAI agents as RESTful APIs for production environments"
+icon: "server"
+---
+
+PraisonAI agents can be easily deployed as RESTful APIs, allowing you to integrate them into various applications and services. This guide covers how to deploy both single and multiple agents as APIs.
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Dependencies">
+        Make sure you have the required packages installed:
+        ```bash
+        pip install "praisonaiagents[api]"
+        ```
+    </Step>
+    <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY="your_api_key"
+        ```
+    </Step>
+    <Step title="Deploy a Simple Agent API">
+        Create a file named `simple-api.py` with the following code:
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=3030)
+        ```
+    </Step>
+    <Step title="Run the API Server">
+        ```bash
+        python simple-api.py
+        ```
+        
+        Your API will be available at `http://localhost:3030/ask`
+    </Step>
+</Steps>
+
+## Making API Requests
+
+Once your agent is deployed, you can make POST requests to interact with it:
+
+```bash
+curl -X POST http://localhost:3030/ask \
+  -H "Content-Type: application/json" \
+  -d '{"message": "What is artificial intelligence?"}'
+```
+
+The response will be in JSON format:
+
+```json
+{
+  "response": "Artificial intelligence (AI) refers to the simulation of human intelligence in machines that are programmed to think and learn like humans. It encompasses various technologies including machine learning, natural language processing, computer vision, and robotics. AI systems can perform tasks that typically require human intelligence such as understanding natural language, recognizing patterns, solving problems, and making decisions."
+}
+```
+
+## Multi-Agent API Deployment
+
+You can deploy multiple agents on the same server, each with its own endpoint:
+
+```python
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=3030)
+stock_agent.launch(path="/stock", port=3030)
+travel_agent.launch(path="/travel", port=3030) 
+```
+
+With this setup, you can access:
+- Weather agent at `http://localhost:3030/weather`
+- Stock agent at `http://localhost:3030/stock`
+- Travel agent at `http://localhost:3030/travel`
+
+## Production Deployment Options
+
+For production environments, consider the following deployment options:
+
+### Docker Deployment
+
+<Steps>
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        COPY . .
+
+        EXPOSE 3030
+
+        CMD ["python", "api.py"]
+        ```
+    </Step>
+    <Step title="Create requirements.txt">
+        ```
+        praisonaiagents[api]>=0.0.79
+        ```
+    </Step>
+    <Step title="Build and Run Docker Container">
+        ```bash
+        docker build -t praisonai-api .
+        docker run -p 3030:3030 -e OPENAI_API_KEY=your_api_key praisonai-api
+        ```
+    </Step>
+</Steps>
+
+### Cloud Deployment
+
+#### Deploying to AWS
+
+<Steps>
+    <Step title="Create an EC2 Instance">
+        Launch an EC2 instance with Ubuntu or Amazon Linux.
+    </Step>
+    <Step title="Install Dependencies">
+        ```bash
+        sudo apt update
+        sudo apt install -y python3-pip
+        pip install "praisonaiagents[api]"
+        ```
+    </Step>
+    <Step title="Configure Security Group">
+        Make sure to open port 3030 in your security group settings.
+    </Step>
+    <Step title="Run with Systemd">
+        Create a systemd service file for automatic startup and management.
+    </Step>
+</Steps>
+
+#### Deploying to Google Cloud Run
+
+<Steps>
+    <Step title="Build Docker Image">
+        ```bash
+        docker build -t gcr.io/your-project/praisonai-api .
+        ```
+    </Step>
+    <Step title="Push to Container Registry">
+        ```bash
+        docker push gcr.io/your-project/praisonai-api
+        ```
+    </Step>
+    <Step title="Deploy to Cloud Run">
+        ```bash
+        gcloud run deploy praisonai-api \
+          --image gcr.io/your-project/praisonai-api \
+          --platform managed \
+          --allow-unauthenticated \
+          --set-env-vars="OPENAI_API_KEY=your_api_key"
+        ```
+    </Step>
+</Steps>
+
+## API Configuration Options
+
+When launching your agent as an API, you can customize various parameters:
+
+```python
+agent.launch(
+    path="/custom-endpoint",  # API endpoint path
+    port=8080,                # Port number
+    host="0.0.0.0",           # Host address (0.0.0.0 for external access)
+    debug=True,               # Enable debug mode
+    cors_origins=["*"],       # CORS configuration
+    api_key="your-api-key"    # Optional API key for authentication
+)
+```
+
+## Securing Your API
+
+For production deployments, consider implementing:
+
+1. **API Key Authentication**: Require API keys for all requests
+2. **Rate Limiting**: Limit the number of requests per client
+3. **HTTPS**: Use SSL/TLS certificates for encrypted communication
+4. **Input Validation**: Validate all input data before processing
+
+## Monitoring and Scaling
+
+For production environments, consider:
+
+1. **Load Balancing**: Distribute traffic across multiple instances
+2. **Auto-Scaling**: Automatically adjust resources based on demand
+3. **Logging**: Implement comprehensive logging for debugging
+4. **Monitoring**: Set up alerts for errors and performance issues
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="RESTful API" icon="server">
+    Deploy your agents as standard RESTful APIs for easy integration.
+  </Card>
+  <Card title="Multi-Agent Support" icon="users">
+    Deploy multiple agents with different endpoints on the same server.
+  </Card>
+  <Card title="Customizable" icon="gear">
+    Configure ports, paths, CORS settings, and more.
+  </Card>
+  <Card title="Production-Ready" icon="rocket">
+    Easily deploy to Docker, AWS, Google Cloud, or other cloud platforms.
+  </Card>
+</CardGroup>

docs/deploy/googlecloud.mdx

@@ -0,0 +1,248 @@
+---
+title: "Deploying to Google Cloud"
+sidebarTitle: "Google Cloud"
+description: "Deploy PraisonAI agents to Google Cloud Platform for scalable production environments"
+icon: "google"
+---
+
+# Deploying PraisonAI Agents to Google Cloud
+
+This guide provides step-by-step instructions for deploying PraisonAI agents to Google Cloud Platform using Cloud Run, which offers a serverless environment for containerized applications.
+
+## Prerequisites
+
+- Google Cloud account with billing enabled
+- Google Cloud SDK installed and configured
+- Docker installed on your local machine
+- Basic knowledge of containerization and cloud deployment
+
+## Deployment Options
+
+There are several ways to deploy PraisonAI agents to Google Cloud:
+
+1. **Google Cloud Run** (recommended for most use cases)
+2. **Google Compute Engine** (for custom VM requirements)
+3. **Google Kubernetes Engine** (for complex, scalable deployments)
+
+This guide focuses on Cloud Run as it's the simplest and most cost-effective option for most deployments.
+
+## Deploying to Google Cloud Run
+
+<Steps>
+    <Step title="Prepare Your Application">
+        Create a simple API file named `api.py`:
+
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=8080, host="0.0.0.0")
+        ```
+
+        Note: Cloud Run expects your application to listen on the port defined by the `PORT` environment variable, which defaults to 8080.
+    </Step>
+
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        # Install dependencies
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        # Copy application code
+        COPY . .
+
+        # Set environment variables
+        ENV PORT=8080
+
+        # Run the application
+        CMD exec python api.py
+        ```
+
+        Create a `requirements.txt` file:
+        ```
+        praisonaiagents[api]>=0.0.79
+        ```
+    </Step>
+
+    <Step title="Build and Push the Docker Image">
+        ```bash
+        # Build the Docker image
+        docker build -t gcr.io/YOUR_PROJECT_ID/praisonai-agent .
+
+        # Configure Docker to use Google Cloud credentials
+        gcloud auth configure-docker
+
+        # Push the image to Google Container Registry
+        docker push gcr.io/YOUR_PROJECT_ID/praisonai-agent
+        ```
+    </Step>
+
+    <Step title="Deploy to Cloud Run">
+        ```bash
+        gcloud run deploy praisonai-agent \
+          --image gcr.io/YOUR_PROJECT_ID/praisonai-agent \
+          --platform managed \
+          --region us-central1 \
+          --allow-unauthenticated \
+          --set-env-vars="OPENAI_API_KEY=your_api_key"
+        ```
+
+        Note: For production deployments, it's recommended to use Secret Manager for API keys instead of environment variables.
+    </Step>
+</Steps>
+
+## Multi-Agent Deployment
+
+For deploying multiple agents, you can use a single Cloud Run service with different endpoints:
+
+```python
+# multi-agent-api.py
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=8080, host="0.0.0.0")
+stock_agent.launch(path="/stock", port=8080, host="0.0.0.0")
+travel_agent.launch(path="/travel", port=8080, host="0.0.0.0")
+```
+
+## Scaling and Performance
+
+Google Cloud Run automatically scales based on traffic, from zero to many instances. You can configure:
+
+- **Minimum instances**: Keep a certain number of instances warm to avoid cold starts
+- **Maximum instances**: Limit the number of instances to control costs
+- **Memory allocation**: Allocate more memory for complex agents
+- **CPU allocation**: Allocate dedicated CPUs for compute-intensive workloads
+
+```bash
+gcloud run services update praisonai-agent \
+  --min-instances=1 \
+  --max-instances=10 \
+  --memory=2Gi \
+  --cpu=1
+```
+
+## Continuous Deployment
+
+Set up continuous deployment with Cloud Build:
+
+```yaml
+# cloudbuild.yaml
+steps:
+  # Build the container image
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['build', '-t', 'gcr.io/$PROJECT_ID/praisonai-agent', '.']
+  # Push the container image to Container Registry
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['push', 'gcr.io/$PROJECT_ID/praisonai-agent']
+  # Deploy container image to Cloud Run
+  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
+    entrypoint: gcloud
+    args:
+    - 'run'
+    - 'deploy'
+    - 'praisonai-agent'
+    - '--image'
+    - 'gcr.io/$PROJECT_ID/praisonai-agent'
+    - '--region'
+    - 'us-central1'
+    - '--platform'
+    - 'managed'
+    - '--allow-unauthenticated'
+substitutions:
+  _REGION: us-central1
+images:
+  - 'gcr.io/$PROJECT_ID/praisonai-agent'
+```
+
+## Monitoring and Logging
+
+Google Cloud provides comprehensive monitoring and logging capabilities:
+
+- **Cloud Monitoring**: Set up dashboards and alerts for your deployed agents
+- **Cloud Logging**: View and analyze logs from your applications
+- **Error Reporting**: Automatically detect and group errors
+
+Access logs through the Google Cloud Console or using the gcloud command:
+
+```bash
+gcloud logging read "resource.type=cloud_run_revision AND resource.labels.service_name=praisonai-agent" --limit=10
+```
+
+## Cost Optimization
+
+Cloud Run charges based on the resources your service uses only when it's processing requests. To optimize costs:
+
+1. Set appropriate memory and CPU allocations
+2. Configure minimum instances based on traffic patterns
+3. Use regional deployments closest to your users
+4. Implement caching for frequent requests
+
+## Security Best Practices
+
+1. **Secret Management**: Store API keys and credentials in Secret Manager
+   ```bash
+   # Create a secret
+   echo -n "your_api_key" | gcloud secrets create openai-api-key --data-file=-
+   
+   # Grant access to the Cloud Run service
+   gcloud secrets add-iam-policy-binding openai-api-key \
+     --member=serviceAccount:YOUR_SERVICE_ACCOUNT \
+     --role=roles/secretmanager.secretAccessor
+   
+   # Reference in deployment
+   gcloud run deploy praisonai-agent \
+     --image gcr.io/YOUR_PROJECT_ID/praisonai-agent \
+     --set-secrets=OPENAI_API_KEY=openai-api-key:latest
+   ```
+
+2. **Service Identity**: Use dedicated service accounts with minimal permissions
+3. **Network Security**: Configure VPC Service Controls for sensitive deployments
+4. **API Authentication**: Implement authentication for your API endpoints
+
+## All in One 
+
+```bash
+gcloud init
+gcloud services enable run.googleapis.com
+gcloud services enable containerregistry.googleapis.com
+gcloud services enable cloudbuild.googleapis.com
+
+export OPENAI_MODEL_NAME="gpt-4o"
+export OPENAI_API_KEY="Enter your API key"
+export OPENAI_API_BASE="https://api.openai.com/v1"
+
+yes | gcloud auth configure-docker us-central1-docker.pkg.dev 
+gcloud artifacts repositories create praisonai-repository --repository-format=docker --location=us-central1
+
+PROJECT_ID=$(gcloud config get-value project)
+TAG="latest"
+docker build --platform linux/amd64 -t gcr.io/${PROJECT_ID}/praisonai-app:${TAG} .
+docker tag gcr.io/${PROJECT_ID}/praisonai-app:${TAG} us-central1-docker.pkg.dev/${PROJECT_ID}/praisonai-repository/praisonai-app:${TAG}
+docker push us-central1-docker.pkg.dev/${PROJECT_ID}/praisonai-repository/praisonai-app:${TAG}
+
+gcloud run deploy praisonai-service \
+    --image us-central1-docker.pkg.dev/${PROJECT_ID}/praisonai-repository/praisonai-app:${TAG} \
+    --platform managed \
+    --region us-central1 \
+    --allow-unauthenticated \
+    --set-env-vars OPENAI_MODEL_NAME=${OPENAI_MODEL_NAME},OPENAI_API_KEY=${OPENAI_API_KEY},OPENAI_API_BASE=${OPENAI_API_BASE}
+```

docs/deploy/mcp-server-deploy.mdx

@@ -0,0 +1,405 @@
+---
+title: "Deploying MCP Servers"
+sidebarTitle: "MCP Servers"
+description: "Learn how to deploy Model Context Protocol (MCP) servers for production environments"
+icon: "server-rack"
+---
+
+# Deploying MCP Servers
+
+This guide focuses on deploying Model Context Protocol (MCP) servers for production environments. MCP servers allow AI models to access tools and external systems through a standardized protocol.
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Dependencies">
+        Make sure you have the required packages installed:
+        ```bash
+        pip install "praisonaiagents[mcp]"
+        ```
+        
+        For the multi-agent example with search capabilities:
+        ```bash
+        pip install "praisonaiagents[mcp]" duckduckgo-search
+        ```
+    </Step>
+    <Step title="Create MCP Server Files">
+        **Single Agent MCP Server**
+        
+        Create a file named `simple-mcp-server.py`:
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="Create a Tweet based on the topic provided")
+        agent.launch(port=8080, host="0.0.0.0", protocol="mcp")
+        ```
+        
+        **Multi-Agent MCP Server with Custom Tools**
+
+        Create a file named `simple-mcp-multi-agents-server.py`:
+        ```python
+        from praisonaiagents import Agent, Agents
+        from duckduckgo_search import DDGS
+
+        def internet_search_tool(query: str):
+            results = []
+            ddgs = DDGS()
+            for result in ddgs.text(keywords=query, max_results=5):
+                results.append({
+                    "title": result.get("title", ""),
+                    "url": result.get("href", ""),
+                    "snippet": result.get("body", "")
+                })
+            return results
+
+        agent = Agent(instructions="You Search the internet for information", tools=[internet_search_tool])
+        agent2 = Agent(instructions="You Summarise the information")
+
+        agents = Agents(agents=[agent, agent2])
+        agents.launch(port=8080, host="0.0.0.0", protocol="mcp")
+        ```
+        
+        **Simple Multi-Agent MCP Server**
+        
+        Create a file named `simple-multi-agents-server.py`:
+        ```python
+        from praisonaiagents import Agent, Agents
+
+        agent = Agent(instructions="You Search the internet for information")
+        agent2 = Agent(instructions="You Summarise the information")
+
+        agents = Agents(agents=[agent, agent2])
+        agents.launch(port=8080, host="0.0.0.0", protocol="mcp")
+        ```
+        ```python
+        from praisonaiagents import Agent, Agents
+        from duckduckgo_search import DDGS
+
+        def internet_search_tool(query: str):
+            results = []
+            ddgs = DDGS()
+            for result in ddgs.text(keywords=query, max_results=5):
+                results.append({
+                    "title": result.get("title", ""),
+                    "url": result.get("href", ""),
+                    "snippet": result.get("body", "")
+                })
+            return results
+
+        agent = Agent(instructions="You Search the internet for information", tools=[internet_search_tool])
+        agent2 = Agent(instructions="You Summarise the information")
+
+        agents = Agents(agents=[agent, agent2])
+        agents.launch(port=8080, host="0.0.0.0", protocol="mcp")
+        ```
+    </Step>
+</Steps>
+
+## Containerization with Docker
+
+<Steps>
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        # Install dependencies
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        # Copy application code
+        COPY . .
+
+        # Expose the port
+        EXPOSE 8080
+
+        # Run the MCP server
+        CMD ["python", "simple-mcp-server.py"]
+        ```
+        
+        Create a `requirements.txt` file:
+        ```
+        praisonaiagents[mcp]
+        duckduckgo-search  # Only needed for the multi-agent example
+        ```
+    </Step>
+    <Step title="Build and Run the Docker Container">
+        ```bash
+        # Build the Docker image
+        docker build -t mcp-server .
+
+        # Run the container
+        docker run -p 8080:8080 -e OPENAI_API_KEY=your_api_key mcp-server
+        ```
+    </Step>
+</Steps>
+
+## Cloud Deployment
+
+### AWS Elastic Container Service (ECS)
+
+<Steps>
+    <Step title="Push Docker Image to ECR">
+        ```bash
+        # Create an ECR repository
+        aws ecr create-repository --repository-name mcp-server
+        
+        # Authenticate Docker to ECR
+        aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com
+        
+        # Tag and push the image
+        docker tag mcp-server:latest YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/mcp-server:latest
+        docker push YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/mcp-server:latest
+        ```
+    </Step>
+    <Step title="Create ECS Task Definition">
+        ```json
+        {
+          "family": "mcp-server",
+          "networkMode": "awsvpc",
+          "executionRoleArn": "arn:aws:iam::YOUR_AWS_ACCOUNT_ID:role/ecsTaskExecutionRole",
+          "containerDefinitions": [
+            {
+              "name": "mcp-server",
+              "image": "YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/mcp-server:latest",
+              "essential": true,
+              "portMappings": [
+                {
+                  "containerPort": 8080,
+                  "hostPort": 8080,
+                  "protocol": "tcp"
+                }
+              ],
+              "environment": [
+                {
+                  "name": "OPENAI_API_KEY",
+                  "value": "your_api_key"
+                }
+              ],
+              "logConfiguration": {
+                "logDriver": "awslogs",
+                "options": {
+                  "awslogs-group": "/ecs/mcp-server",
+                  "awslogs-region": "us-east-1",
+                  "awslogs-stream-prefix": "ecs"
+                }
+              }
+            }
+          ],
+          "requiresCompatibilities": [
+            "FARGATE"
+          ],
+          "cpu": "256",
+          "memory": "512"
+        }
+        ```
+    </Step>
+    <Step title="Deploy to ECS">
+        ```bash
+        # Create a service
+        aws ecs create-service \
+          --cluster your-cluster \
+          --service-name mcp-server \
+          --task-definition mcp-server:1 \
+          --desired-count 1 \
+          --launch-type FARGATE \
+          --network-configuration "awsvpcConfiguration={subnets=[subnet-12345678],securityGroups=[sg-12345678],assignPublicIp=ENABLED}" \
+          --load-balancers "targetGroupArn=arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/mcp-server-tg/1234567890abcdef,containerName=mcp-server,containerPort=8080"
+        ```
+    </Step>
+</Steps>
+
+### Google Cloud Run
+
+<Steps>
+    <Step title="Push Docker Image to Google Container Registry">
+        ```bash
+        # Configure Docker to use Google Cloud credentials
+        gcloud auth configure-docker
+        
+        # Build and tag the image
+        docker build -t gcr.io/YOUR_PROJECT_ID/mcp-server .
+        
+        # Push the image
+        docker push gcr.io/YOUR_PROJECT_ID/mcp-server
+        ```
+    </Step>
+    <Step title="Deploy to Cloud Run">
+        ```bash
+        gcloud run deploy mcp-server \
+          --image gcr.io/YOUR_PROJECT_ID/mcp-server \
+          --platform managed \
+          --region us-central1 \
+          --allow-unauthenticated \
+          --set-env-vars="OPENAI_API_KEY=your_api_key"
+        ```
+    </Step>
+</Steps>
+
+## Production Configuration
+
+### Security
+
+For production deployments, implement these security measures:
+
+1. **API Key Authentication**:
+   ```python
+   agent.launch(port=8080, host="0.0.0.0", protocol="mcp", api_key="your-secret-key")
+   ```
+
+2. **HTTPS with SSL/TLS**:
+   Set up a reverse proxy like Nginx with SSL certificates:
+   ```nginx
+   server {
+       listen 443 ssl;
+       server_name your-mcp-server.com;
+       
+       ssl_certificate /path/to/cert.pem;
+       ssl_certificate_key /path/to/key.pem;
+       
+       location / {
+           proxy_pass http://localhost:8080;
+           proxy_set_header Host $host;
+           proxy_set_header X-Real-IP $remote_addr;
+       }
+   }
+   ```
+
+3. **Secret Management**:
+   Use environment variables or a secrets manager for API keys:
+   ```bash
+   # AWS Secrets Manager
+   aws secretsmanager create-secret \
+     --name OPENAI_API_KEY \
+     --secret-string "your_api_key"
+   
+   # Google Secret Manager
+   echo -n "your_api_key" | gcloud secrets create openai-api-key --data-file=-
+   ```
+
+### Scaling
+
+For high-traffic MCP servers, consider these scaling strategies:
+
+1. **Load Balancing**:
+   Deploy multiple instances behind a load balancer.
+
+2. **Auto Scaling**:
+   Configure auto-scaling based on CPU/memory usage or request count.
+
+3. **Resource Allocation**:
+   Allocate sufficient CPU and memory for your MCP servers:
+   ```bash
+   # AWS ECS
+   aws ecs update-service \
+     --cluster your-cluster \
+     --service mcp-server \
+     --desired-count 3
+   
+   # Google Cloud Run
+   gcloud run services update mcp-server \
+     --min-instances=2 \
+     --max-instances=10 \
+     --memory=2Gi \
+     --cpu=1
+   ```
+
+## Monitoring and Logging
+
+Set up comprehensive monitoring for your MCP servers:
+
+1. **Application Logging**:
+   ```python
+   import logging
+   
+   logging.basicConfig(
+       level=logging.INFO,
+       format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+       handlers=[
+           logging.FileHandler("mcp-server.log"),
+           logging.StreamHandler()
+       ]
+   )
+   
+   logger = logging.getLogger("mcp-server")
+   ```
+
+2. **Health Checks**:
+   Create a health check endpoint:
+   ```python
+   from flask import Flask
+   
+   app = Flask(__name__)
+   
+   @app.route('/health')
+   def health_check():
+       return {"status": "healthy"}, 200
+   
+   if __name__ == "__main__":
+       app.run(host="0.0.0.0", port=8081)
+   ```
+
+3. **Metrics Collection**:
+   Use Prometheus or similar tools to collect metrics.
+
+## Testing MCP Servers
+
+Before deploying to production, thoroughly test your MCP server:
+
+```python
+import requests
+import json
+
+def test_mcp_server():
+    url = "http://localhost:8080/v1/chat/completions"
+    
+    headers = {
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "messages": [
+            {"role": "user", "content": "Create a tweet about artificial intelligence"}
+        ]
+    }
+    
+    response = requests.post(url, headers=headers, data=json.dumps(data))
+    
+    print(f"Status Code: {response.status_code}")
+    print(f"Response: {response.json()}")
+
+if __name__ == "__main__":
+    test_mcp_server()
+```
+
+## Deployment Checklist
+
+Before going live with your MCP server, ensure you've addressed these items:
+
+- [ ] Implemented proper authentication
+- [ ] Set up HTTPS with valid SSL certificates
+- [ ] Configured proper logging and monitoring
+- [ ] Tested the server under load
+- [ ] Implemented rate limiting
+- [ ] Secured all API keys and credentials
+- [ ] Set up automated backups
+- [ ] Created a disaster recovery plan
+- [ ] Documented the deployment process
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Containerized Deployment" icon="docker">
+    Package your MCP servers in Docker containers for consistent deployment.
+  </Card>
+  <Card title="Cloud-Ready" icon="cloud">
+    Deploy to AWS, Google Cloud, or other cloud providers with ease.
+  </Card>
+  <Card title="Scalable Architecture" icon="server">
+    Scale your MCP servers to handle production workloads.
+  </Card>
+  <Card title="Security-Focused" icon="shield">
+    Implement best practices for secure MCP server deployments.
+  </Card>
+</CardGroup>

docs/deploy/multi-agents-deploy.mdx

@@ -0,0 +1,210 @@
+---
+title: "Deploying Multi-Agent Systems as APIs"
+sidebarTitle: "Multi-Agent Deployment"
+description: "Learn how to deploy PraisonAI multi-agent systems as RESTful APIs for production environments"
+icon: "network-wired"
+---
+
+# Deploying Multi-Agent Systems as APIs
+
+PraisonAI allows you to deploy sophisticated multi-agent systems as RESTful APIs, enabling seamless integration with various applications and services. This guide covers different approaches to deploying multi-agent systems.
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Dependencies">
+        Make sure you have the required packages installed:
+        ```bash
+        pip install "praisonaiagents[api]>=0.0.81"
+        ```
+    </Step>
+    <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY="your_api_key"
+        ```
+    </Step>
+    <Step title="Deploy a Multi-Agent System">
+        Create a file named `multi-agents-api.py` with the following code:
+        ```python
+        from praisonaiagents import Agent, Agents, Tools
+
+        research_agent = Agent(name="Research", instructions="You are a research agent to search internet about AI 2024", tools=[Tools.internet_search])
+        summarise_agent = Agent(name="Summarise", instructions="You are a summarize agent to summarise in points")
+        agents = Agents(agents=[research_agent, summarise_agent])
+        agents.launch(path="/agents", port=3030)
+        ```
+    </Step>
+    <Step title="Run the API Server">
+        ```bash
+        python multi-agents-api.py
+        ```
+        
+        Your multi-agent API will be available at `http://localhost:3030/agents`
+    </Step>
+</Steps>
+
+## Making API Requests
+
+Once your multi-agent system is deployed, you can make POST requests to interact with it:
+
+```bash
+curl -X POST http://localhost:3030/agents \
+  -H "Content-Type: application/json" \
+  -d '{"message": "What are the latest developments in AI in 2024?"}'
+```
+
+The response will include the collaborative output from both the research and summarization agents:
+
+```json
+{
+  "response": "# Latest AI Developments in 2024\n\n- Multimodal AI models have become mainstream, combining text, image, audio, and video understanding\n- Significant advancements in AI reasoning capabilities with models like GPT-4o and Claude 3\n- Increased focus on AI alignment and safety research\n- Emergence of specialized AI agents for specific domains\n- Growth in open-source AI models and frameworks\n- Regulatory frameworks for AI being established globally"
+}
+```
+
+## Multiple Agent Groups
+
+You can deploy multiple agent groups on the same server, each with its own endpoint:
+
+```python
+from praisonaiagents import Agent, Agents, Tools
+
+research_agent = Agent(name="Research", instructions="You are a research agent to search internet about AI 2024", tools=[Tools.internet_search])
+summarise_agent = Agent(name="Summarise", instructions="You are a summarize agent to summarise in points")
+agents = Agents(agents=[research_agent, summarise_agent])
+agents2 = Agents(agents=[research_agent])
+agents.launch(path="/agents", port=3030)
+agents2.launch(path="/agents2", port=3030)
+```
+
+With this setup, you can access:
+- The full agent group at `http://localhost:3030/agents`
+- Just the research agent at `http://localhost:3030/agents2`
+
+## Independent Multi-Agent Deployment
+
+You can also deploy multiple independent agents on the same server:
+
+```python
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=3030)
+stock_agent.launch(path="/stock", port=3030)
+travel_agent.launch(path="/travel", port=3030) 
+```
+
+## Production Deployment Options
+
+For production environments, consider the following deployment options:
+
+### Docker Deployment
+
+<Steps>
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        COPY . .
+
+        EXPOSE 3030
+
+        CMD ["python", "multi-agents-api.py"]
+        ```
+    </Step>
+    <Step title="Create requirements.txt">
+        ```
+        praisonaiagents[api]>=0.0.81
+        ```
+    </Step>
+    <Step title="Build and Run Docker Container">
+        ```bash
+        docker build -t praisonai-multi-agent .
+        docker run -p 3030:3030 -e OPENAI_API_KEY=your_api_key praisonai-multi-agent
+        ```
+    </Step>
+</Steps>
+
+### Cloud Deployment
+
+For detailed cloud deployment instructions, refer to:
+- [AWS Deployment Guide](/deploy/aws)
+- [Google Cloud Deployment Guide](/deploy/googlecloud)
+
+## Scaling Multi-Agent Systems
+
+When deploying multi-agent systems to production, consider these scaling strategies:
+
+1. **Horizontal Scaling**: Deploy multiple instances behind a load balancer
+2. **Vertical Scaling**: Allocate more CPU and memory resources for complex agent interactions
+3. **Caching**: Implement response caching for frequently asked questions
+4. **Asynchronous Processing**: Use message queues for handling long-running agent tasks
+
+## API Configuration Options
+
+When launching your multi-agent system as an API, you can customize various parameters:
+
+```python
+agents.launch(
+    path="/custom-endpoint",  # API endpoint path
+    port=8080,                # Port number
+    host="0.0.0.0",           # Host address (0.0.0.0 for external access)
+    debug=True,               # Enable debug mode
+    cors_origins=["*"],       # CORS configuration
+    api_key="your-api-key"    # Optional API key for authentication
+)
+```
+
+## Securing Your Multi-Agent API
+
+For production deployments, consider implementing:
+
+1. **API Key Authentication**: Require API keys for all requests
+2. **Rate Limiting**: Limit the number of requests per client
+3. **HTTPS**: Use SSL/TLS certificates for encrypted communication
+4. **Input Validation**: Validate all input data before processing
+5. **Output Filtering**: Implement content filtering for agent responses
+
+## Monitoring and Logging
+
+For production environments, consider:
+
+1. **Centralized Logging**: Collect logs from all agents in a central location
+2. **Performance Metrics**: Track response times and resource usage
+3. **Error Tracking**: Monitor and alert on agent failures
+4. **Usage Analytics**: Track which agents are used most frequently
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Collaborative Agents" icon="users-gear">
+    Deploy agent systems that collaborate to solve complex problems.
+  </Card>
+  <Card title="Specialized Endpoints" icon="sitemap">
+    Create dedicated endpoints for different agent groups or individual agents.
+  </Card>
+  <Card title="Tool Integration" icon="screwdriver-wrench">
+    Deploy agents with specialized tools like web search capabilities.
+  </Card>
+  <Card title="Scalable Architecture" icon="server">
+    Scale your multi-agent systems to handle production workloads.
+  </Card>
+</CardGroup>

docs/developers/local-development.mdx

@@ -0,0 +1,75 @@
+---
+title: 'Local Development'
+description: 'Set up local development environment with Docker and live reload'
+---
+
+## Logging
+```bash
+export LOGLEVEL=info
+```
+
+Advanced logging:
+```bash
+export LOGLEVEL=debug
+```
+
+## Local Docker Development with Live Reload
+
+To facilitate local development with live reload, you can use Docker. Follow the steps below:
+
+### 1. Create Dockerfile.dev
+
+<CodeGroup>
+```dockerfile Dockerfile.dev
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY . .
+
+RUN pip install flask praisonai==2.2.1 watchdog
+
+EXPOSE 5555
+
+ENV FLASK_ENV=development
+
+CMD ["flask", "run", "--host=0.0.0.0"]
+```
+</CodeGroup>
+
+### 2. Create docker-compose.yml
+
+<CodeGroup>
+```yaml docker-compose.yml
+version: '3.8'
+
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile.dev
+    volumes:
+      - .:/app
+    ports:
+      - "5555:5555"
+    environment:
+      FLASK_ENV: development
+    command: flask run --host=0.0.0.0
+
+  watch:
+    image: alpine:latest
+    volumes:
+      - .:/app
+    command: sh -c "apk add --no-cache inotify-tools && while inotifywait -r -e modify,create,delete /app; do kill -HUP 1; done"
+```
+</CodeGroup>
+
+### 3. Run Docker Compose
+
+<CodeGroup>
+```bash Terminal
+docker-compose up
+```
+</CodeGroup>
+
+This setup will allow you to develop locally with live reload, making it easier to test and iterate on your code.

docs/developers/wrapper.mdx

@@ -65,14 +65,14 @@ def basic(): # Basic Mode
 def advanced(): # Advanced Mode with options
     praisonai = PraisonAI(
         agent_file="agents.yaml",
-        framework="autogen",
+        framework="autogen", # use AG2 framework (Formerly AutoGen)
     )
     praisonai.run()
     
 def auto(): # Full Automatic Mode
     praisonai = PraisonAI(
         auto="Create a movie script about car in mars",
-        framework="autogen"
+        framework="autogen" # use AG2 framework
     )
     print(praisonai.framework)
     praisonai.run()

docs/features/chat-with-pdf.mdx

@@ -0,0 +1,244 @@
+---
+title: "Chat with PDF Agents"
+sidebarTitle: "Chat with PDF"
+description: "Learn how to create AI agents that can intelligently chat with PDF documents using vector databases for efficient information retrieval."
+icon: "file-pdf"
+---
+
+```mermaid
+flowchart LR
+    PDF[PDF Document] --> PDFAgent[("PDF Chat Agent")]
+    VDB[(Vector DB)] --> PDFAgent
+    PDFAgent --> Chat[Chat Interface]
+    Chat --> |Query| VDB
+    Chat --> Out[Response]
+    
+    style PDF fill:#8B0000,color:#fff
+    style PDFAgent fill:#2E8B57,color:#fff,shape:circle
+    style VDB fill:#4169E1,color:#fff,shape:cylinder
+    style Chat fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A PDF-centric workflow where Chat agents interact with vector databases to store and retrieve information from PDF documents, enabling natural conversations and intelligent question-answering capabilities.
+
+## Quick Start
+
+<Steps>
+  <Step title="Install Package">
+    Install PraisonAI Agents with PDF chat 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 `chat_with_pdf.py`:
+```python
+from praisonaiagents import Agent
+
+agent = Agent(
+    name="PDF Chat Agent",
+    instructions="You answer questions based on the provided PDF document.",
+    knowledge=["document.pdf"], # PDF Indexing
+)
+
+agent.start("What is the main topic of this PDF?") # Chat Query
+```
+  </Step>
+</Steps>
+
+## PDF Processing and Chat Agents 
+
+<Note>
+  PDF processing involves indexing the document content for efficient retrieval during chat.
+</Note>
+
+```mermaid
+flowchart LR
+    subgraph In[Input]
+        PDF[PDF Documents]
+    end
+
+    subgraph Router[Vector Store]
+        DB[(Vector DB)]
+    end
+    
+    subgraph Out[Chat Agents]
+        A1[Chat Agent 1]
+        A2[Chat Agent 2]
+        A3[Chat 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
+```
+
+The simplest way to create a PDF chat agent is without any configuration:
+
+```python
+from praisonaiagents import Agent
+
+agent = Agent(
+    name="PDF Chat Agent",
+    instructions="You answer questions based on the provided PDF document.",
+    knowledge=["document.pdf"] # PDF Indexing
+)
+
+agent.start("What are the key points in this document?") # Chat Query
+```
+
+### 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": "praison",
+            "path": ".praison",
+        }
+    }
+}
+
+agent = Agent(
+    name="PDF Chat Agent",
+    instructions="You answer questions based on the provided PDF document.",
+    knowledge=["document.pdf"], # PDF Indexing
+    knowledge_config=config # Configuration
+)
+
+agent.start("What is the main topic of this PDF?") # Chat Query
+```
+
+### 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": "praison",
+            "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"], # Indexing
+    knowledge_config=config, # Configuration
+    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 # Agent
+)
+
+# Create and start the agents
+agents = PraisonAIAgents(
+    agents=[knowledge_agent],
+    tasks=[knowledge_task],
+    process="sequential",
+    user_id="user1" # User ID
+)
+
+# Start execution
+result = agents.start() # Retrieval
+```
+
+## Understanding PDF Chat Agents
+
+<Card title="What are PDF Chat Agents?" icon="question">
+  PDF Chat agents enable:
+  - Natural conversation with PDF documents
+  - Intelligent information extraction
+  - Context-aware document understanding
+  - Quick answers to document-specific questions
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="PDF Processing" icon="file-pdf">
+    Process and index PDF documents efficiently.
+  </Card>
+  <Card title="Natural Chat" icon="comments">
+    Have natural conversations about PDF content.
+  </Card>
+  <Card title="Smart Retrieval" icon="brain">
+    Intelligently retrieve relevant information from PDFs.
+  </Card>
+  <Card title="Context Awareness" icon="layer-group">
+    Maintain context throughout the conversation.
+  </Card>
+</CardGroup>
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="PDF Issues" icon="triangle-exclamation">
+    If PDF processing isn't working:
+    - Check PDF file format and encoding
+    - Verify document accessibility
+    - Enable verbose mode for debugging
+  </Card>
+
+  <Card title="Chat Issues" icon="gauge-high">
+    If chat responses aren't accurate:
+    - Check PDF indexing quality
+    - Verify question clarity
+    - Monitor context retention
+  </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 chat experience, ensure your PDFs are properly formatted and text-searchable.
+</Note>

docs/features/cli.mdx

@@ -0,0 +1,117 @@
+---
+title: "Command Line Interface"
+sidebarTitle: "CLI"
+description: "Use PraisonAI directly from your terminal with simple commands"
+icon: "terminal"
+---
+
+```mermaid
+flowchart LR
+    Start((🚀)) --> CLI[CLI Command]
+    CLI --> Agent[AI Agent]
+    Agent --> Config[Config/YAML]
+    Config --> Out((🏁))
+    
+    style Start fill:#8B0000,color:#fff,stroke:#8B0000
+    style CLI fill:#2E8B57,color:#fff
+    style Agent fill:#2E8B57,color:#fff
+    style Config fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff,stroke:#8B0000
+```
+
+PraisonAI CLI provides a simple way to interact with AI agents directly from your terminal. You can run quick commands, specify LLM options, or use YAML configuration files for more complex scenarios.
+
+<Frame>
+  <img src="../demo/praisonai-cli-demo.gif" alt="PraisonAI CLI Demo" />
+</Frame>
+
+## Quick Start
+
+<Steps>
+  <Step title="Install Package">
+    Install the PraisonAI package:
+    ```bash
+    pip install praisonai
+    ```
+  </Step>
+
+  <Step title="Set API Key">
+    Set your OpenAI API key as an environment variable:
+    ```bash
+    export OPENAI_API_KEY=your_api_key_here
+    ```
+  </Step>
+</Steps>
+
+## Usage Examples
+
+<AccordionGroup>
+  <Accordion title="Simple Command" icon="terminal" defaultOpen>
+    Run a simple command directly:
+    ```bash
+    praisonai "write a movie script in 3 lines"
+    ```
+  </Accordion>
+
+  <Accordion title="With LLM Option" icon="wand-magic-sparkles" defaultOpen>
+    Specify a different LLM model:
+    ```bash
+    praisonai "write a movie script in 3 lines" --llm gpt-4o-mini
+    ```
+  </Accordion>
+
+  <Accordion title="Using YAML Config" icon="file-code" defaultOpen>
+    Run agents defined in a YAML file:
+    ```bash
+    praisonai agents.yaml
+    ```
+  </Accordion>
+</AccordionGroup>
+
+## Configuration
+
+<Tabs>
+  <Tab title="Create Config">
+    Initialize a new agents.yaml file for your project:
+    ```bash
+    praisonai --init "Create a movie script about AI"
+    ```
+    This will create an `agents.yaml` file with predefined configuration for your task.
+  </Tab>
+
+  <Tab title="Auto Mode">
+    Let PraisonAI automatically create and configure agents:
+    ```bash
+    praisonai --auto "Create a movie script about AI"
+    ```
+    This mode will analyze your task and set up appropriate agents automatically.
+  </Tab>
+</Tabs>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Simple Commands" icon="terminal">
+    Run AI tasks directly from your terminal with simple commands.
+  </Card>
+  <Card title="LLM Options" icon="wand-magic-sparkles">
+    Choose from different LLM models for your specific needs.
+  </Card>
+  <Card title="YAML Support" icon="file-code">
+    Use YAML files for complex agent configurations and workflows.
+  </Card>
+  <Card title="Auto Configuration" icon="robot">
+    Automatic agent setup based on task requirements.
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup>
+  <Card title="YAML Configuration" icon="file-code" href="/config">
+    Learn more about YAML configuration options
+  </Card>
+  <Card title="API Reference" icon="code" href="/api-reference">
+    View the complete API documentation
+  </Card>
+</CardGroup>

docs/features/generate-reasoning.mdx

@@ -0,0 +1,298 @@
+---
+title: "Generate Synthetic Reasoning Data Agents"
+sidebarTitle: "Generate Reasoning Data"
+description: "Learn how to generate chain-of-thought reasoning data using PraisonAI Agents."
+icon: "brain"
+---
+
+```mermaid
+flowchart TD
+    Start[Start] --> Generator[Question Answer Generator Agent]
+    Generator --> Evaluator[Evaluator Agent]
+    Evaluator --> COT[Reasoning Steps / COT Generator Agent]
+    COT --> COT
+    COT --> Upload[HuggingFace Uploader Agent]
+    Upload --> End[End]
+    
+    style Start fill:#8B0000,color:#fff
+    style Generator fill:#2E8B57,color:#fff
+    style Evaluator fill:#2E8B57,color:#fff
+    style COT fill:#2E8B57,color:#fff
+    style Upload fill:#2E8B57,color:#fff
+    style End fill:#8B0000,color:#fff
+```
+
+## What is Chain-of-Thought Generation?
+
+Chain-of-Thought (CoT) Generation is a process where AI agents create detailed, step-by-step reasoning paths for solving problems. This involves generating questions, evaluating them, producing detailed solution steps, and making the data available for training and analysis.
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Package">
+        First, install the PraisonAI Agents package:
+        ```bash
+        pip install "praisonaiagents[llm]" datasets huggingface-hub pandas
+        ```
+    </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
+        export HF_TOKEN=your_huggingface_token_here
+        ```
+    </Step>
+
+    <Step title="Create a file">
+        Create a new file `app.py` with the basic setup:
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import cot_save, cot_upload_to_huggingface
+from pydantic import BaseModel
+import os
+
+# Define Pydantic model for structured output
+class DecisionModel(BaseModel):
+    response: str
+    decision: str
+
+def write_csv(file_path, data):
+    """Write data to CSV file."""
+    if not os.path.exists(file_path):
+        with open(file_path, 'w') as file:
+            file.write(data + '\n')
+    else:
+        with open(file_path, 'a') as file:
+            file.write(data + '\n')
+    return f"Data appended to {file_path}"
+
+def count_questions(file_path):
+    """Count lines in file."""
+    with open(file_path, 'r') as file:
+        return sum(1 for _ in file)
+
+# Create specialized agents
+qa_generator = Agent(
+    name="Generator",
+    role="Question Creator",
+    goal="Create challenging math and logic questions",
+    backstory="Expert in educational content creation",
+    llm="gpt-4o-mini",
+    tools=[write_csv, count_questions]
+)
+
+total_questions_evaluator = Agent(
+    name="TotalQuestionsEvaluator",
+    role="Total Questions Evaluator",
+    goal="Evaluate the total number of questions in qa_pairs.csv file",
+    backstory="Expert in evaluating the total number of questions in a file",
+    llm="gpt-4o-mini",
+    tools=[count_questions],
+    verbose=False
+)
+
+cot_generator = Agent(
+    name="COTGenerator",
+    role="Chain of Thought Specialist",
+    goal="Generate and manage chain of thought solutions for Q&A pairs",
+    backstory="Expert in breaking down problems and generating detailed solution steps",
+    tools=[cot_save],
+    llm="gpt-4o-mini",
+    verbose=False
+)
+
+upload_to_huggingface = Agent(
+    name="UploadToHuggingface",
+    role="Upload to Huggingface",
+    goal="Upload the generated chain of thought solutions to a Huggingface dataset",
+    backstory="Expert in saving data to Huggingface",
+    tools=[cot_upload_to_huggingface],
+    llm="gpt-4o-mini",
+    verbose=False
+)
+
+# Define tasks with workflow
+generate_task = Task(
+    description="""Generate question and answer in csv format without headers: question, answer and append to qa_pairs.csv file
+generate 10 unique questions and answers and don't repeat on the same question and answer. Reponse with 'done' when done
+with append mode as 'a'
+Example question and answer:
+question, answer
+What is the sum of numbers from 1 to 10?, 55
+Number of r's in the word strawberry, 3
+""",
+    expected_output="append to qa_pairs.csv file with questions and answers and move to next task",
+    agent=qa_generator,
+    name="generate_task",
+    is_start=True,
+    next_tasks=["evaluate_total_questions"],
+    task_type="decision",
+    condition={
+        "more": "generate_task",
+        "done": "evaluate_total_questions"
+    }
+)
+
+evaluate_total_questions_task = Task(
+    description="Evaluate the total number of questions in qa_pairs.csv file is 1",
+    expected_output="Total number of questions in qa_pairs.csv file",
+    agent=total_questions_evaluator,
+    task_type="decision",
+    name="evaluate_total_questions",
+    condition={
+        "more": "generate_task",
+        "done": "generate_cot"
+    }
+)
+
+generate_cot_task = Task(
+    name="generate_cot",
+    description="""Generate chain of thought solutions for each question in the input file. 
+Save to cot_solutions.csv file
+Don't generate chain of thought solutions again after receiving the response from Tool Call
+After calling the tool, respond with a JSON object:
+{
+    "response": "done",
+    "decision": "done"
+}
+""",
+    expected_output="done",
+    agent=cot_generator,
+    input_file="qa_pairs.csv",
+    task_type="loop",
+    next_tasks=["upload_to_huggingface"],
+    condition={
+        "done": ["upload_to_huggingface"],
+        "exit": [],
+    },
+    output_pydantic=DecisionModel  # Use Pydantic model for output validation
+)
+
+upload_to_huggingface_task = Task(
+    name="upload_to_huggingface",
+    description="""Upload to Huggingface:
+    1. Save to cot_solutions.csv
+    2. Upload to mervinpraison/cot-dataset""",
+    expected_output="Dataset published successfully",
+    agent=upload_to_huggingface,
+    tools=[cot_upload_to_huggingface]
+)
+
+# Initialize workflow
+agents = PraisonAIAgents(
+    agents=[qa_generator, total_questions_evaluator, cot_generator, upload_to_huggingface],
+    tasks=[generate_task, evaluate_total_questions_task, generate_cot_task, upload_to_huggingface_task],
+    process="workflow",
+    max_iter=30,
+    verbose=False
+)
+
+agents.start()
+```
+    </Step>
+
+    <Step title="Run the application">
+        Execute the Python script to start generating chain-of-thought data:
+        ```bash
+        python app.py
+        ```
+    </Step>
+
+</Steps>
+
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Question Generation" icon="question">
+    Create challenging math and logic questions with answers.
+  </Card>
+  <Card title="Question Evaluation" icon="check-double">
+    Evaluate and validate generated questions for quality.
+  </Card>
+  <Card title="CoT Solutions" icon="diagram-project">
+    Generate detailed chain-of-thought solutions for each question.
+  </Card>
+  <Card title="Data Management" icon="database">
+    Save and manage generated data in structured formats.
+  </Card>
+  <Card title="HuggingFace Integration" icon="cloud-arrow-up">
+    Upload datasets directly to HuggingFace for sharing.
+  </Card>
+</CardGroup>
+
+## Understanding the Workflow
+
+<AccordionGroup>
+  <Accordion title="Key Components">
+    <CardGroup cols={2}>
+      <Card title="Question Generator" icon="robot">
+        Creates unique math and logic questions with answers. Uses `write_csv` and `count_questions` tools.
+      </Card>
+      <Card title="Questions Evaluator" icon="magnifying-glass-chart">
+        Validates the total number of generated questions. Uses `count_questions` tool.
+      </Card>
+      <Card title="CoT Generator" icon="diagram-project">
+        Produces detailed step-by-step solutions. Uses `cot_save` tool for solution management.
+      </Card>
+      <Card title="HuggingFace Uploader" icon="cloud-arrow-up">
+        Publishes datasets to HuggingFace. Uses `cot_upload_to_huggingface` tool.
+      </Card>
+    </CardGroup>
+  </Accordion>
+
+  <Accordion title="Task Types and Flow Control">
+    <Tabs>
+      <Tab title="Decision Tasks">
+        Used in question generation and evaluation phases.
+        
+        ```python Decision Task Example
+        generate_task = Task(
+            task_type="decision",
+            condition={
+                "more": "generate_task",
+                "done": "evaluate_total_questions"
+            }
+        )
+        ```
+
+        <Note>
+          Conditions determine whether to continue generating or move forward. The task can loop back to itself or proceed to the next task.
+        </Note>
+      </Tab>
+      <Tab title="Loop Tasks">
+        Used in Chain-of-Thought generation phase.
+        
+        ```python Loop Task Example
+        generate_cot_task = Task(
+            task_type="loop",
+            input_file="qa_pairs.csv",
+            output_pydantic=DecisionModel
+        )
+        ```
+
+        <Warning>
+          Always use Pydantic models for output validation in loop tasks to ensure data consistency.
+        </Warning>
+      </Tab>
+    </Tabs>
+
+    <Info>
+      Each task type serves a specific purpose in the workflow:
+      - **Decision Tasks**: Control flow and branching logic
+      - **Loop Tasks**: Process data iteratively with validation
+    </Info>
+  </Accordion>
+</AccordionGroup>
+
+## Next Steps
+
+<CardGroup>
+  <Card title="Introduction" icon="book" href="/introduction">
+    Learn more about PraisonAI and its core concepts
+  </Card>
+  <Card title="Quick Start" icon="bolt" href="/quickstart">
+    Get started with the basics of PraisonAI
+  </Card>
+</CardGroup>

docs/features/image-generation.mdx

@@ -0,0 +1,126 @@
+---
+title: "Image Generation AI Agents"
+sidebarTitle: "Image Generation"
+description: "Generate high-quality images using PraisonAI Image Agents with both synchronous and asynchronous capabilities."
+icon: "image"
+---
+
+```mermaid
+flowchart LR
+    In[Start] --> Process[Image Description]
+    Process --> Agent[Image Agent]
+    Agent --> Out[Image URL]
+    
+    style In fill:#8B0000,color:#fff
+    style Process fill:#2E8B57,color:#fff
+    style Agent fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+Image Generation in PraisonAI allows you to create high-quality images using natural language descriptions. The Image Agent supports both synchronous and asynchronous operations, making it flexible for various use cases.
+
+## Quick Start
+
+<Tabs>
+  <Tab title="Code">
+    <Steps>
+      <Step title="Install Package">
+        First, install the PraisonAI Agents package with LLM support:
+        ```bash
+        pip install "praisonaiagents[llm]"
+        ```
+      </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 Agent">
+        Create a new file `image_gen.py` with the basic setup:
+        ```python
+        from praisonaiagents.agent.image_agent import ImageAgent
+
+        # Create an image agent
+        agent = ImageAgent(
+            llm="dall-e-3",
+            verbose=True
+        )
+
+        # Generate an image
+        result = agent.chat("A cute baby sea otter playing with a laptop")
+        print("Image generation result:", result)
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+
+  <Tab title="Async">
+    <Steps>
+      <Step title="Install Package">
+        First, install the PraisonAI Agents package with LLM support:
+        ```bash
+        pip install "praisonaiagents[llm]"
+        ```
+      </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 Async Agent">
+        Create a new file `image_gen_async.py` with the async setup:
+        ```python
+        import asyncio
+        from praisonaiagents import ImageAgent
+
+        async def main():
+            agent = ImageAgent(
+                name="ImageCreator",
+                llm="dall-e-3",
+                style="natural"
+            )
+
+            result = await agent.achat("A cute baby sea otter playing with a laptop")
+            print(f"Image generation result: {result}")
+
+        if __name__ == "__main__":
+            asyncio.run(main())
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="DALL-E Integration" icon="image">
+    Seamless integration with DALL-E for high-quality image generation.
+  </Card>
+  <Card title="Async Support" icon="bolt">
+    Asynchronous operations for better performance in concurrent environments.
+  </Card>
+  <Card title="Natural Style" icon="paintbrush">
+    Generate images with natural, realistic styling options.
+  </Card>
+  <Card title="Verbose Mode" icon="message">
+    Detailed output logging for better debugging and monitoring.
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup>
+  <Card title="Agents Overview" icon="robot" href="/agents">
+    Learn more about PraisonAI Agents and their capabilities
+  </Card>
+  <Card title="API Reference" icon="code" href="/api-reference">
+    View the complete API documentation
+  </Card>
+</CardGroup>

docs/features/reasoning-extract.mdx

@@ -0,0 +1,137 @@
+---
+title: "Reasoning Extract Agents"
+description: "Learn how to create AI agents that can perform step-by-step reasoning and extract information"
+icon: "brain-circuit"
+---
+
+```mermaid
+flowchart LR
+    In[Input] --> RA[("Reasoning Agent")]
+    RA --> Steps[Reasoning Steps]
+    Steps --> SA[("Small Agent")]
+    SA --> Out[Output]
+    
+    style In fill:#8B0000,color:#fff
+    style RA fill:#2E8B57,color:#fff,shape:circle
+    style Steps fill:#4169E1,color:#fff
+    style SA fill:#2E8B57,color:#fff,shape:circle
+    style Out fill:#8B0000,color:#fff
+```
+
+A workflow where a reasoning agent breaks down complex problems into steps, followed by a smaller agent that processes these steps to provide concise answers.
+
+## Prerequisites
+
+<Steps>
+    <Step title="Install Package">
+        Install required packages:
+        ```bash
+        pip install "praisonaiagents[llm]"
+        ```
+
+        <Note>
+        praisonaiagents[llm] includes all necessary dependencies for reasoning agents
+        </Note>
+    </Step>
+
+    <Step title="Set API Key">
+        Configure your API key:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+    </Step>
+
+    <Step title="Create File">
+        Create a new file called `app.py` and add the following code:
+    </Step>
+
+    <Step title="Run Application">
+        Execute the script:
+        ```bash
+        python app.py
+        ```
+    </Step>
+</Steps>
+
+## Code
+
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+reasoning_agent = Agent(
+    role="Helpful Assistant", 
+    reasoning_steps=True, 
+    llm="deepseek/deepseek-reasoner"
+)
+
+small_agent = Agent(
+    role="Helpful Assistant", 
+    llm="gpt-3.5-turbo"
+)
+
+reasoning_task = Task(
+    description="How many r's in the word 'Strawberry'?", 
+    agent=reasoning_agent
+)
+
+small_task = Task(
+    description="With the provided reasoning tell me how many r's in the word 'Strawberry'?", 
+    agent=small_agent
+)
+
+agents = PraisonAIAgents(
+    agents=[reasoning_agent, small_agent],
+    tasks=[reasoning_task, small_task]
+)
+
+agents.start()
+```
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Step-by-Step Reasoning" icon="list-check">
+    Break down complex problems into logical steps.
+  </Card>
+  <Card title="Multi-Agent Collaboration" icon="users">
+    Combine reasoning and processing agents.
+  </Card>
+  <Card title="Flexible Models" icon="arrows-split-up-and-left">
+    Use different models for reasoning and processing.
+  </Card>
+  <Card title="Task Chaining" icon="link">
+    Connect reasoning output to processing tasks.
+  </Card>
+</CardGroup>
+
+## Understanding Reasoning Agents
+
+<Card title="What are Reasoning Agents?" icon="question">
+  Reasoning agents enable:
+  - Detailed step-by-step analysis
+  - Logical problem decomposition
+  - Clear reasoning paths
+  - Enhanced decision making
+</Card>
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Reasoning Issues" icon="triangle-exclamation">
+    If reasoning steps aren't clear:
+    - Check reasoning_steps parameter
+    - Verify model compatibility
+    - Review task descriptions
+  </Card>
+
+  <Card title="Agent Communication" icon="messages">
+    If agents aren't coordinating:
+    - Ensure task order is correct
+    - Check task dependencies
+    - Verify agent configurations
+  </Card>
+</CardGroup>
+
+<Note>
+  The reasoning agent uses a specialized model (deepseek-reasoner) optimized for step-by-step analysis, while the small agent can use a more general-purpose model for processing the reasoning output.
+</Note>

docs/framework/autogen.mdx

@@ -1,12 +1,13 @@
 ---
-title: "AutoGen with PraisonAI"
-description: "Guide for using AutoGen framework with PraisonAI, including installation, setup, and multi-agent conversation capabilities"
+title: "AG2 with PraisonAI"
+description: "Guide for using AG2 framework with PraisonAI, including installation, setup, and multi-agent conversation capabilities"
 icon: "robot"
 ---
 
-# AutoGen with PraisonAI
+# AG2 with PraisonAI
 
-Low-code solution to run AutoGen with integrated tools and features.
+Low-code solution to run AG2 with integrated tools and features.
+AutoGen is being evolved into AG2, check the new look [here](https://docs.ag2.ai/docs/Home/)
 
 ## Installation
 
@@ -16,7 +17,7 @@ pip install "praisonai[autogen]"
 ```
 
 This installation includes:
-- AutoGen framework
+- AG2 framework
 - PraisonAI tools integration
 - Multi-agent conversation capabilities
 - Code execution environment
@@ -27,7 +28,7 @@ This installation includes:
 # Set your OpenAI API key
 export OPENAI_API_KEY=xxxxxxxxxx
 
-# Initialize with AutoGen
+# Initialize with AG2
 praisonai --framework autogen --init "Create a Movie Script About Cat in Mars"
 
 # Run the agents

docs/home.mdx

@@ -1,7 +1,7 @@
 ---
 title: "Praison AI"
 sidebarTitle: "Home"
-description: "Comprehensive guide to PraisonAI - an AI Agents Framework with Self Reflection, combining PraisonAI Agents, AutoGen, and CrewAI for building multi-agent LLM systems"
+description: "Comprehensive guide to PraisonAI - an AI Agents Framework with Self Reflection, combining PraisonAI Agents, AG2 (Formerly AutoGen), and CrewAI for building multi-agent LLM systems"
 icon: "house"
 openGraph:
   url: "/"
@@ -46,7 +46,7 @@ seo:
 </div>
 
 <Tip>
-  PraisonAI combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customization, and efficient human-agent collaboration.
+  PraisonAI combines PraisonAI Agents, AG2 (Formerly AutoGen), and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customization, and efficient human-agent collaboration.
 </Tip>
 
 ## Key Features
@@ -56,7 +56,7 @@ seo:
     Automated creation and management of AI agents with self-reflection capabilities
   </Card>
   <Card title="Framework Integration" icon="puzzle-piece">
-    Seamless integration with CrewAI and AutoGen frameworks
+    Seamless integration with CrewAI and AG2 frameworks
   </Card>
   <Card title="LLM Support" icon="brain">
     Support for 100+ Language Learning Models
@@ -301,8 +301,8 @@ seo:
   <Card title="CrewAI Framework" icon="users-gear" href="/framework/crewai">
     Build collaborative AI teams with CrewAI integration
   </Card>
-  <Card title="AutoGen Framework" icon="robot" href="/framework/autogen">
-    Create autonomous agent networks using AutoGen
+  <Card title="AG2 Framework" icon="robot" href="/framework/autogen">
+    Create autonomous agent networks using AG2 (Formerly AutoGen)
   </Card>
   <Card title="Multimodal Agents" icon="icons" href="/framework/multimodalagents">
     Work with agents that can process text, images, and other data types
@@ -316,7 +316,7 @@ seo:
 
 <CardGroup cols={3}>
   <Card title="Multi Agents UI" icon="users" href="/ui/ui">
-    Work with CrewAI or AutoGen multi-agent systems
+    Work with CrewAI or AG2 multi-agent systems
   </Card>
   <Card title="Chat Interface" icon="comments" href="/ui/chat">
     Chat with 100+ LLMs using a single AI Agent

docs/index.mdx

@@ -1,7 +1,7 @@
 ---
 title: "Praison AI"
 sidebarTitle: "Home"
-description: "Comprehensive guide to PraisonAI - an AI Agents Framework with Self Reflection, combining PraisonAI Agents, AutoGen, and CrewAI for building multi-agent LLM systems"
+description: "PraisonAI is a production-ready Multi-AI Agents framework with self-reflection, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. By integrating PraisonAI Agents, AG2 (Formerly AutoGen), and CrewAI into a low-code solution, it streamlines the building and management of multi-agent LLM systems, emphasising simplicity, customisation, and effective human-agent collaboration."
 icon: "house"
 openGraph:
   url: "/"
@@ -45,7 +45,7 @@ seo:
     Automated creation and management of AI agents with self-reflection capabilities
   </Card>
   <Card title="Framework Integration" icon="puzzle-piece">
-    Seamless integration with CrewAI and AutoGen frameworks
+    Seamless integration with CrewAI and AG2 frameworks
   </Card>
   <Card title="LLM Support" icon="brain">
     Support for 100+ Language Learning Models
@@ -66,49 +66,10 @@ seo:
     Internet search using Crawl4AI and Tavily
   </Card>
 </CardGroup>
-<br />
-<div className="relative w-full aspect-video overflow-hidden rounded-lg shadow-lg mb-8">
-  <iframe
-    className="absolute top-0 left-0 w-full h-full border-0"
-    src="https://www.youtube.com/embed/Fn1lQjC0GO0"
-    title="YouTube video player"
-    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-    allowFullScreen
-    style={{
-      maxWidth: '100vw',
-      margin: '0 auto'
-    }}
-  ></iframe>
-</div>
 
-## Installation Options
+## Install
 
 <Tabs>
-  <Tab title="No Code">
-    <Tip>
-        PraisonAI combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customization, and efficient human-agent collaboration.
-    </Tip>
-    <Steps>
-      <Step title="Install Package">
-        ```bash
-        pip install praisonai
-        ```
-      </Step>
-      <Step title="Set API Key">
-        ```bash
-        export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
-        ```
-      </Step>
-      <Step title="Auto Mode">
-        ```bash
-        praisonai --auto create a movie script about Robots in Mars
-        ```
-
-        This will automatically create required agents and complete the task
-
-      </Step>
-    </Steps>
-  </Tab>
   <Tab title="Code">
     <Steps>
       <Step title="Install Package">
@@ -127,86 +88,22 @@ seo:
         ## Code Example
 
 <CodeGroup>
-  ```python Basic
-  from praisonaiagents import Agent, Task, PraisonAIAgents
+```python Single Agent
+from praisonaiagents import Agent
 
-  # Create an agent
-  researcher = Agent(
-      name="Researcher",
-      role="Senior Research Analyst",
-      goal="Uncover cutting-edge developments in AI",
-      backstory="You are an expert at a technology research group",
-      verbose=True,
-      llm="gpt-4o"
-  )
+agent = Agent(instructions="Your are a helpful AI assistant")
+agent.start("Write a movie script about a robot in Mars")
+```
 
-  # Define a task
-  task = Task(
-      name="research_task",
-      description="Analyze 2024's AI advancements",
-      expected_output="A detailed report",
-      agent=researcher
-  )
+```python Multi Agents
+from praisonaiagents import Agent, PraisonAIAgents
 
-  # Run the agents
-  agents = PraisonAIAgents(
-      agents=[researcher],
-      tasks=[task],
-      verbose=False
-  )
+research_agent = Agent(instructions="Research about AI")
+summarise_agent = Agent(instructions="Summarise research agent's findings")
 
-  result = agents.start()
-  ```
-
-  ```python Advanced
-  from praisonaiagents import Agent, Task, PraisonAIAgents
-
-  # Create multiple agents
-  researcher = Agent(
-      name="Researcher",
-      role="Senior Research Analyst",
-      goal="Uncover cutting-edge developments in AI",
-      backstory="You are an expert at a technology research group",
-      verbose=True,
-      llm="gpt-4o",
-      markdown=True
-  )
-
-  writer = Agent(
-      name="Writer",
-      role="Tech Content Strategist",
-      goal="Craft compelling content on tech advancements",
-      backstory="You are a content strategist",
-      llm="gpt-4o",
-      markdown=True
-  )
-
-  # Define multiple tasks
-  task1 = Task(
-      name="research_task",
-      description="Analyze 2024's AI advancements",
-      expected_output="A detailed report",
-      agent=researcher
-  )
-
-  task2 = Task(
-      name="writing_task",
-      description="Create a blog post about AI advancements",
-      expected_output="A blog post",
-      agent=writer
-  )
-
-  # Run with hierarchical process
-  agents = PraisonAIAgents(
-      agents=[researcher, writer],
-      tasks=[task1, task2],
-      verbose=False,
-      process="hierarchical",
-      manager_llm="gpt-4o"
-  )
-
-  result = agents.start()
-  ```
+agents = PraisonAIAgents(agents=[research_agent, summarise_agent])
+agents.start()
+```
 </CodeGroup>
       </Step>
       <Step title="Run Script">
@@ -216,8 +113,529 @@ seo:
       </Step>
     </Steps>
   </Tab>
+  <Tab title="No Code">
+    <Steps>
+      <Step title="Install Package">
+        Install the No Code PraisonAI Package:
+        ```bash
+        pip install praisonaiagents
+        ```
+      </Step>
+
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=your_openai_key
+        ```
+      </Step>
+
+      <Step title="Create Config">
+        Create `agents.yaml`:
+
+    <CodeGroup>
+      ```yaml Single Agent
+      roles:
+        summarise_agent:
+          instructions: Summarise Photosynthesis
+      ```
+
+      ```yaml Multiple Agents
+      roles:
+        diet_agent:
+          instructions: Give me 5 healthy food recipes
+        blog_agent:
+          instructions: Write a blog post about the food recipes
+      ```
+    </CodeGroup>
+
+<Note>
+You can automatically create `agents.yaml` using:
+```bash
+praisonai --init "your task description"
+```
+</Note>
+
+      </Step>
+
+      <Step title="Run Agents">
+        Execute your config:
+        ```bash
+        praisonai agents.yaml
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+  <Tab title="JavaScript">
+    <Steps>
+      <Step title="Install Package">
+        ```bash
+        npm install praisonai
+        ```
+      </Step>
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+        ```
+      </Step>
+      <Step title="Create File">
+        Create `app.js` file
+
+        ## Code Example
+
+<CodeGroup>
+```javascript Single Agent
+const { Agent } = require('praisonai');
+const agent = new Agent({ instructions: 'You are a helpful AI assistant' });
+agent.start('Write a movie script about a robot in Mars');
+```
+
+```javascript Multi Agents
+const { Agent, PraisonAIAgents } = require('praisonai');
+
+const researchAgent = new Agent({ instructions: 'Research about AI' });
+const summariseAgent = new Agent({ instructions: 'Summarise research agent\'s findings' });
+
+const agents = new PraisonAIAgents({ agents: [researchAgent, summariseAgent] });
+agents.start();
+```
+</CodeGroup>
+      </Step>
+      <Step title="Run Script">
+        ```bash
+        node app.js
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+  <Tab title="TypeScript">
+    <Steps>
+      <Step title="Install Package">
+        <CodeGroup>
+        ```bash npm
+        npm install praisonai
+        ```
+        ```bash yarn
+        yarn add praisonai
+        ```
+        </CodeGroup>
+      </Step>
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+        ```
+      </Step>
+      <Step title="Create File">
+        Create `app.ts` file
+
+        ## Code Example
+
+<CodeGroup>
+```javascript Single Agent
+import { Agent } from 'praisonai';
+
+const agent = new Agent({ 
+  instructions: `You are a creative writer who writes short stories with emojis.`,
+  name: "StoryWriter"
+});
+
+agent.start("Write a story about a time traveler")
+```
+
+```javascript Multi Agents
+import { Agent, PraisonAIAgents } from 'praisonai';
+
+const storyAgent = new Agent({
+  instructions: "Generate a very short story (2-3 sentences) about artificial intelligence with emojis.",
+  name: "StoryAgent"
+});
+
+const summaryAgent = new Agent({
+  instructions: "Summarize the provided AI story in one sentence with emojis.",
+  name: "SummaryAgent"
+});
+
+const agents = new PraisonAIAgents({
+  agents: [storyAgent, summaryAgent]
+});
+
+agents.start()
+```
+</CodeGroup>
+      </Step>
+      <Step title="Run Script">
+        ```bash
+        npx ts-node app.ts
+        ```
+      </Step>
+    </Steps>
+  </Tab>
 </Tabs>
 
+## Playground
+
+<iframe 
+  id="codeExecutionFrame"
+  src="https://code-execution-server-praisonai.replit.app/?code=import%20openai%0A%0Aclient%20%3D%20openai.OpenAI()%0Aresult%20%3D%20client.chat.completions.create(%0A%20%20%20%20model%3D%22gpt-3.5-turbo%22%2C%0A%20%20%20%20messages%3D%5B%0A%20%20%20%20%20%20%20%20%7B%22role%22%3A%20%22user%22%2C%20%22content%22%3A%20%22Hello%20World%22%7D%0A%20%20%20%20%5D%0A)%0A%0Aprint(result.choices%5B0%5D.message.content)" 
+  width="100%" 
+  height="600px" 
+  frameborder="0"
+  allow="clipboard-read; clipboard-write"
+  scrolling="yes"
+  onload="resizeIframe(this)"
+></iframe>
+
+## AI Agents Flow
+
+```mermaid
+graph LR
+    %% Define the main flow
+    Start([▶ Start]) --> Agent1
+    Agent1 --> Process[⚙ Process]
+    Process --> Agent2
+    Agent2 --> Output([✓ Output])
+    Process -.-> Agent1
+    
+    %% Define subgraphs for agents and their tasks
+    subgraph Agent1[ ]
+        Task1[📋 Task]
+        AgentIcon1[🤖 AI Agent]
+        Tools1[🔧 Tools]
+        
+        Task1 --- AgentIcon1
+        AgentIcon1 --- Tools1
+    end
+    
+    subgraph Agent2[ ]
+        Task2[📋 Task]
+        AgentIcon2[🤖 AI Agent]
+        Tools2[🔧 Tools]
+        
+        Task2 --- AgentIcon2
+        AgentIcon2 --- Tools2
+    end
+
+    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
+```
+
+## AI Agents with Tools
+
+Create AI agents that can use tools to interact with external systems and perform actions.
+
+```mermaid
+flowchart TB
+    subgraph Tools
+        direction TB
+        T3[Internet Search]
+        T1[Code Execution]
+        T2[Formatting]
+    end
+
+    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
+```
+
+## AI Agents with Memory
+
+Create AI agents with memory capabilities for maintaining context and information across tasks.
+
+```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
+```
+
+## AI Agents with Different Processes
+
+### Sequential Process
+
+The simplest form of task execution where tasks are performed one after another.
+
+```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
+```
+
+### Hierarchical Process
+
+Uses a manager agent to coordinate task execution and agent assignments.
+
+```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
+```
+
+### Workflow Process
+
+Advanced process type supporting complex task relationships and conditional execution.
+
+```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
+```
+
+#### Agentic Routing Workflow
+
+Create AI agents that can dynamically route tasks to specialized LLM instances.
+
+```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 --> Out[Out]
+    LLM2 --> Out
+    LLM3 --> 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 Out fill:#8B0000,color:#fff
+```
+
+#### Agentic Orchestrator Worker
+
+Create AI agents that orchestrate and distribute tasks among specialized workers.
+
+```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
+```
+
+#### Agentic Autonomous Workflow
+
+Create AI agents that can autonomously monitor, act, and adapt based on environment feedback.
+
+```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
+```
+
+#### Agentic Parallelization
+
+Create AI agents that can execute tasks in parallel for improved performance.
+
+```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
+```
+
+#### Agentic Prompt Chaining
+
+Create AI agents with sequential prompt chaining for complex workflows.
+
+```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
+```
+
+#### Agentic Evaluator Optimizer
+
+Create AI agents that can generate and optimize solutions through iterative feedback.
+
+```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
+```
+
+#### Repetitive Agents
+
+Create AI agents that can efficiently handle repetitive tasks through automated loops.
+
+```mermaid
+flowchart LR
+    In[Input] --> LoopAgent[("Looping Agent")]
+    LoopAgent --> Task[Task]
+    Task --> |Next iteration| LoopAgent
+    Task --> |Done| Out[Output]
+    
+    style In fill:#8B0000,color:#fff
+    style LoopAgent fill:#2E8B57,color:#fff,shape:circle
+    style Task fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+<br />
+<div className="relative w-full aspect-video overflow-hidden rounded-lg shadow-lg mb-8">
+  <iframe
+    className="absolute top-0 left-0 w-full h-full border-0"
+    src="https://www.youtube.com/embed/Fn1lQjC0GO0"
+    title="YouTube video player"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+    allowFullScreen
+    style={{
+      maxWidth: '100vw',
+      margin: '0 auto'
+    }}
+  ></iframe>
+</div>
+
 ## Integration Options
 
 <AccordionGroup>
@@ -293,8 +711,8 @@ seo:
   <Card title="CrewAI Framework" icon="users-gear" href="/framework/crewai">
     Build collaborative AI teams with CrewAI integration
   </Card>
-  <Card title="AutoGen Framework" icon="robot" href="/framework/autogen">
-    Create autonomous agent networks using AutoGen
+  <Card title="AG2 Framework" icon="robot" href="/framework/autogen">
+    Create autonomous agent networks using AG2 (Formerly AutoGen)
   </Card>
   <Card title="Multimodal Agents" icon="icons" href="/framework/multimodalagents">
     Work with agents that can process text, images, and other data types
@@ -308,7 +726,7 @@ seo:
 
 <CardGroup cols={3}>
   <Card title="Multi Agents UI" icon="users" href="/ui/ui">
-    Work with CrewAI or AutoGen multi-agent systems
+    Work with CrewAI or AG2 multi-agent systems
   </Card>
   <Card title="Chat Interface" icon="comments" href="/ui/chat">
     Chat with 100+ LLMs using a single AI Agent
@@ -338,4 +756,31 @@ seo:
   <div className="hover:opacity-80 transition-opacity">
     <img src="https://img.shields.io/github/forks/MervinPraison/PraisonAI?style=social" alt="GitHub Forks" />
   </div>
-</div>
+</div>
+
+## Video Tutorials
+
+| Topic | Video |
+|-------|--------|
+| AI Agents with Self Reflection | [![Self Reflection](https://img.youtube.com/vi/vLXobEN2Vc8/0.jpg)](https://www.youtube.com/watch?v=vLXobEN2Vc8) |
+| Reasoning Data Generating Agent | [![Reasoning Data](https://img.youtube.com/vi/fUT332Y2zA8/0.jpg)](https://www.youtube.com/watch?v=fUT332Y2zA8) |
+| AI Agents with Reasoning | [![Reasoning](https://img.youtube.com/vi/KNDVWGN3TpM/0.jpg)](https://www.youtube.com/watch?v=KNDVWGN3TpM) |
+| Multimodal AI Agents | [![Multimodal](https://img.youtube.com/vi/hjAWmUT1qqY/0.jpg)](https://www.youtube.com/watch?v=hjAWmUT1qqY) |
+| AI Agents Workflow | [![Workflow](https://img.youtube.com/vi/yWTH44QPl2A/0.jpg)](https://www.youtube.com/watch?v=yWTH44QPl2A) |
+| Async AI Agents | [![Async](https://img.youtube.com/vi/VhVQfgo00LE/0.jpg)](https://www.youtube.com/watch?v=VhVQfgo00LE) |
+| Mini AI Agents | [![Mini](https://img.youtube.com/vi/OkvYp5aAGSg/0.jpg)](https://www.youtube.com/watch?v=OkvYp5aAGSg) |
+| AI Agents with Memory | [![Memory](https://img.youtube.com/vi/1hVfVxvPnnQ/0.jpg)](https://www.youtube.com/watch?v=1hVfVxvPnnQ) |
+| Repetitive Agents | [![Repetitive](https://img.youtube.com/vi/dAYGxsjDOPg/0.jpg)](https://www.youtube.com/watch?v=dAYGxsjDOPg) |
+| Introduction | [![Introduction](https://img.youtube.com/vi/Fn1lQjC0GO0/0.jpg)](https://www.youtube.com/watch?v=Fn1lQjC0GO0) |
+| Tools Overview | [![Tools Overview](https://img.youtube.com/vi/XaQRgRpV7jo/0.jpg)](https://www.youtube.com/watch?v=XaQRgRpV7jo) |
+| Custom Tools | [![Custom Tools](https://img.youtube.com/vi/JSU2Rndh06c/0.jpg)](https://www.youtube.com/watch?v=JSU2Rndh06c) |
+| Firecrawl Integration | [![Firecrawl](https://img.youtube.com/vi/UoqUDcLcOYo/0.jpg)](https://www.youtube.com/watch?v=UoqUDcLcOYo) |
+| User Interface | [![UI](https://img.youtube.com/vi/tg-ZjNl3OCg/0.jpg)](https://www.youtube.com/watch?v=tg-ZjNl3OCg) |
+| Crawl4AI Integration | [![Crawl4AI](https://img.youtube.com/vi/KAvuVUh0XU8/0.jpg)](https://www.youtube.com/watch?v=KAvuVUh0XU8) |
+| Chat Interface | [![Chat](https://img.youtube.com/vi/sw3uDqn2h1Y/0.jpg)](https://www.youtube.com/watch?v=sw3uDqn2h1Y) |
+| Code Interface | [![Code](https://img.youtube.com/vi/_5jQayO-MQY/0.jpg)](https://www.youtube.com/watch?v=_5jQayO-MQY) |
+| Mem0 Integration | [![Mem0](https://img.youtube.com/vi/KIGSgRxf1cY/0.jpg)](https://www.youtube.com/watch?v=KIGSgRxf1cY) |
+| Training | [![Training](https://img.youtube.com/vi/aLawE8kwCrI/0.jpg)](https://www.youtube.com/watch?v=aLawE8kwCrI) |
+| Realtime Voice Interface | [![Realtime](https://img.youtube.com/vi/frRHfevTCSw/0.jpg)](https://www.youtube.com/watch?v=frRHfevTCSw) |
+| Call Interface | [![Call](https://img.youtube.com/vi/m1cwrUG2iAk/0.jpg)](https://www.youtube.com/watch?v=m1cwrUG2iAk) |
+| Reasoning Extract Agents | [![Reasoning Extract](https://img.youtube.com/vi/2PPamsADjJA/0.jpg)](https://www.youtube.com/watch?v=2PPamsADjJA) |

docs/installation.mdx

@@ -11,6 +11,12 @@ pip install praisonaiagents
 ```bash No Code
 pip install praisonai
 ```
+```bash JavaScript
+npm install praisonai
+```
+```bash TypeScript
+npm install praisonai
+```
 </RequestExample>
 
 <Note>
@@ -90,6 +96,38 @@ Follow these steps to set up PraisonAI in your development environment.
         </Step>
     </Steps>
   </Tab>
+  <Tab title="JavaScript">
+    <Steps>
+        <Step title="Install PraisonAI">
+            Install the PraisonAI package:
+            ```bash
+            npm install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_openai_key
+            ```
+        </Step>
+    </Steps>
+  </Tab>
+  <Tab title="TypeScript">
+    <Steps>
+        <Step title="Install PraisonAI">
+            Install the PraisonAI package:
+            ```bash
+            npm install praisonai
+            ```
+        </Step>
+        <Step title="Set API Key">
+            Set your OpenAI API key as an environment variable in your terminal:
+            ```bash
+            export OPENAI_API_KEY=your_openai_key
+            ```
+        </Step>
+    </Steps>
+  </Tab>
 </Tabs>
 
 Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)

docs/introduction.mdx

@@ -89,147 +89,242 @@ graph LR
 ## Getting Started is Easy
 <Tabs>
   <Tab title="Code">
-<Steps>
+    <Steps>
+      <Step title="Install Package">
+        Install the PraisonAI Agents package:
+        ```bash
+        pip install praisonaiagents
+        ```
+      </Step>
 
-  <Step title="Install PraisonAI">
-    Install the core package:
-    ```bash Terminal
-    pip install praisonaiagents
-    ```
-  </Step>
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=your_openai_key
+        ```
+        Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys).
+        Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
+      </Step>
 
-  <Step title="Configure Environment">
-    ```bash Terminal
-    export OPENAI_API_KEY=your_openai_key
-    ```
-    Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
-    Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
-  </Step>
+      <Step title="Create Agents">
+        Create `app.py`:
+    <CodeGroup>
+      ```python Single Agent
+      from praisonaiagents import Agent, PraisonAIAgents
 
-  <Step title="Create Agent">
-    Create `app.py`:
-<CodeGroup>
-  ```python Single Agent
-  from praisonaiagents import Agent, Task, PraisonAIAgents
+      # Create a simple agent
+      summarise_agent = Agent(instructions="Summarise Photosynthesis")
 
-  # Create an agent
-  researcher = Agent(
-      name="Researcher",
-      role="Senior Research Analyst",
-      goal="Uncover cutting-edge developments in AI",
-      backstory="You are an expert at a technology research group",
-      verbose=True,
-      llm="gpt-4o"
-  )
+      # Run the agent
+      agents = PraisonAIAgents(agents=[summarise_agent])
+      agents.start()
+      ```
 
-  # Define a task
-  task = Task(
-      name="research_task",
-      description="Analyze 2024's AI advancements",
-      expected_output="A detailed report",
-      agent=researcher
-  )
+      ```python Multiple Agents
+      from praisonaiagents import Agent, PraisonAIAgents
 
-  # Run the agents
-  agents = PraisonAIAgents(
-      agents=[researcher],
-      tasks=[task],
-      verbose=False
-  )
+      # Create agents with specific roles
+      diet_agent = Agent(
+          instructions="Give me 5 healthy food recipes",
+      )
 
-  result = agents.start()
-  ```
+      blog_agent = Agent(
+          instructions="Write a blog post about the food recipes",
+      )
 
-  ```python Multiple Agents
-  from praisonaiagents import Agent, Task, PraisonAIAgents
+      # Run multiple agents
+      agents = PraisonAIAgents(agents=[diet_agent, blog_agent])
+      agents.start()
+      ```
+    </CodeGroup>
+      </Step>
 
-  # Create multiple agents
-  researcher = Agent(
-      name="Researcher",
-      role="Senior Research Analyst",
-      goal="Uncover cutting-edge developments in AI",
-      backstory="You are an expert at a technology research group",
-      verbose=True,
-      llm="gpt-4o",
-      markdown=True
-  )
+      <Step title="Run Agents">
+        Execute your script:
+        ```bash
+        python app.py
+        ```
 
-  writer = Agent(
-      name="Writer",
-      role="Tech Content Strategist",
-      goal="Craft compelling content on tech advancements",
-      backstory="You are a content strategist",
-      llm="gpt-4o",
-      markdown=True
-  )
-
-  # Define multiple tasks
-  task1 = Task(
-      name="research_task",
-      description="Analyze 2024's AI advancements",
-      expected_output="A detailed report",
-      agent=researcher
-  )
-
-  task2 = Task(
-      name="writing_task",
-      description="Create a blog post about AI advancements",
-      expected_output="A blog post",
-      agent=writer
-  )
-
-  # Run with hierarchical process
-  agents = PraisonAIAgents(
-      agents=[researcher, writer],
-      tasks=[task1, task2],
-      verbose=False,
-      process="hierarchical",
-      manager_llm="gpt-4o"
-  )
-
-  result = agents.start()
-  ```
-</CodeGroup>
-  </Step>
-
-  <Step title="Start Agents">
-    Execute your script:
-    ```bash Terminal
-    python app.py
-    ```
-  </Step>
-</Steps>
-</Tab>
+        You'll see:
+        - Agent initialization
+        - Task execution progress
+        - Final results
 
+        <Tip>
+        You have successfully CreatedAI Agents and made them work for you!
+        </Tip>
+      </Step>
+    </Steps>
+  </Tab>
   <Tab title="No Code">
     <Steps>
+      <Step title="Install Package">
+        Install the No Code PraisonAI Package:
+        ```bash
+        pip install praisonaiagents
+        ```
+      </Step>
 
-        <Step title="Install PraisonAI">
-            Install the PraisonAI package:
-            ```bash
-            pip install praisonai
-            ```
-        </Step>
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=your_openai_key
+        ```
+      </Step>
 
-        <Step title="Set API Key">
-            Set your OpenAI API key as an environment variable in your terminal:
-            ```bash Terminal
-            export OPENAI_API_KEY=your_openai_key
-            ```
-            Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)
-            Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the [Models](/models) for more information.
-        </Step>
+      <Step title="Create Config">
+        Create `agents.yaml`:
 
-        <Step title="Start AutoAgents">    
-            Run your AutoAgents:
-            ```bash
-            praisonai --auto "Create a movie script about a robot in Mars"
-            ```
-        </Step>
+    <CodeGroup>
+      ```yaml Single Agent
+      roles:
+        summarise_agent:
+          instructions: Summarise Photosynthesis
+      ```
+
+      ```yaml Multiple Agents
+      roles:
+        diet_agent:
+          instructions: Give me 5 healthy food recipes
+        blog_agent:
+          instructions: Write a blog post about the food recipes
+      ```
+    </CodeGroup>
+
+<Note>
+You can automatically create `agents.yaml` using:
+```bash
+praisonai --init "your task description"
+```
+</Note>
+
+      </Step>
+
+      <Step title="Run Agents">
+        Execute your config:
+        ```bash
+        praisonai agents.yaml
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+  <Tab title="JavaScript">
+    <Steps>
+      <Step title="Install Package">
+        ```bash
+        npm install praisonai
+        ```
+      </Step>
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+        ```
+      </Step>
+      <Step title="Create File">
+        Create `app.js` file
+
+        ## Code Example
+
+<CodeGroup>
+```javascript Single Agent
+const { Agent } = require('praisonai');
+const agent = new Agent({ instructions: 'You are a helpful AI assistant' });
+agent.start('Write a movie script about a robot in Mars');
+```
+
+```javascript Multi Agents
+const { Agent, PraisonAIAgents } = require('praisonai');
+
+const researchAgent = new Agent({ instructions: 'Research about AI' });
+const summariseAgent = new Agent({ instructions: 'Summarise research agent\'s findings' });
+
+const agents = new PraisonAIAgents({ agents: [researchAgent, summariseAgent] });
+agents.start();
+```
+</CodeGroup>
+      </Step>
+      <Step title="Run Script">
+        ```bash
+        node app.js
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+  <Tab title="TypeScript">
+    <Steps>
+      <Step title="Install Package">
+        <CodeGroup>
+        ```bash npm
+        npm install praisonai
+        ```
+        ```bash yarn
+        yarn add praisonai
+        ```
+        </CodeGroup>
+      </Step>
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+        ```
+      </Step>
+      <Step title="Create File">
+        Create `app.ts` file
+
+        ## Code Example
+
+<CodeGroup>
+```javascript Single Agent
+import { Agent } from 'praisonai';
+
+const agent = new Agent({ 
+  instructions: `You are a creative writer who writes short stories with emojis.`,
+  name: "StoryWriter"
+});
+
+agent.start("Write a story about a time traveler")
+```
+
+```javascript Multi Agents
+import { Agent, PraisonAIAgents } from 'praisonai';
+
+const storyAgent = new Agent({
+  instructions: "Generate a very short story (2-3 sentences) about artificial intelligence with emojis.",
+  name: "StoryAgent"
+});
+
+const summaryAgent = new Agent({
+  instructions: "Summarize the provided AI story in one sentence with emojis.",
+  name: "SummaryAgent"
+});
+
+const agents = new PraisonAIAgents({
+  agents: [storyAgent, summaryAgent]
+});
+
+agents.start()
+```
+</CodeGroup>
+      </Step>
+      <Step title="Run Script">
+        ```bash
+        npx ts-node app.ts
+        ```
+      </Step>
     </Steps>
   </Tab>
 </Tabs>
 
+## Playground
+
+<iframe 
+  id="codeExecutionFrame"
+  src="https://code-execution-server-praisonai.replit.app/?code=import%20openai%0A%0Aclient%20%3D%20openai.OpenAI()%0Aresult%20%3D%20client.chat.completions.create(%0A%20%20%20%20model%3D%22gpt-3.5-turbo%22%2C%0A%20%20%20%20messages%3D%5B%0A%20%20%20%20%20%20%20%20%7B%22role%22%3A%20%22user%22%2C%20%22content%22%3A%20%22Hello%20World%22%7D%0A%20%20%20%20%5D%0A)%0A%0Aprint(result.choices%5B0%5D.message.content)" 
+  width="100%" 
+  height="600px" 
+  frameborder="0"
+  allow="clipboard-read; clipboard-write"
+  scrolling="yes"
+  onload="resizeIframe(this)"
+></iframe>
+
 ## Key Features
 
 <CardGroup cols={3}>

docs/js/customtools.mdx

@@ -0,0 +1,50 @@
+---
+title: "Custom Tools for TypeScript AI Agents"
+sidebarTitle: "Custom Tools"
+description: "Learn how to create custom tools for TypeScript AI Agents"
+icon: "toolbox"
+---
+
+## Single Agent
+
+```typescript
+import { Agent } from 'praisonai';
+
+async function getWeather(location: string) {
+  console.log(`Getting weather for ${location}...`);
+  return `${Math.floor(Math.random() * 30)}°C`;
+}
+
+const agent = new Agent({ 
+  instructions: `You provide the current weather for requested locations.`,
+  name: "DirectFunctionAgent",
+  tools: [getWeather]
+});
+
+agent.start("What's the weather in Paris, France?");
+``` 
+
+## Multi Agents
+
+```typescript
+import { Agent } from 'praisonai';
+
+async function getWeather(location: string) {
+  console.log(`Getting weather for ${location}...`);
+  return `${Math.floor(Math.random() * 30)}°C`;
+}
+
+async function getTime(location: string) {
+  console.log(`Getting time for ${location}...`);
+  const now = new Date();
+  return `${now.getHours()}:${now.getMinutes()}`;
+}
+
+const agent = new Agent({ 
+  instructions: `You provide the current weather and time for requested locations.`,
+  name: "DirectFunctionAgent",
+  tools: [getWeather, getTime]
+});
+
+agent.start("What's the weather and time in Paris, France and Tokyo, Japan?");
+``` 

docs/js/development.mdx

@@ -0,0 +1,38 @@
+---
+title: "Development Setup"
+sidebarTitle: "Development"
+description: "Set up your development environment for PraisonAI JavaScript framework"
+icon: "code"
+---
+
+## Development Setup
+
+<Steps>
+  <Step title="Clone Repository">
+    ```bash
+    git clone https://github.com/MervinPraison/PraisonAI.git
+    cd src/praisonai-ts
+    ```
+  </Step>
+
+  <Step title="Install Dependencies">
+    ```bash
+    npm install
+    ```
+  </Step>
+
+  <Step title="Build Package">
+    ```bash
+    npm run build
+    ```
+  </Step>
+</Steps>
+
+## Package Structure
+
+```
+src/
+├── agent/         # Agent-related interfaces and implementations
+├── task/          # Task management and execution
+├── utils/         # Utility functions and helpers
+└── types/         # TypeScript type definitions

docs/js/js.mdx

@@ -0,0 +1,214 @@
+---
+title: "JavaScript AI Agents Framework"
+sidebarTitle: "JavaScript Agents"
+description: "A production-ready Multi AI Agents framework for JavaScript"
+icon: "js"
+---
+
+PraisonAI is a production-ready Multi AI Agents framework for JavaScript, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. It provides a low-code solution to streamline the building and management of multi-agent LLM systems, emphasising simplicity, customisation, and effective human-agent collaboration.
+
+```mermaid
+graph LR
+    %% Define the main flow
+    Start([▶ Start]) --> Agent1
+    Agent1 --> Process[⚙ Process]
+    Process --> Agent2
+    Agent2 --> Output([✓ Output])
+    Process -.-> Agent1
+    
+    %% Define subgraphs for agents and their tasks
+    subgraph Agent1[ ]
+        Task1[📋 Task]
+        AgentIcon1[🤖 AI Agent]
+        Tools1[🔧 Tools]
+        
+        Task1 --- AgentIcon1
+        AgentIcon1 --- Tools1
+    end
+    
+    subgraph Agent2[ ]
+        Task2[📋 Task]
+        AgentIcon2[🤖 AI Agent]
+        Tools2[🔧 Tools]
+        
+        Task2 --- AgentIcon2
+        AgentIcon2 --- Tools2
+    end
+
+    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
+```
+
+<Tabs>
+<Tab title="JavaScript">
+    <Steps>
+      <Step title="Install Package">
+        <CodeGroup>
+        ```bash npm
+        npm install praisonai
+        ```
+        ```bash yarn
+        yarn add praisonai
+        ```
+        </CodeGroup>
+      </Step>
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+        ```
+      </Step>
+      <Step title="Create File">
+        Create `app.js` file
+
+        ## Code Example
+
+<CodeGroup>
+```javascript Single Agent
+const { Agent } = require('praisonai');
+const agent = new Agent({ instructions: 'You are a helpful AI assistant' });
+agent.start('Write a movie script about a robot in Mars');
+```
+
+```javascript Multi Agents
+const { Agent, PraisonAIAgents } = require('praisonai');
+
+const researchAgent = new Agent({ instructions: 'Research about AI' });
+const summariseAgent = new Agent({ instructions: 'Summarise research agent\'s findings' });
+
+const agents = new PraisonAIAgents({ agents: [researchAgent, summariseAgent] });
+agents.start();
+```
+</CodeGroup>
+      </Step>
+      <Step title="Run Script">
+        ```bash
+        node app.js
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+## Usage Examples
+
+<AccordionGroup>
+  <Accordion title="Single Agent Example" icon="user" defaultOpen>
+    Create and run a single agent to perform a specific task:
+
+```javascript
+const { Agent } = require('praisonai');
+
+// Create a simple science explainer agent
+const agent = new Agent({
+  instructions: "You are a science expert who explains complex phenomena in simple terms.",
+  name: "ScienceExplainer",
+  verbose: true
+});
+
+// Ask a question
+agent.start("Why is the sky blue?")
+  .then(response => {
+    console.log('\nExplanation:');
+    console.log(response);
+  })
+  .catch(error => console.error('Error:', error));
+
+```
+  </Accordion>
+
+  <Accordion title="Multi-Agent Example" icon="users" defaultOpen>
+    Create and run multiple agents working together:
+
+```javascript
+const { PraisonAIAgents, Agent } = require('praisonai');
+
+// Create a story agent and a summary agent
+const storyAgent = new Agent({
+  instructions: "You are a creative storyteller. Create engaging stories.",
+  name: "Storyteller"
+});
+
+const summaryAgent = new Agent({
+  instructions: "You summarize stories into brief, engaging summaries.",
+  name: "Summarizer"
+});
+
+// Create multi-agent system
+const agents = new PraisonAIAgents({
+  agents: [storyAgent, summaryAgent],
+  tasks: [
+    "Create a short story about a magical forest",
+    "Summarize the story in 2 sentences"
+  ]
+});
+
+// Run the agents
+agents.start()
+  .then(responses => {
+    console.log('\nStory:');
+    console.log(responses[0]);
+    console.log('\nSummary:');
+    console.log(responses[1]);
+  })
+  .catch(error => console.error('Error:', error));
+```
+  </Accordion>
+
+  <Accordion title="Task-Based Agent Example" icon="list-check" defaultOpen>
+    Create agents with specific tasks and dependencies:
+
+```javascript
+const { Agent, Task } = require('praisonai');
+
+// Create a task-based agent
+const agent = new Agent({
+  name: "TaskMaster",
+  role: "Assistant",
+  goal: "Complete tasks efficiently",
+  backstory: "You are an AI assistant that helps complete tasks step by step."
+});
+
+// Create a task with dependencies
+const mainTask = new Task({
+  name: "Write Blog Post",
+  description: "Write a blog post about artificial intelligence",
+  expected_output: "A complete blog post",
+  dependencies: []
+});
+
+// Execute the task
+agent.execute(mainTask)
+  .then(response => {
+    console.log('\nBlog Post:');
+    console.log(response);
+  })
+  .catch(error => console.error('Error:', error));
+```
+  </Accordion>
+</AccordionGroup>
+
+## Running the Examples
+
+<Steps>
+  <Step title="Set Environment Variables">
+    ```bash
+    export OPENAI_API_KEY='your-api-key'
+    ```
+  </Step>
+
+  <Step title="Create Example File">
+    Create a new JavaScript file (e.g., `app.js`) with any of the above examples.
+  </Step>
+
+  <Step title="Run the Example">
+    ```bash
+    node app.js
+    ```
+  </Step>
+</Steps>

docs/js/nodejs.mdx

@@ -0,0 +1,251 @@
+---
+title: "Node.js AI Agents Framework"
+sidebarTitle: "Node.js Agents"
+description: "A production-ready Multi AI Agents framework for Node.js"
+icon: "node-js"
+---
+
+PraisonAI is a production-ready Multi AI Agents framework for Node.js, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. It provides a low-code solution to streamline the building and management of multi-agent LLM systems, emphasising simplicity, customisation, and effective human-agent collaboration.
+
+```mermaid
+graph LR
+    %% Define the main flow
+    Start([▶ Start]) --> Agent1
+    Agent1 --> Process[⚙ Process]
+    Process --> Agent2
+    Agent2 --> Output([✓ Output])
+    Process -.-> Agent1
+    
+    %% Define subgraphs for agents and their tasks
+    subgraph Agent1[ ]
+        Task1[📋 Task]
+        AgentIcon1[🤖 AI Agent]
+        Tools1[🔧 Tools]
+        
+        Task1 --- AgentIcon1
+        AgentIcon1 --- Tools1
+    end
+    
+    subgraph Agent2[ ]
+        Task2[📋 Task]
+        AgentIcon2[🤖 AI Agent]
+        Tools2[🔧 Tools]
+        
+        Task2 --- AgentIcon2
+        AgentIcon2 --- Tools2
+    end
+
+    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
+```
+
+<Tabs>
+<Tab title="Node.js">
+    <Steps>
+      <Step title="Install Package">
+        <CodeGroup>
+        ```bash npm
+        npm install praisonai
+        ```
+        ```bash yarn
+        yarn add praisonai
+        ```
+        </CodeGroup>
+      </Step>
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+        ```
+      </Step>
+      <Step title="Create File">
+        Create `app.js` file
+
+        ## Code Example
+
+<CodeGroup>
+```javascript Single Agent
+const { Agent } = require('praisonai');
+const agent = new Agent({ instructions: 'You are a helpful AI assistant' });
+agent.start('Write a movie script about a robot in Mars');
+```
+
+```javascript Multi Agents
+const { Agent, PraisonAIAgents } = require('praisonai');
+
+const researchAgent = new Agent({ instructions: 'Research about AI' });
+const summariseAgent = new Agent({ instructions: 'Summarise research agent\'s findings' });
+
+const agents = new PraisonAIAgents({ agents: [researchAgent, summariseAgent] });
+agents.start();
+```
+</CodeGroup>
+      </Step>
+      <Step title="Run Script">
+        ```bash
+        node app.js
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+## Usage Examples
+
+<AccordionGroup>
+  <Accordion title="Single Agent Example" icon="user" defaultOpen>
+    Create and run a single agent to perform a specific task:
+
+```typescript
+import { Agent } from 'praisonai';
+
+// Single agent example - Science Explainer
+const agent = new Agent({ 
+  instructions: `You are a science expert who explains complex phenomena in simple terms.
+Provide clear, accurate, and easy-to-understand explanations.`,
+  name: "ScienceExplainer",
+  verbose: true
+});
+
+agent.start("Why is the sky blue?")
+  .then(response => {
+    console.log('\nExplanation:');
+    console.log(response);
+  })
+  .catch(error => {
+    console.error('Error:', error);
+  });
+
+```
+  </Accordion>
+
+  <Accordion title="Multi-Agent Example" icon="users" defaultOpen>
+    Create and run multiple agents working together:
+
+```typescript
+import { Agent, PraisonAIAgents } from 'praisonai';
+
+// Create story agent
+const storyAgent = new Agent({
+  instructions: "You are a storyteller. Write a very short story (2-3 sentences) about a given topic.",
+  name: "StoryAgent",
+  verbose: true
+});
+
+// Create summary agent
+const summaryAgent = new Agent({
+  instructions: "You are an editor. Create a one-sentence summary of the given story.",
+  name: "SummaryAgent",
+  verbose: true
+});
+
+// Create and start agents
+const agents = new PraisonAIAgents({
+  agents: [storyAgent, summaryAgent],
+  tasks: [
+    "Write a short story about a cat",
+    "{previous_result}"  // This will be replaced with the story
+  ],
+  verbose: true
+});
+
+agents.start()
+  .then(results => {
+    console.log('\nStory:', results[0]);
+    console.log('\nSummary:', results[1]);
+  })
+  .catch(error => console.error('Error:', error));
+```
+  </Accordion>
+
+  <Accordion title="Task-Based Agent Example" icon="list-check" defaultOpen>
+    Create agents with specific tasks and dependencies:
+
+```typescript
+import { Agent, PraisonAIAgents } from 'praisonai';
+
+// Create recipe agent
+const recipeAgent = new Agent({
+  instructions: `You are a professional chef and nutritionist. Create 5 healthy food recipes that are both nutritious and delicious.
+Each recipe should include:
+1. Recipe name
+2. List of ingredients with quantities
+3. Step-by-step cooking instructions
+4. Nutritional information
+5. Health benefits
+
+Format your response in markdown.`,
+  name: "RecipeAgent",
+  verbose: true
+});
+
+// Create blog agent
+const blogAgent = new Agent({
+  instructions: `You are a food and health blogger. Write an engaging blog post about the provided recipes.
+The blog post should:
+1. Have an engaging title
+2. Include an introduction about healthy eating
+3. Discuss each recipe and its unique health benefits
+4. Include tips for meal planning and preparation
+5. End with a conclusion encouraging healthy eating habits
+
+Here are the recipes to write about:
+{previous_result}
+
+Format your response in markdown.`,
+  name: "BlogAgent",
+  verbose: true
+});
+
+// Create PraisonAIAgents instance with tasks
+const agents = new PraisonAIAgents({
+  agents: [recipeAgent, blogAgent],
+  tasks: [
+    "Create 5 healthy and delicious recipes",
+    "Write a blog post about the recipes"
+  ],
+  verbose: true
+});
+
+// Start the agents
+agents.start()
+  .then(results => {
+    console.log('\nFinal Results:');
+    console.log('\nRecipe Task Results:');
+    console.log(results[0]);
+    console.log('\nBlog Task Results:');
+    console.log(results[1]);
+  })
+  .catch(error => {
+    console.error('Error:', error);
+  });
+
+```
+  </Accordion>
+</AccordionGroup>
+
+## Running the Examples
+
+<Steps>
+  <Step title="Set Environment Variables">
+    ```bash
+    export OPENAI_API_KEY='your-api-key'
+    ```
+  </Step>
+
+  <Step title="Create Example File">
+    Create a new TypeScript file (e.g., `app.ts`) with any of the above examples.
+  </Step>
+
+  <Step title="Run the Example">
+    ```bash
+    npx ts-node app.ts
+    ```
+  </Step>
+</Steps>

docs/js/typescript-async.mdx

@@ -0,0 +1,198 @@
+---
+title: "TypeScript Async AI Agents"
+sidebarTitle: "TypeScript Async"
+description: "A production-ready Multi AI Agents framework for TypeScript Async"
+icon: "rotate"
+---
+
+PraisonAI is a production-ready Multi AI Agents framework for TypeScript Async, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. It provides a low-code solution to streamline the building and management of multi-agent LLM systems, emphasising simplicity, customisation, and effective human-agent collaboration.
+
+## Installation
+
+<CodeGroup>
+```bash npm
+npm install praisonai
+```
+
+```bash yarn
+yarn add praisonai
+```
+</CodeGroup>
+
+## Usage Examples
+
+<AccordionGroup>
+  <Accordion title="Single Agent Example" icon="user" defaultOpen>
+    Create and run a single agent to perform a specific task:
+
+    ```typescript
+    import { Agent, PraisonAIAgents } from 'praisonai';
+
+    async function main() {
+        // Create a simple agent (no task specified)
+        const agent = new Agent({
+            name: "BiologyExpert",
+            instructions: "Explain the process of photosynthesis in detail.",
+            verbose: true
+        });
+
+        // Run the agent
+        const praisonAI = new PraisonAIAgents({
+            agents: [agent],
+            tasks: ["Explain the process of photosynthesis in detail."],
+            verbose: true
+        });
+
+        try {
+            console.log('Starting single agent example...');
+            const results = await praisonAI.start();
+            console.log('\nFinal Results:', results);
+        } catch (error) {
+            console.error('Error:', error);
+        }
+    }
+
+    main();
+    ```
+  </Accordion>
+
+  <Accordion title="Multi-Agent Example" icon="users" defaultOpen>
+    Create and run multiple agents working together:
+
+    ```typescript
+    import { Agent, PraisonAIAgents } from 'praisonai';
+
+    async function main() {
+        // Create multiple agents with different roles
+        const researchAgent = new Agent({
+            name: "ResearchAgent",
+            instructions: "Research and provide detailed information about renewable energy sources.",
+            verbose: true
+        });
+
+        const summaryAgent = new Agent({
+            name: "SummaryAgent",
+            instructions: "Create a concise summary of the research findings about renewable energy sources. Use {previous_result} as input.",
+            verbose: true
+        });
+
+        const recommendationAgent = new Agent({
+            name: "RecommendationAgent",
+            instructions: "Based on the summary in {previous_result}, provide specific recommendations for implementing renewable energy solutions.",
+            verbose: true
+        });
+
+        // Run the agents in sequence
+        const praisonAI = new PraisonAIAgents({
+            agents: [researchAgent, summaryAgent, recommendationAgent],
+            tasks: [
+                "Research and analyze current renewable energy technologies and their implementation.",
+                "Summarize the key findings from the research.",
+                "Provide actionable recommendations based on the summary."
+            ],
+            verbose: true
+        });
+
+        try {
+            console.log('Starting multi-agent example...');
+            const results = await praisonAI.start();
+            console.log('\nFinal Results:', results);
+        } catch (error) {
+            console.error('Error:', error);
+        }
+    }
+
+    main();
+    ```
+  </Accordion>
+
+  <Accordion title="Task-Based Agent Example" icon="list-check" defaultOpen>
+    Create agents with specific tasks and dependencies:
+
+    ```typescript
+    import { Agent, Task, PraisonAIAgents } from 'praisonai';
+
+    async function main() {
+        // Create agents first
+        const dietAgent = new Agent({
+            name: "DietAgent",
+            role: "Nutrition Expert",
+            goal: "Create healthy and delicious recipes",
+            backstory: "You are a certified nutritionist with years of experience in creating balanced meal plans.",
+            verbose: true,
+            instructions: `You are a professional chef and nutritionist. Create 5 healthy food recipes that are both nutritious and delicious.
+    Each recipe should include:
+    1. Recipe name
+    2. List of ingredients with quantities
+    3. Step-by-step cooking instructions
+    4. Nutritional information
+    5. Health benefits
+
+    Format your response in markdown.`
+        });
+
+        const blogAgent = new Agent({
+            name: "BlogAgent",
+            role: "Food Blogger",
+            goal: "Write engaging blog posts about food and recipes",
+            backstory: "You are a successful food blogger known for your ability to make recipes sound delicious and approachable.",
+            verbose: true,
+            instructions: `You are a food and health blogger. Write an engaging blog post about the provided recipes.
+    The blog post should:
+    1. Have an engaging title
+    2. Include an introduction about healthy eating`
+        });
+
+        // Create tasks
+        const createRecipesTask = new Task({
+            name: "Create Recipes",
+            description: "Create 5 healthy and delicious recipes",
+            agent: dietAgent
+        });
+
+        const writeBlogTask = new Task({
+            name: "Write Blog",
+            description: "Write a blog post about the recipes",
+            agent: blogAgent,
+            dependencies: [createRecipesTask]  // This task depends on the recipes being created first
+        });
+
+        // Run the tasks
+        const praisonAI = new PraisonAIAgents({
+            tasks: [createRecipesTask, writeBlogTask],
+            verbose: true
+        });
+
+        try {
+            console.log('Starting task-based example...');
+            const results = await praisonAI.start();
+            console.log('\nFinal Results:', results);
+        } catch (error) {
+            console.error('Error:', error);
+        }
+    }
+
+    main();
+    ```
+  </Accordion>
+</AccordionGroup>
+
+## Running the Examples
+
+<Steps>
+  <Step title="Set Environment Variables">
+    ```bash
+    export OPENAI_API_KEY='your-api-key'
+    ```
+  </Step>
+
+  <Step title="Create Example File">
+    Create a new TypeScript file (e.g., `app.ts`) with any of the above examples.
+  </Step>
+
+  <Step title="Run the Example">
+    ```bash
+    npx ts-node app.ts
+    ```
+  </Step>
+</Steps>

docs/js/typescript.mdx

@@ -0,0 +1,297 @@
+---
+title: "TypeScript AI Agents Framework"
+sidebarTitle: "TypeScript Agents"
+description: "A production-ready Multi AI Agents framework for TypeScript"
+icon: "scroll"
+---
+
+PraisonAI is a production-ready Multi AI Agents framework for TypeScript, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. It provides a low-code solution to streamline the building and management of multi-agent LLM systems, emphasising simplicity, customisation, and effective human-agent collaboration.
+
+```mermaid
+graph LR
+    %% Define the main flow
+    Start([▶ Start]) --> Agent1
+    Agent1 --> Process[⚙ Process]
+    Process --> Agent2
+    Agent2 --> Output([✓ Output])
+    Process -.-> Agent1
+    
+    %% Define subgraphs for agents and their tasks
+    subgraph Agent1[ ]
+        Task1[📋 Task]
+        AgentIcon1[🤖 AI Agent]
+        Tools1[🔧 Tools]
+        
+        Task1 --- AgentIcon1
+        AgentIcon1 --- Tools1
+    end
+    
+    subgraph Agent2[ ]
+        Task2[📋 Task]
+        AgentIcon2[🤖 AI Agent]
+        Tools2[🔧 Tools]
+        
+        Task2 --- AgentIcon2
+        AgentIcon2 --- Tools2
+    end
+
+    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
+```
+
+<Tabs>
+<Tab title="TypeScript">
+    <Steps>
+      <Step title="Install Package">
+        <CodeGroup>
+        ```bash npm
+        npm install praisonai
+        ```
+        ```bash yarn
+        yarn add praisonai
+        ```
+        </CodeGroup>
+      </Step>
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+        ```
+      </Step>
+      <Step title="Create File">
+        Create `app.ts` file
+
+        ## Code Example
+
+<CodeGroup>
+```javascript Single Agent
+import { Agent } from 'praisonai';
+
+const agent = new Agent({ 
+  instructions: `You are a creative writer who writes short stories with emojis.`,
+  name: "StoryWriter"
+});
+
+agent.start("Write a story about a time traveler")
+```
+
+```javascript Multi Agents
+import { Agent, PraisonAIAgents } from 'praisonai';
+
+const storyAgent = new Agent({
+  instructions: "Generate a very short story (2-3 sentences) about artificial intelligence with emojis.",
+  name: "StoryAgent"
+});
+
+const summaryAgent = new Agent({
+  instructions: "Summarize the provided AI story in one sentence with emojis.",
+  name: "SummaryAgent"
+});
+
+const agents = new PraisonAIAgents({
+  agents: [storyAgent, summaryAgent]
+});
+
+agents.start()
+```
+</CodeGroup>
+      </Step>
+      <Step title="Run Script">
+        ```bash
+        npx ts-node app.ts
+        ```
+      </Step>
+    </Steps>
+  </Tab>
+</Tabs>
+
+## Usage Examples
+
+<AccordionGroup>
+  <Accordion title="Single Agent Example" icon="user" defaultOpen>
+    Create and run a single agent to perform a specific task:
+
+```typescript
+import { Agent } from 'praisonai';
+
+// Single agent example - Science Explainer
+const agent = new Agent({ 
+  instructions: `You are a science expert who explains complex phenomena in simple terms.
+Provide clear, accurate, and easy-to-understand explanations.`,
+  name: "ScienceExplainer",
+  verbose: true
+});
+
+agent.start("Why is the sky blue?")
+  .then(response => {
+    console.log('\nExplanation:');
+    console.log(response);
+  })
+  .catch(error => {
+    console.error('Error:', error);
+  });
+
+```
+  </Accordion>
+
+  <Accordion title="Multi-Agent Example" icon="users" defaultOpen>
+    Create and run multiple agents working together:
+
+```typescript
+import { Agent, PraisonAIAgents } from 'praisonai';
+
+// Create story agent
+const storyAgent = new Agent({
+  instructions: "You are a storyteller. Write a very short story (2-3 sentences) about a given topic.",
+  name: "StoryAgent",
+  verbose: true
+});
+
+// Create summary agent
+const summaryAgent = new Agent({
+  instructions: "You are an editor. Create a one-sentence summary of the given story.",
+  name: "SummaryAgent",
+  verbose: true
+});
+
+// Create and start agents
+const agents = new PraisonAIAgents({
+  agents: [storyAgent, summaryAgent],
+  tasks: [
+    "Write a short story about a cat",
+    "{previous_result}"  // This will be replaced with the story
+  ],
+  verbose: true
+});
+
+agents.start()
+  .then(results => {
+    console.log('\nStory:', results[0]);
+    console.log('\nSummary:', results[1]);
+  })
+  .catch(error => console.error('Error:', error));
+```
+  </Accordion>
+
+  <Accordion title="Task-Based Agent Example" icon="list-check" defaultOpen>
+    Create agents with specific tasks and dependencies:
+
+```typescript
+import { Agent, PraisonAIAgents } from 'praisonai';
+
+// Create recipe agent
+const recipeAgent = new Agent({
+  instructions: `You are a professional chef and nutritionist. Create 5 healthy food recipes that are both nutritious and delicious.
+Each recipe should include:
+1. Recipe name
+2. List of ingredients with quantities
+3. Step-by-step cooking instructions
+4. Nutritional information
+5. Health benefits
+
+Format your response in markdown.`,
+  name: "RecipeAgent",
+  verbose: true
+});
+
+// Create blog agent
+const blogAgent = new Agent({
+  instructions: `You are a food and health blogger. Write an engaging blog post about the provided recipes.
+The blog post should:
+1. Have an engaging title
+2. Include an introduction about healthy eating
+3. Discuss each recipe and its unique health benefits
+4. Include tips for meal planning and preparation
+5. End with a conclusion encouraging healthy eating habits
+
+Here are the recipes to write about:
+{previous_result}
+
+Format your response in markdown.`,
+  name: "BlogAgent",
+  verbose: true
+});
+
+// Create PraisonAIAgents instance with tasks
+const agents = new PraisonAIAgents({
+  agents: [recipeAgent, blogAgent],
+  tasks: [
+    "Create 5 healthy and delicious recipes",
+    "Write a blog post about the recipes"
+  ],
+  verbose: true
+});
+
+// Start the agents
+agents.start()
+  .then(results => {
+    console.log('\nFinal Results:');
+    console.log('\nRecipe Task Results:');
+    console.log(results[0]);
+    console.log('\nBlog Task Results:');
+    console.log(results[1]);
+  })
+  .catch(error => {
+    console.error('Error:', error);
+  });
+
+```
+  </Accordion>
+</AccordionGroup>
+
+## Running the Examples
+
+<Steps>
+  <Step title="Set Environment Variables">
+    ```bash
+    export OPENAI_API_KEY='your-api-key'
+    ```
+  </Step>
+
+  <Step title="Create Example File">
+    Create a new TypeScript file (e.g., `app.ts`) with any of the above examples.
+  </Step>
+
+  <Step title="Run the Example">
+    ```bash
+    npx ts-node app.ts
+    ```
+  </Step>
+</Steps>
+
+## Tool Calls Examples
+
+<AccordionGroup>
+  <Accordion title="Direct Function Tools" icon="code" defaultOpen>
+    Create an agent with directly registered function tools:
+
+```typescript
+import { Agent } from 'praisonai';
+
+async function getWeather(location: string) {
+  console.log(`Getting weather for ${location}...`);
+  return `${Math.floor(Math.random() * 30)}°C`;
+}
+
+async function getTime(location: string) {
+  console.log(`Getting time for ${location}...`);
+  const now = new Date();
+  return `${now.getHours()}:${now.getMinutes()}`;
+}
+
+const agent = new Agent({ 
+  instructions: `You provide the current weather and time for requested locations.`,
+  name: "DirectFunctionAgent",
+  tools: [getWeather, getTime]
+});
+
+agent.start("What's the weather and time in Paris, France and Tokyo, Japan?");
+```
+  </Accordion>
+</AccordionGroup>

docs/mcp/airbnb.mdx

@@ -0,0 +1,112 @@
+---
+title: "Airbnb MCP Integration"
+sidebarTitle: "Airbnb"
+description: "Guide for integrating Airbnb booking capabilities with PraisonAI agents using MCP"
+icon: "airbnb"
+---
+
+## Add Airbnb Tool to AI Agent
+
+```mermaid
+flowchart LR
+    In[In] --> Agent[AI Agent]
+    Agent --> Tool[Airbnb MCP]
+    Tool --> Agent
+    Agent --> Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style Agent fill:#2E8B57,color:#fff
+    style Tool fill:#FF5A5F,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+## Quick Start
+
+<Steps>
+    <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable in your terminal:
+        ```bash
+        export OPENAI_API_KEY=your_openai_api_key_here
+        ```
+    </Step>
+
+    <Step title="Create a file">
+        Create a new file `airbnb_search.py` with the following code:
+        ```python
+        from praisonaiagents import Agent, MCP
+
+        search_agent = Agent(
+            instructions="""You help book apartments on Airbnb.""",
+            llm="gpt-4o-mini",
+            tools=MCP("npx -y @openbnb/mcp-server-airbnb --ignore-robots-txt")
+        )
+
+        search_agent.start("I want to book an apartment in Paris for 2 nights. 03/28 - 03/30 for 2 adults")
+        ```
+    </Step>
+
+    <Step title="Install Dependencies">
+        Make sure you have Node.js installed, as the MCP server requires it:
+        ```bash
+        pip install praisonaiagents
+        ```
+    </Step>
+
+    <Step title="Run the Agent">
+        Execute your script:
+        ```bash
+        python airbnb_search.py
+        ```
+    </Step>
+</Steps>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - Node.js installed on your system
+  - OpenAI API key (for the agent's LLM)
+</Note>
+
+## Gradio UI 
+
+```python
+from praisonaiagents import Agent, MCP
+import gradio as gr
+
+def search_airbnb(query):
+    agent = Agent(
+        instructions="You help book apartments on Airbnb.",
+        llm="gpt-4o-mini",
+        tools=MCP("npx -y @openbnb/mcp-server-airbnb --ignore-robots-txt")
+    )
+    result = agent.start(query)
+    return f"## Airbnb Search Results\n\n{result}"
+
+demo = gr.Interface(
+    fn=search_airbnb,
+    inputs=gr.Textbox(placeholder="I want to book an apartment in Paris for 2 nights..."),
+    outputs=gr.Markdown(),
+    title="Airbnb Booking Assistant",
+    description="Enter your booking requirements below:"
+)
+
+if __name__ == "__main__":
+    demo.launch()
+```
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Accommodation Search" icon="hotel">
+    Search for accommodations on Airbnb with natural language queries.
+  </Card>
+  <Card title="MCP Integration" icon="plug">
+    Seamless integration with Model Context Protocol.
+  </Card>
+  <Card title="Booking Details" icon="calendar">
+    Specify dates, guests, and location preferences in natural language.
+  </Card>
+  <Card title="NPM Package" icon="js">
+    Leverages the official Airbnb MCP server package.
+  </Card>
+</CardGroup>