Merge pull request #381 from MervinPraison/develop

Bump version to 2.0.74 and refactor train.py template generation

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, 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 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,830 +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
-    ):
-        # 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
-
-        # 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: {output_json.schema_json()}"
-            elif output_pydantic:
-                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_pydantic.schema_json()}"
-        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: {output_json.schema_json()}"
-            elif output_pydantic:
-                system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {output_pydantic.schema_json()}"
-
-            # 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,569 +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
-
-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}"
-                        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"]:
-                    result = current_task.result.raw.lower()
-                    # Check conditions
-                    for condition, tasks in current_task.condition.items():
-                        if condition.lower() in result:
-                            # Handle both list and direct string values
-                            task_value = tasks[0] if isinstance(tasks, list) else tasks
-                            if not task_value or task_value == "exit":  # If empty or explicit exit
-                                logging.info("Workflow exit condition met, ending workflow")
-                                current_task = None
-                                break
-                            next_task_name = task_value
-                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
-                            # For loops, allow revisiting the same task
-                            if next_task and next_task.id == current_task.id:
-                                visited_tasks.discard(current_task.id)
-                            break
-            
-            if not next_task and current_task 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")
-        
-        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}"
-                        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"]:
-                    result = current_task.result.raw.lower()
-                    # Check conditions
-                    for condition, tasks in current_task.condition.items():
-                        if condition.lower() in result:
-                            # Handle both list and direct string values
-                            task_value = tasks[0] if isinstance(tasks, list) else tasks
-                            if not task_value or task_value == "exit":  # If empty or explicit exit
-                                logging.info("Workflow exit condition met, ending workflow")
-                                current_task = None
-                                break
-                            next_task_name = task_value
-                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
-                            # For loops, allow revisiting the same task
-                            if next_task and next_task.id == current_task.id:
-                                visited_tasks.discard(current_task.id)
-                            break
-            
-            if not next_task and current_task 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.49 gunicorn markdown
+RUN pip install flask praisonai==2.0.74 gunicorn markdown
 EXPOSE 8080
 CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]

docs/agents/agents.mdx

@@ -6,6 +6,45 @@ icon: "robot"
 
 PraisonAI provides a diverse set of specialized agents for various tasks. Each agent is designed with specific capabilities and tools to handle different types of tasks effectively.
 
+```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
+```
+
 ## Data & Analysis
 
 <CardGroup cols={2}>

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.49 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.0.74 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/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.0.18 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/examples/code-analysis.mdx

@@ -0,0 +1,203 @@
+---
+title: "Code Analysis Agent"
+description: "Learn how to create AI agents for comprehensive code analysis and quality assessment."
+icon: "code-merge"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Analyzer[Code Analyzer]
+    Analyzer --> Quality[Quality Assessment]
+    Quality --> Metrics[Core Metrics]
+    Metrics --> Technical[Technical Review]
+    Technical --> Recommendations[Recommendations]
+    Recommendations --> Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style Analyzer fill:#2E8B57,color:#fff
+    style Quality fill:#2E8B57,color:#fff
+    style Metrics fill:#2E8B57,color:#fff
+    style Technical fill:#2E8B57,color:#fff
+    style Recommendations fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+## What is Code Analysis?
+
+Code Analysis is a systematic process of evaluating source code to assess its quality, maintainability, performance, and security. This helps developers and organizations maintain high code standards and identify areas for improvement.
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Quality Assessment" icon="chart-simple">
+    Comprehensive evaluation of code quality with numerical scoring.
+  </Card>
+  <Card title="Core Metrics Analysis" icon="gauge">
+    Analysis of architecture, maintainability, performance, and security.
+  </Card>
+  <Card title="Technical Assessment" icon="code">
+    Review of tech stack, complexity, and best practices adherence.
+  </Card>
+  <Card title="Risk Assessment" icon="shield">
+    Identification of potential risks and security vulnerabilities.
+  </Card>
+  <Card title="Recommendations" icon="lightbulb">
+    Actionable suggestions for improvements and enhancements.
+  </Card>
+</CardGroup>
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Package">
+        First, install the PraisonAI Agents package:
+        ```bash
+        pip install praisonaiagents gitingest
+        ```
+    </Step>
+
+    <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable in your terminal:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+    </Step>
+
+    <Step title="Create a file">
+        Create a new file `code_analysis.py` with the following code:
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from pydantic import BaseModel
+from typing import List, Dict
+from gitingest import ingest
+
+class CodeMetrics(BaseModel):
+    category: str
+    score: int
+    findings: List[str]
+
+class CodeAnalysisReport(BaseModel):
+    overall_quality: int
+    code_metrics: List[CodeMetrics]
+    architecture_score: int
+    maintainability_score: int
+    performance_score: int
+    security_score: int
+    test_coverage: int
+    key_strengths: List[str]
+    improvement_areas: List[str]
+    tech_stack: List[str]
+    recommendations: List[str]
+    complexity_metrics: Dict[str, int]
+    best_practices: List[Dict[str, str]]
+    potential_risks: List[str]
+    documentation_quality: int
+
+code_analyzer = Agent(
+    role="Code Analysis Expert",
+    goal="Provide comprehensive code evaluation and recommendations",
+    backstory="""Expert code analyst specializing in architecture review, 
+    best practices, and technical debt assessment.""",
+    verbose=True
+)
+
+code_analysis_task = Task(
+    description="""Analyze code repository and provide structured evaluation:
+    
+    1. Overall Quality (0-100)
+    2. Core Metrics Analysis:
+       - Architecture and Design
+       - Code Maintainability
+       - Performance Optimization
+       - Security Practices
+       - Test Coverage
+    3. Technical Assessment:
+       - Technology Stack Review
+       - Code Complexity Analysis
+       - Best Practices Adherence
+       - Risk Assessment
+    4. Recommendations:
+       - Key Improvements
+       - Architecture Suggestions
+       - Security Enhancements""",
+    expected_output="Detailed code analysis report with metrics and recommendations",
+    agent=code_analyzer,
+    output_pydantic=CodeAnalysisReport
+)
+
+def analyze_code(code_source: str) -> CodeAnalysisReport:
+    """
+    Analyze code from directory path or GitHub URL
+    """
+    # Ingest code content
+    summary, tree, content = ingest(code_source)
+    
+    # Concatenate context into structured format
+    context_text = f"""
+    CODE REPOSITORY ANALYSIS
+    =======================
+    
+    SUMMARY
+    -------
+    {summary}
+    
+    REPOSITORY STRUCTURE
+    -------------------
+    {tree}
+    
+    SOURCE CODE
+    -----------
+    {content}
+    """
+    
+    # Initialize and run analysis
+    agents = PraisonAIAgents(
+        agents=[code_analyzer],
+        tasks=[code_analysis_task]
+    )
+    
+    return agents.start(context_text)
+
+if __name__ == "__main__":
+    # Example usage
+    code_source = "https://github.com/openai/openai-python/tree/main/src/openai/cli/_api/chat"  # GitHub URL or local directory
+    result = analyze_code(code_source)
+    print(result)
+```
+    </Step>
+</Steps>
+
+## Understanding the Output
+
+The code analysis generates a comprehensive report with the following components:
+
+- Overall Quality Score (0-100)
+- Core Metrics Analysis
+  - Architecture and Design Score
+  - Code Maintainability Score
+  - Performance Score
+  - Security Score
+  - Test Coverage Percentage
+- Technical Assessment
+  - Technology Stack
+  - Complexity Metrics
+  - Best Practices Review
+  - Risk Assessment
+- Recommendations
+  - Key Improvements
+  - Architecture Suggestions
+  - Security Enhancements
+
+## 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>
+  <Card title="API Reference" icon="code" href="/api-reference">
+    Explore the complete API documentation
+  </Card>
+</CardGroup>

docs/examples/hackathon-judge.mdx

@@ -0,0 +1,265 @@
+---
+title: "Hackathon Judge Agent"
+description: "Learn how to create AI agents for evaluating hackathon projects through video demonstrations."
+icon: "trophy"
+---
+
+```mermaid
+flowchart LR
+    In[In] --> Judge[Hackathon Judge]
+    Judge --> Scores[Project Scores]
+    Scores --> Analysis[Detailed Analysis]
+    Analysis --> Feedback[Feedback]
+    Feedback --> Recommendations[Recommendations]
+    Recommendations --> Out[Out]
+    
+    style In fill:#8B0000,color:#fff
+    style Judge fill:#2E8B57,color:#fff
+    style Scores fill:#2E8B57,color:#fff
+    style Analysis fill:#2E8B57,color:#fff
+    style Feedback fill:#2E8B57,color:#fff
+    style Recommendations fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+## What is Hackathon Project Evaluation?
+
+Hackathon Project Evaluation is an automated process for assessing hackathon projects through video demonstrations. It provides comprehensive scoring across multiple dimensions including innovation, technical complexity, and presentation quality, helping organizers make informed decisions and providing valuable feedback to participants.
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Project Scoring" icon="star">
+    Comprehensive scoring system across multiple dimensions (0-100).
+  </Card>
+  <Card title="Technical Analysis" icon="microchip">
+    Evaluation of technical complexity and implementation quality.
+  </Card>
+  <Card title="Innovation Assessment" icon="lightbulb">
+    Analysis of creativity and unique project features.
+  </Card>
+  <Card title="Market Analysis" icon="chart-line">
+    Assessment of market potential and scalability.
+  </Card>
+  <Card title="Detailed Feedback" icon="comments">
+    Constructive feedback and specific recommendations for improvement.
+  </Card>
+</CardGroup>
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Package">
+        First, install the PraisonAI Agents package:
+        ```bash
+        pip install praisonaiagents opencv-python moviepy
+        ```
+    </Step>
+
+    <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable in your terminal:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+    </Step>
+
+    <Step title="Create a file">
+        Create a new file `hackathon_judge.py` with the following code:
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from pydantic import BaseModel
+from typing import List, Dict
+import os
+import json
+
+class ProjectEvaluation(BaseModel):
+    innovation_score: int  # 0-100
+    technical_complexity: int # 0-100  
+    presentation_quality: int # 0-100
+    user_experience: int # 0-100
+    completeness: int # 0-100
+    overall_score: int # 0-100
+    key_strengths: List[str]
+    areas_for_improvement: List[str]
+    notable_features: List[str]
+    technical_highlights: List[str]
+    recommendations: List[str]
+    market_potential: str
+    scalability_assessment: str
+
+# Create Vision Analysis Agent
+hackathon_judge = Agent(
+    name="HackathonJudge",
+    role="Technical Project Evaluator",
+    goal="Evaluate hackathon projects through video demonstrations",
+    backstory="""You are an experienced hackathon judge and technical expert.
+    You excel at evaluating innovation, technical implementation, and presentation quality.
+    You provide constructive feedback and identify both strengths and areas for improvement.""",
+    llm="gpt-4o-mini",  # Using vision-capable model
+    self_reflect=False,
+    knowledge=""
+)
+
+def evaluate_project(video_path: str) -> ProjectEvaluation:
+    """
+    Evaluate a hackathon project based on its video demonstration
+    """
+    evaluation_task = Task(
+        name="project_evaluation",
+        description="""Analyze this hackathon project video demonstration and provide a comprehensive evaluation:
+        
+        1. Score the following aspects (0-100):
+           - Innovation and Creativity
+           - Technical Complexity
+           - Presentation Quality
+           - User Experience
+           - Project Completeness
+           
+        2. Identify:
+           - Key strengths and standout features
+           - Areas that could be improved
+           - Notable technical implementations
+           - Market potential and scalability
+           
+        3. Provide:
+           - Specific recommendations for improvement
+           - Technical suggestions
+           - Potential future enhancements""",
+        expected_output="Detailed project evaluation with scores and feedback",
+        agent=hackathon_judge,
+        output_pydantic=ProjectEvaluation,
+        images=[video_path]  # Video input for multimodal analysis
+    )
+
+    # Initialize and run evaluation
+    agents = PraisonAIAgents(
+        agents=[hackathon_judge],
+        tasks=[evaluation_task],
+        process="sequential",
+        verbose=True
+    )
+    
+    response = agents.start()
+    
+    try:
+        # If response contains task_results, extract the Pydantic model directly
+        if isinstance(response, dict) and 'task_results' in response:
+            task_output = response['task_results'][0]
+            if hasattr(task_output, 'pydantic'):
+                return task_output.pydantic
+            elif hasattr(task_output, 'raw'):
+                # Extract JSON from raw string if it's wrapped in ```json
+                raw_text = task_output.raw
+                if raw_text.startswith('```json'):
+                    raw_text = raw_text.split('\n', 1)[1].rsplit('\n', 1)[0]
+                evaluation_data = json.loads(raw_text)
+            else:
+                evaluation_data = json.loads(task_output) if isinstance(task_output, str) else task_output
+        # If response is a string, try to parse it as JSON
+        elif isinstance(response, str):
+            evaluation_data = json.loads(response)
+        # If response is a dict with task_status
+        elif isinstance(response, dict) and 'task_status' in response:
+            content = response['task_status']
+            if isinstance(content, dict):
+                evaluation_data = content
+            else:
+                evaluation_data = json.loads(content) if isinstance(content, str) else content
+        else:
+            evaluation_data = response
+            
+        print(f"Debug - Parsed evaluation_data: {evaluation_data}")
+        
+        # Create and return ProjectEvaluation instance
+        return ProjectEvaluation(
+            innovation_score=int(evaluation_data.get('innovation_score', 0)),
+            technical_complexity=int(evaluation_data.get('technical_complexity', 0)),
+            presentation_quality=int(evaluation_data.get('presentation_quality', 0)),
+            user_experience=int(evaluation_data.get('user_experience', 0)),
+            completeness=int(evaluation_data.get('completeness', 0)),
+            overall_score=int(evaluation_data.get('overall_score', 0)),
+            key_strengths=evaluation_data.get('key_strengths', []),
+            areas_for_improvement=evaluation_data.get('areas_for_improvement', []),
+            notable_features=evaluation_data.get('notable_features', []),
+            technical_highlights=evaluation_data.get('technical_highlights', []),
+            recommendations=evaluation_data.get('recommendations', []),
+            market_potential=str(evaluation_data.get('market_potential', '')),
+            scalability_assessment=str(evaluation_data.get('scalability_assessment', ''))
+        )
+    except Exception as e:
+        print(f"Debug - Raw response: {response}")
+        print(f"Error processing response: {e}")
+        raise
+
+if __name__ == "__main__":
+    # Example usage
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    video_path = os.path.join(current_dir, "presentation.mp4")
+    result = evaluate_project(video_path)  # Now returns ProjectEvaluation directly
+    
+    print("\nHackathon Project Evaluation")
+    print("===========================")
+    print(f"\nOverall Score: {result.overall_score}/100")
+    print("\nDetailed Scores:")
+    print(f"Innovation: {result.innovation_score}/100")
+    print(f"Technical Complexity: {result.technical_complexity}/100")
+    print(f"Presentation: {result.presentation_quality}/100")
+    print(f"User Experience: {result.user_experience}/100")
+    print(f"Completeness: {result.completeness}/100")
+    
+    print("\nKey Strengths:")
+    for strength in result.key_strengths:
+        print(f"- {strength}")
+        
+    print("\nAreas for Improvement:")
+    for area in result.areas_for_improvement:
+        print(f"- {area}")
+        
+    print("\nTechnical Highlights:")
+    for highlight in result.technical_highlights:
+        print(f"- {highlight}")
+        
+    print("\nRecommendations:")
+    for rec in result.recommendations:
+        print(f"- {rec}")
+        
+    print(f"\nMarket Potential: {result.market_potential}")
+    print(f"\nScalability Assessment: {result.scalability_assessment}") 
+```
+    </Step>
+</Steps>
+
+## Understanding the Output
+
+The hackathon project evaluation generates a comprehensive report with the following components:
+
+- Scoring Metrics (0-100)
+  - Innovation Score
+  - Technical Complexity
+  - Presentation Quality
+  - User Experience
+  - Project Completeness
+  - Overall Score
+- Qualitative Analysis
+  - Key Strengths
+  - Areas for Improvement
+  - Notable Features
+  - Technical Highlights
+- Strategic Assessment
+  - Recommendations
+  - Market Potential
+  - Scalability Assessment
+
+## 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>
+  <Card title="API Reference" icon="code" href="/api-reference">
+    Explore the complete API documentation
+  </Card>
+</CardGroup>

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/multimodal.mdx

@@ -12,7 +12,7 @@ icon: "images"
         <Step title="Install Package">
             First, install the PraisonAI Agents package:
             ```bash
-            pip install praisonaiagents
+            pip install praisonaiagents opencv-python moviepy
             ```
         </Step>
         <Step title="Set API Key">
@@ -71,7 +71,7 @@ icon: "images"
         <Step title="Install Package">
             Install the PraisonAI package:
             ```bash
-            pip install praisonai
+            pip install praisonai opencv-python moviepy
             ```
         </Step>
         <Step title="Set API Key">

docs/features/rag.mdx

@@ -0,0 +1,352 @@
+---
+title: "RAG Agents"
+description: "Learn how to create AI agents that can efficiently interact with vector databases for knowledge retrieval and storage."
+icon: "database"
+---
+
+```mermaid
+flowchart LR
+    In[Input] --> RAGAgent[("RAG Agent")]
+    VDB[(Vector DB)] --> RAGAgent
+    RAGAgent --> Task[Knowledge Task]
+    Task --> |Query| VDB
+    Task --> Out[Output]
+    
+    style In fill:#8B0000,color:#fff
+    style RAGAgent fill:#2E8B57,color:#fff,shape:circle
+    style VDB fill:#4169E1,color:#fff,shape:cylinder
+    style Task fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+A knowledge-centric workflow where RAG (Retrieval Augmented Generation) agents interact with vector databases to store and retrieve information efficiently, enabling sophisticated question-answering and information retrieval capabilities.
+
+## Quick Start
+
+<Steps>
+  <Step title="Install Package">
+    Install PraisonAI Agents with knowledge support:
+    ```bash
+    pip install "praisonaiagents[knowledge]"
+    ```
+  </Step>
+
+  <Step title="Set API Key">
+    Set your OpenAI API key:
+    ```bash
+    export OPENAI_API_KEY=xxxxx
+    ```
+  </Step>
+
+  <Step title="Create Script">
+    Create a new file `app.py`:
+```python
+from praisonaiagents import Agent
+
+agent = Agent(
+    name="Knowledge Agent",
+    instructions="You answer questions based on the provided knowledge.",
+    knowledge=["small.pdf"], # Indexing
+)
+
+agent.start("What is KAG in one line?") # Retrieval
+```
+  </Step>
+</Steps>
+
+## Data Indexing and Retrieval Agents 
+
+<Note>
+  Indexing and Ingestion are relatively the same.
+</Note>
+
+```mermaid
+flowchart LR
+    subgraph In[Input]
+        PDF[PDF]
+        TXT[TXT]
+        MD[MD]
+    end
+
+    subgraph Router[Vector Store]
+        DB[(Vector DB)]
+    end
+    
+    subgraph Out[Agents]
+        A1[Agent 1]
+        A2[Agent 2]
+        A3[Agent 3]
+    end
+
+    In --> Router
+    Router --> A1
+    Router --> A2
+    Router --> A3
+
+    style In fill:#8B0000,color:#fff
+    style Router fill:#2E8B57,color:#fff
+    style Out fill:#8B0000,color:#fff
+```
+
+The simplest way to create a knowledge-based agent is without any configuration:
+
+```python
+from praisonaiagents import Agent
+
+agent = Agent(
+    name="Knowledge Agent",
+    instructions="You answer questions based on the provided knowledge.",
+    knowledge=["small.pdf"] # Indexing
+)
+
+agent.start("What is KAG in one line?") # Retrieval
+```
+
+### 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="Knowledge Agent",
+    instructions="You answer questions based on the provided knowledge.",
+    knowledge=["small.pdf"], # Indexing
+    knowledge_config=config # Configuration
+)
+
+agent.start("What is KAG in one line?") # Retrieval
+```
+
+### 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
+```
+
+## Retrieval Agents
+
+<Note>
+  Retrieval is the process of querying the vector database for information.
+  Considering there is data already in the Vector Database.
+</Note>
+
+<Steps>
+    <Step title="Install Package">
+        First, install the PraisonAI Agents package:
+        ```bash
+        pip install praisonaiagents
+        ```
+    </Step>
+
+    <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable in your terminal:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+    </Step>
+
+    <Step title="Create a file">
+        Create a new file `rag_agent.py` with the basic setup:
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Define the configuration for the Knowledge instance
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "praison",
+            "path": ".praison"
+        }
+    }
+}
+
+# Create an agent
+rag_agent = Agent(
+    name="RAG Agent",
+    role="Information Specialist",
+    goal="Retrieve knowledge efficiently",
+    llm="gpt-4o-mini"
+)
+
+# Define a task for the agent
+rag_task = Task(
+    name="RAG Task",
+    description="What is KAG?",
+    expected_output="Answer to the question",
+    agent=rag_agent,
+    context=[config] # Retrieval : Vector Database provided as context
+)
+
+# Build Agents
+agents = PraisonAIAgents(
+    agents=[rag_agent],
+    tasks=[rag_task],
+    user_id="user1"
+)
+
+# Start Agents
+agents.start()
+```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```bash
+        python rag_agent.py
+        ```
+    </Step>
+</Steps>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+  - ChromaDB or other supported vector database
+</Note>
+
+### Adding Knowledge to RAG Agents
+
+```python
+from praisonaiagents import Agent
+
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "praison",
+            "path": ".praison",
+        }
+    }
+}
+
+agent = Agent(
+    name="Knowledge Agent",
+    instructions="You answer questions based on the provided knowledge.",
+    knowledge=["small.pdf"], # Indexing
+    knowledge_config=config # Configuration
+)
+
+agent.start("What is KAG in one line?") # Retrieval
+```
+
+## Understanding RAG Agents
+
+<Card title="What are RAG Agents?" icon="question">
+  RAG (Retrieval Augmented Generation) agents enable:
+  - Efficient knowledge retrieval
+  - Semantic search capabilities
+  - Persistent knowledge storage
+  - Context-aware responses
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="RAG Architecture" icon="database">
+    Store and manage vector embeddings efficiently.
+  </Card>
+  <Card title="Semantic Search" icon="magnifying-glass">
+    Find relevant information using semantic similarity.
+  </Card>
+  <Card title="Knowledge Integration" icon="brain">
+    Seamlessly integrate with existing knowledge bases.
+  </Card>
+  <Card title="Context Management" icon="layer-group">
+    Handle complex contextual queries and responses.
+  </Card>
+</CardGroup>
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="RAG Issues" icon="triangle-exclamation">
+    If RAG system isn't working:
+    - Check database configuration
+    - Verify connection settings
+    - Enable verbose mode for debugging
+  </Card>
+
+  <Card title="Query Issues" icon="gauge-high">
+    If queries aren't returning expected results:
+    - Check embedding quality
+    - Verify search parameters
+    - Monitor similarity thresholds
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
+  </Card>
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal results, ensure your vector database is properly configured and indexed for your specific use case.
+</Note>

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/features/repetitive.mdx

@@ -0,0 +1,138 @@
+---
+title: "Repetitive Agents"
+description: "Learn how to create AI agents that can efficiently handle repetitive tasks through automated loops."
+icon: "repeat"
+---
+
+```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
+```
+
+A workflow optimization pattern where agents handle repetitive tasks through automated loops, processing multiple instances efficiently while maintaining consistency.
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Package">
+        First, install the PraisonAI Agents package:
+        ```bash
+        pip install praisonaiagents
+        ```
+    </Step>
+
+    <Step title="Set API Key">
+        Set your OpenAI API key as an environment variable in your terminal:
+        ```bash
+        export OPENAI_API_KEY=your_api_key_here
+        ```
+    </Step>
+
+    <Step title="Create a file">
+        Create a new file `repetitive_agent.py` with the basic setup:
+        ```python
+        from praisonaiagents import Agent, Task, PraisonAIAgents
+
+        agent = Agent(
+            instructions="You are a loop agent that creating a loop of tasks."
+        )
+
+        task = Task(
+            description="Create the list of tasks to be looped through.",
+            agent=agent,
+            task_type="loop",
+            input_file="tasks.csv"
+        )
+
+        agents = PraisonAIAgents(
+            agents=[agent],
+            tasks=[task],
+            process="workflow",
+            max_iter=30
+        )
+
+        agents.start()
+        ```
+    </Step>
+
+    <Step title="Start Agents">
+        Type this in your terminal to run your agents:
+        ```bash
+        python repetitive_agent.py
+        ```
+    </Step>
+</Steps>
+
+<Note>
+  **Requirements**
+  - Python 3.10 or higher
+  - OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys). Use Other models using [this guide](/models).   
+</Note>
+
+## Understanding Repetitive Agents
+
+<Card title="What are Repetitive Agents?" icon="question">
+  Repetitive agents enable:
+  - Automated task loops
+  - Batch processing
+  - Consistent task execution
+  - Efficient handling of multiple similar tasks
+</Card>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Task Looping" icon="repeat">
+    Process multiple tasks through automated loops.
+  </Card>
+  <Card title="Batch Processing" icon="layer-group">
+    Handle multiple similar tasks efficiently.
+  </Card>
+  <Card title="Input Management" icon="file-csv">
+    Process tasks from structured input files.
+  </Card>
+  <Card title="Progress Tracking" icon="chart-line">
+    Monitor task completion and progress.
+  </Card>
+</CardGroup>
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Loop Issues" icon="triangle-exclamation">
+    If loops aren't working as expected:
+    - Verify input file format
+    - Check task configurations
+    - Enable verbose mode for debugging
+  </Card>
+
+  <Card title="Performance Issues" icon="gauge-high">
+    If processing is slow:
+    - Check batch sizes
+    - Verify resource allocation
+    - Monitor memory usage
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="AutoAgents" icon="robot" href="./autoagents">
+    Learn about automatically created and managed AI agents
+  </Card>
+  <Card title="Mini Agents" icon="microchip" href="./mini">
+    Explore lightweight, focused AI agents
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal results, ensure your input files are properly formatted and your task configurations are appropriate for your use case.
+</Note>

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, 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: "/"
@@ -66,24 +66,53 @@ 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="Code">
+    <Steps>
+      <Step title="Install Package">
+        ```bash
+        pip install praisonaiagents
+        ```
+      </Step>
+      <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx
+        ```
+      </Step>
+      <Step title="Create File">
+        Create `app.py` file
+
+        ## Code Example
+
+<CodeGroup>
+```python Single Agent
+from praisonaiagents import Agent
+
+agent = Agent(instructions="Your are a helpful AI assistant")
+agent.start("Write a movie script about a robot in Mars")
+```
+
+```python Multi Agents
+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()
+```
+</CodeGroup>
+      </Step>
+      <Step title="Run Script">
+        ```bash
+        python app.py
+        ```
+      </Step>
+    </Steps>
+  </Tab>
   <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.
@@ -109,11 +138,11 @@ seo:
       </Step>
     </Steps>
   </Tab>
-  <Tab title="Code">
+  <Tab title="JavaScript">
     <Steps>
       <Step title="Install Package">
         ```bash
-        pip install praisonaiagents
+        npm install praisonai
         ```
       </Step>
       <Step title="Set API Key">
@@ -122,102 +151,390 @@ seo:
         ```
       </Step>
       <Step title="Create File">
-        Create `app.py` file
+        Create `app.js` file
 
         ## Code Example
 
 <CodeGroup>
-  ```python Basic
-  from praisonaiagents import Agent, Task, PraisonAIAgents
+```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');
+```
 
-  # 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"
-  )
+```javascript Multi Agents
+const { Agent, PraisonAIAgents } = require('praisonai');
 
-  # Define a task
-  task = Task(
-      name="research_task",
-      description="Analyze 2024's AI advancements",
-      expected_output="A detailed report",
-      agent=researcher
-  )
+const researchAgent = new Agent({ instructions: 'Research about AI' });
+const summariseAgent = new Agent({ instructions: 'Summarise research agent\'s findings' });
 
-  # Run the agents
-  agents = PraisonAIAgents(
-      agents=[researcher],
-      tasks=[task],
-      verbose=False
-  )
-
-  result = agents.start()
-  ```
-
-  ```python Advanced
-  from praisonaiagents import Agent, Task, PraisonAIAgents
-
-  # Create multiple agents
-  researcher = Agent(
-      name="Researcher",
-      role="Senior Research Analyst",
-      goal="Uncover cutting-edge developments in AI",
-      backstory="You are an expert at a technology research group",
-      verbose=True,
-      llm="gpt-4o",
-      markdown=True
-  )
-
-  writer = Agent(
-      name="Writer",
-      role="Tech Content Strategist",
-      goal="Craft compelling content on tech advancements",
-      backstory="You are a content strategist",
-      llm="gpt-4o",
-      markdown=True
-  )
-
-  # Define multiple tasks
-  task1 = Task(
-      name="research_task",
-      description="Analyze 2024's AI advancements",
-      expected_output="A detailed report",
-      agent=researcher
-  )
-
-  task2 = Task(
-      name="writing_task",
-      description="Create a blog post about AI advancements",
-      expected_output="A blog post",
-      agent=writer
-  )
-
-  # Run with hierarchical process
-  agents = PraisonAIAgents(
-      agents=[researcher, writer],
-      tasks=[task1, task2],
-      verbose=False,
-      process="hierarchical",
-      manager_llm="gpt-4o"
-  )
-
-  result = agents.start()
-  ```
+const agents = new PraisonAIAgents({ agents: [researchAgent, summariseAgent] });
+agents.start();
+```
 </CodeGroup>
       </Step>
       <Step title="Run Script">
         ```bash
-        python app.py
+        node app.js
         ```
       </Step>
     </Steps>
   </Tab>
 </Tabs>
 
+## 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>
@@ -338,4 +655,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,9 @@ pip install praisonaiagents
 ```bash No Code
 pip install praisonai
 ```
+```bash JavaScript
+npm install praisonai
+```
 </RequestExample>
 
 <Note>
@@ -90,6 +93,22 @@ 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>
 </Tabs>
 
 Generate your OpenAI API key from [OpenAI](https://platform.openai.com/api-keys)

docs/introduction.mdx

@@ -89,143 +89,163 @@ 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>
 </Tabs>

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,266 @@
+---
+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>

docs/mint.json

@@ -74,6 +74,10 @@
     {
         "name": "Tools",
         "url": "/tools"
+    },
+    {
+        "name": "JS",
+        "url": "/js"
     }
   ],
   "navigation": [
@@ -108,23 +112,30 @@
         "features/autonomous-workflow",
         "features/parallelisation",
         "features/promptchaining",
-        "features/evaluator-optimiser"
+        "features/evaluator-optimiser",
+        "features/repetitive"
       ]
     },
     {
       "group": "Features",
       "pages": [
+        "features/cli",
         "features/autoagents",
+        "features/image-generation",
         "features/selfreflection",
+        "features/rag",
+        "features/reasoning-extract",
         "features/reasoning",
         "features/multimodal",
         "features/langchain",
         "features/async",
         "features/mini",
+        "features/generate-reasoning",
         "features/codeagent",
         "features/mathagent",
         "features/structured",
-        "features/callbacks"
+        "features/callbacks",
+        "features/chat-with-pdf"
       ]
     },
     {
@@ -139,6 +150,7 @@
         "models/anthropic",
         "models/cohere",
         "models/mistral",
+        "models/deepseek",
         "models/other"
       ]
     },
@@ -146,6 +158,8 @@
       "group": "Examples",
       "pages": [
         "examples/examples",
+        "examples/code-analysis",
+        "examples/hackathon-judge",
         "examples/predictive-maintenance",
         "examples/emergency-response",
         "examples/code-review",
@@ -226,6 +240,16 @@
         "tools/googlecalendar"
       ]
     },
+    {
+      "group": "JavaScript",
+      "pages": [
+        "js/js",
+        "js/typescript",
+        "js/nodejs",
+        "js/typescript-async",
+        "js/development"
+      ]
+    },
     {
       "group": "Other Features",
       "pages": [
@@ -240,7 +264,18 @@
       "pages": [
         "ui/overview",
         "ui/gradio",
-        "ui/streamlit",
+        {
+          "group": "Streamlit",
+          "icon": "pen-paintbrush",
+          "pages": [
+            "ui/streamlit",
+            "ui/streamlit/code-analysis-streamlit",
+            "ui/streamlit/hackathon-judge-streamlit",
+            "ui/streamlit/ollama-streamlit",
+            "ui/streamlit/deepseek-streamlit",
+            "ui/streamlit/gemini-streamlit"
+          ]
+        },
         "ui/ui",
         "ui/chat",
         "ui/code"
@@ -259,6 +294,7 @@
         "developers/wrapper-tools",
         "developers/googlecolab",
         "developers/googlecolab-tools",
+        "developers/local-development",
         "deploy"
       ]
     },

docs/models.mdx

@@ -4,7 +4,184 @@ description: "Overview of supported language models in PraisonAI, including Open
 icon: "brain"
 ---
 
-## Supported Models for Code
+# Code
+
+## Set model by 3 ways
+
+### 1. OpenAI Compatible Endpoints
+
+<Note>By Default it uses OPENAI_BASE_URL https://api.openai.com/v1 </Note>
+Example Groq Implementation:
+
+```bash
+export OPENAI_API_KEY=groq-api-key
+export OPENAI_BASE_URL=https://api.groq.com/openai/v1
+```
+
+```python
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="llama-3.1-8b-instant",
+)
+
+agent.start("Why sky is Blue?")
+```
+
+### 2. Litellm Compatible model names (eg: gemini/gemini-1.5-flash-8b)
+
+```bash
+pip install "praisonaiagents[llm]"
+```
+
+```python
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="gemini/gemini-1.5-flash-8b",
+    self_reflect=True,
+    verbose=True
+)
+
+agent.start("Why sky is Blue?")
+```
+
+### 3. Litellm Compatible Configuration
+
+```bash
+pip install "praisonaiagents[llm]"
+```
+
+```python 
+from praisonaiagents import Agent
+
+llm_config = {
+    "model": "gemini/gemini-1.5-flash-latest",  # Model name without provider prefix
+    
+    # Core settings
+    "temperature": 0.7,                # Controls randomness (like temperature)
+    "timeout": 30,                 # Timeout in seconds
+    "top_p": 0.9,                    # Nucleus sampling parameter
+    "max_tokens": 1000,               # Max tokens in response
+    
+    # Advanced parameters
+    "presence_penalty": 0.1,         # Penalize repetition of topics (-2.0 to 2.0)
+    "frequency_penalty": 0.1,        # Penalize token repetition (-2.0 to 2.0)
+    
+    # API settings (optional)
+    "api_key": None,                 # Your API key (or use environment variable)
+    "base_url": None,                # Custom API endpoint if needed
+    
+    # Response formatting
+    "response_format": {             # Force specific response format
+        "type": "text"               # Options: "text", "json_object"
+    },
+    
+    # Additional controls
+    "seed": 42,                      # For reproducible responses
+    "stop_phrases": ["##", "END"],   # Custom stop sequences
+}
+
+agent = Agent(
+    instructions="You are a helpful Assistant."
+    llm=llm_config
+)
+agent.start()
+```
+
+## Advanced Configuration (Litellm Support)
+
+<Note>This uses Litellm</Note>
+<Steps>
+  <Step title="Install Package">
+    Install required packages:
+    ```bash
+    pip install "praisonaiagents[llm]"
+    ```
+  </Step>
+
+  <Step title="Setup Environment">
+    Configure environment:
+    ```bash
+    export GOOGLE_API_KEY=your-api-key
+    ```
+    
+    <Note>
+    Get your API key from [Google AI Studio](https://makersuite.google.com/app/apikey)
+    </Note>
+  </Step>
+
+  <Step title="Create Agent">
+    Create `app.py`:
+
+<CodeGroup>
+
+```python Basic
+# if json_object is supported by the model
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="gemini/gemini-1.5-flash-8b",
+    self_reflect=True,
+    verbose=True
+)
+
+agent.start("Why sky is Blue?")
+```
+
+```python Advanced 
+# if json_object is not supported by the model
+from praisonaiagents import Agent
+
+# Detailed LLM configuration
+llm_config = {
+    "model": "gemini/gemini-1.5-flash-latest",  # Model name without provider prefix
+    
+    # Core settings
+    "temperature": 0.7,                # Controls randomness (like temperature)
+    "timeout": 30,                 # Timeout in seconds
+    "top_p": 0.9,                    # Nucleus sampling parameter
+    "max_tokens": 1000,               # Max tokens in response
+    
+    # Advanced parameters
+    "presence_penalty": 0.1,         # Penalize repetition of topics (-2.0 to 2.0)
+    "frequency_penalty": 0.1,        # Penalize token repetition (-2.0 to 2.0)
+    
+    # API settings (optional)
+    "api_key": None,                 # Your API key (or use environment variable)
+    "base_url": None,                # Custom API endpoint if needed
+    
+    # Response formatting
+    "response_format": {             # Force specific response format
+        "type": "text"               # Options: "text", "json_object"
+    },
+    
+    # Additional controls
+    "seed": 42,                      # For reproducible responses
+    "stop_phrases": ["##", "END"],   # Custom stop sequences
+}
+
+agent = Agent(
+    instructions="You are a helpful Assistant specialized in scientific explanations. "
+                "Provide clear, accurate, and engaging responses.",
+    llm=llm_config,                  # Pass the detailed configuration
+    verbose=True,                    # Enable detailed output
+    markdown=True,                   # Format responses in markdown
+    self_reflect=True,              # Enable self-reflection
+    max_reflect=3,                  # Maximum reflection iterations
+    min_reflect=1                   # Minimum reflection iterations
+)
+
+# Test the agent
+response = agent.start("Why is the sky blue? Please explain in simple terms.")
+
+```
+</CodeGroup>
+</Step>
+</Steps>
 
 <AccordionGroup>
   <Accordion title="Ollama Integration" defaultOpen>

docs/models/deepseek.mdx

@@ -0,0 +1,253 @@
+---
+title: "DeepSeek Agents"
+
+description: "Learn how to use Deepseek models with PraisonAI Agents for various applications."
+icon: "brain"
+---
+
+```mermaid
+flowchart LR
+    In[Input] --> Ollama[("Ollama")]
+    Ollama --> DS[("Deepseek")]
+    DS --> Basic[Basic Agent]
+    DS --> RAG[RAG Agent]
+    DS --> UI[UI Agent]
+    Basic --> Out1[Output]
+    RAG --> Out2[Output]
+    UI --> Out3[Output]
+    
+    style In fill:#8B0000,color:#fff
+    style Ollama fill:#4169E1,color:#fff,shape:circle
+    style DS fill:#2E8B57,color:#fff,shape:circle
+    style Basic fill:#2E8B57,color:#fff
+    style RAG fill:#2E8B57,color:#fff
+    style UI fill:#2E8B57,color:#fff
+    style Out1 fill:#8B0000,color:#fff
+    style Out2 fill:#8B0000,color:#fff
+    style Out3 fill:#8B0000,color:#fff
+```
+
+Learn how to use Deepseek models with PraisonAI Agents through Ollama integration for basic queries, RAG applications, and interactive UI implementations.
+
+## Prerequisites
+
+<Steps>
+    <Step title="Install Ollama">
+        First, install Ollama on your system:
+        ```bash
+        curl -fsSL https://ollama.com/install.sh | sh
+        ```
+    </Step>
+
+    <Step title="Pull Deepseek Model">
+        Pull the Deepseek model from Ollama:
+        ```bash
+        ollama pull deepseek-r1
+        ```
+    </Step>
+
+    <Step title="Install Package">
+        Install PraisonAI Agents:
+        ```bash
+        pip install "praisonaiagents[knowledge]" ollama streamlit
+        ```
+
+        <Note> 
+        Streamlit for UI is optional.
+        Ollama is required for Local RAG Agents.
+        praisonaiagents[knowledge] is for RAG Agents. praisonaiagents is for Basic Agents.
+        </Note>
+    </Step>
+
+    <Step title="Set Environment">
+        Set Ollama as your base URL:
+        ```bash
+        export OPENAI_BASE_URL=http://localhost:11434/v1
+        export OPENAI_API_KEY=fake-key
+        ```
+    </Step>
+</Steps>
+
+## Basic Usage
+
+The simplest way to use Deepseek with PraisonAI Agents:
+
+```python
+from praisonaiagents import Agent
+
+agent = Agent(instructions="You are helpful Assisant", llm="deepseek-r1")
+
+agent.start("Why sky is Blue?")
+```
+
+## RAG Implementation
+
+Use Deepseek with RAG capabilities for knowledge-based interactions:
+
+```python
+from praisonaiagents import Agent
+
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "praison",
+            "path": ".praison"
+        }
+    },
+    "llm": {
+        "provider": "ollama",
+        "config": {
+            "model": "deepseek-r1:latest",
+            "temperature": 0,
+            "max_tokens": 8000,
+            "ollama_base_url": "http://localhost:11434",
+        },
+    },
+    "embedder": {
+        "provider": "ollama",
+        "config": {
+            "model": "nomic-embed-text:latest",
+            "ollama_base_url": "http://localhost:11434",
+            "embedding_dims": 1536
+        },
+    },
+}
+
+agent = Agent(
+    name="Knowledge Agent",
+    instructions="You answer questions based on the provided knowledge.",
+    knowledge=["kag-research-paper.pdf"], # Indexing
+    knowledge_config=config,
+    user_id="user1",
+    llm="deepseek-r1"
+)
+
+agent.start("What is KAG in one line?") # Retrieval
+```
+
+## Interactive UI with Streamlit
+
+Create an interactive chat interface using Streamlit:
+
+```python
+import streamlit as st
+from praisonaiagents import Agent
+
+def init_agent():
+    config = {
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "collection_name": "praison",
+                "path": ".praison"
+            }
+        },
+        "llm": {
+            "provider": "ollama",
+            "config": {
+                "model": "deepseek-r1:latest",
+                "temperature": 0,
+                "max_tokens": 8000,
+                "ollama_base_url": "http://localhost:11434",
+            },
+        },
+        "embedder": {
+            "provider": "ollama",
+            "config": {
+                "model": "nomic-embed-text:latest",
+                "ollama_base_url": "http://localhost:11434",
+                "embedding_dims": 1536
+            },
+        },
+    }
+    
+    return Agent(
+        name="Knowledge Agent",
+        instructions="You answer questions based on the provided knowledge.",
+        knowledge=["kag-research-paper.pdf"],
+        knowledge_config=config,
+        user_id="user1",
+        llm="deepseek-r1"
+    )
+
+st.title("Knowledge Agent Chat")
+
+if "agent" not in st.session_state:
+    st.session_state.agent = init_agent()
+    st.session_state.messages = []
+
+if "messages" in st.session_state:
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+prompt = st.chat_input("Ask a question...")
+
+if prompt:
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        response = st.session_state.agent.start(prompt)
+        st.markdown(response)
+        st.session_state.messages.append({"role": "assistant", "content": response}) 
+```
+
+## Running the UI
+
+<Steps>
+    <Step title="Install Streamlit">
+        Install Streamlit if you haven't already:
+        ```bash
+        pip install streamlit
+        ```
+    </Step>
+
+    <Step title="Save and Run">
+        Save the UI code in a file (e.g., `app.py`) and run:
+        ```bash
+        streamlit run app.py
+        ```
+    </Step>
+</Steps>
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Local Deployment" icon="server">
+    Run Deepseek models locally through Ollama.
+  </Card>
+  <Card title="RAG Capabilities" icon="database">
+    Integrate with vector databases for knowledge retrieval.
+  </Card>
+  <Card title="Interactive UI" icon="desktop">
+    Create chat interfaces with Streamlit integration.
+  </Card>
+  <Card title="Custom Configuration" icon="gear">
+    Configure model parameters and embedding settings.
+  </Card>
+</CardGroup>
+
+## Troubleshooting
+
+<CardGroup cols={2}>
+  <Card title="Ollama Issues" icon="triangle-exclamation">
+    If Ollama isn't working:
+    - Check if Ollama is running
+    - Verify model is downloaded
+    - Check port availability
+  </Card>
+
+  <Card title="Performance Issues" icon="gauge-high">
+    If responses are slow:
+    - Check system resources
+    - Adjust max_tokens
+    - Monitor memory usage
+  </Card>
+</CardGroup>
+
+<Note>
+  For optimal performance, ensure your system meets the minimum requirements for running Deepseek models locally through Ollama.
+</Note>

docs/models/google.mdx

@@ -1,12 +1,166 @@
 ---
-title: "Google Gemini"
+title: "Google Gemini Agents"
+sidebarTitle: "Google Gemini"
 description: "Instructions for integrating Google's Gemini models with PraisonAI, including API setup and configuration details"
 icon: "google"
 ---
 
-# Add Google Gemini to Praison AI
+```mermaid
+flowchart LR
+    In[Input] --> API[("Google API")]
+    API --> Gemini[("Gemini")]
+    Gemini --> Basic[Basic Agent]
+    Gemini --> Multi[Multi-Agents]
+    Gemini --> YAML[No-Code]
+    Basic --> Out1[Output]
+    Multi --> Out2[Output]
+    YAML --> Out3[Output]
+    
+    style In fill:#8B0000,color:#fff
+    style API fill:#4169E1,color:#fff,shape:circle
+    style Gemini fill:#2E8B57,color:#fff,shape:circle
+    style Basic fill:#2E8B57,color:#fff
+    style Multi fill:#2E8B57,color:#fff
+    style YAML fill:#2E8B57,color:#fff
+    style Out1 fill:#8B0000,color:#fff
+    style Out2 fill:#8B0000,color:#fff
+    style Out3 fill:#8B0000,color:#fff
+```
 
-## Code
+## Prerequisites
+
+<Steps>
+    <Step title="Install Package">
+        First, install PraisonAI Agents:
+        ```bash
+        pip install "praisonaiagents[llm]"
+        ```
+
+        <Note>
+        praisonaiagents[llm] includes all Google Gemini dependencies.
+        For No-Code implementation, also install: pip install langchain-google-genai
+        </Note>
+    </Step>
+
+    <Step title="Set API Key">
+        Set your Gemini API key:
+        ```bash
+        export GEMINI_API_KEY=xxxxxxxxxxx
+        ```
+    </Step>
+
+    <Step title="Code">
+```python
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="gemini/gemini-1.5-flash-8b",
+    self_reflect=True,
+    verbose=True
+)
+
+agent.start("Why sky is Blue?")
+```
+    </Step>
+</Steps>
+
+## Code Implementation
+
+### Basic Usage
+
+The simplest way to use Gemini with PraisonAI Agents:
+
+```python
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="gemini/gemini-1.5-flash-8b",
+    self_reflect=True,
+    verbose=True
+)
+
+agent.start("Why sky is Blue?")
+```
+
+### Multi-Agent Setup
+
+Create multiple agents working together:
+
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="gemini/gemini-1.5-flash-8b",
+    self_reflect=True,
+    verbose=True
+)
+
+task = Task(
+    description="Why sky is Blue?",
+    agent=agent,
+)
+
+agents = PraisonAIAgents(
+  agents=[agent],
+  tasks=[task],
+)
+
+agents.start()
+```
+
+<Note>
+  This uses Litellm to connect to Google Gemini.
+</Note>
+
+## Gemini 2.0 Flash Thinking
+
+### LLM Configuration
+```python
+llm_config = {
+  "model": "gemini/gemini-2.0-flash-thinking-exp-01-21",
+  "response_format": {"type": "text"} # type is text, because json_object is not supported
+}
+```
+
+<Steps>
+    <Step title="Install Package">
+        Install required packages:
+        ```bash
+        pip install "praisonaiagents[llm]"
+        ```
+    </Step>
+
+    <Step title="Set API Key">
+        Set your Gemini API key:
+        ```bash
+        export GEMINI_API_KEY=xxxxxxxxxxx
+        ```
+    </Step>
+
+    <Step title="Code">
+
+```python
+from praisonaiagents import Agent
+
+llm_config = {"model": "gemini/gemini-2.0-flash-thinking-exp-01-21","response_format": {"type": "text"}}
+
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm=llm_config
+)
+
+result = agent.start("Why sky is Blue?")
+print(result)
+```
+    </Step>
+</Steps>
+
+## Alternative Setup
+
+### Using Environment Variables
 
 <AccordionGroup>
   <Accordion title="Google Gemini" defaultOpen> 
@@ -16,16 +170,18 @@ icon: "google"
     ```
   </Accordion>
 </AccordionGroup>
-## No Code
 
+## No-Code Implementation
+
+### Setup
 ```bash
 pip install langchain-google-genai
-```
-```bash
 export GOOGLE_API_KEY=xxxxxxxxxx
 ```
 
-### agents.yaml file
+### YAML Configuration
+
+Create an `agents.yaml` file:
 
 ```yaml
 framework: crewai
@@ -48,6 +204,8 @@ roles:
     - ''
 ```
 
+## Additional Resources
+
 | PraisonAI Chat | PraisonAI Code | PraisonAI (Multi-Agents) |
 | --- | --- | --- |
 | [Litellm](https://litellm.vercel.app/docs/providers) | [Litellm](https://litellm.vercel.app/docs/providers) | [Models](../models.md) |

docs/quickstart.mdx

@@ -125,6 +125,48 @@ praisonai --init "your task description"
       </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>
 </Tabs>
 
 <Note>

docs/tools/reddit.mdx

@@ -12,6 +12,46 @@ export REDDIT_CLIENT_SECRET=xxxxxx
 export REDDIT_CLIENT_ID=xxxxxx
 ```
 
+[USER] in this format script:APP:v1.0(by/u/USERNAME)
+
+```bash
+pip install praisonai langchain_community praw
+```
+
+```bash
+export OPENAI_API_KEY="Enter your API key"
+```
+
+## Code
+
+### Single Agent
+
+```python
+from praisonaiagents import Agent
+from langchain_community.tools.reddit_search.tool import RedditSearchRun
+
+agent = Agent(name="RedditSearchAgent",instructions="Search Reddit for information", tools=[RedditSearchRun],)
+
+agent.start("Search Reddit for information about the latest AI advancements in subreddit all")
+```
+
+### Multi Agents
+
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from langchain_community.tools.reddit_search.tool import RedditSearchRun
+
+agent = Agent(name="RedditSearchAgent",instructions="Search Reddit for information", tools=[RedditSearchRun],)
+
+task = Task(description="Search Reddit for information about the latest AI news in subreddit all", agent=agent)
+
+agents = PraisonAIAgents(agents=[agent],tasks=[task])
+
+agents.start()
+```
+
+## No Code 
+
 tools.py
 
 ```python

docs/train.mdx

@@ -20,6 +20,20 @@ icon: "dumbbell"
 export HF_TOKEN=xxxxxxxxxxxxxx
 ```
 
+## Initilise praisonai train
+
+```bash
+praisonai train init
+```
+
+## Required
+
+1. Huggingface token
+2. Base model to train on (e.g. unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit)
+3. Dataset to train on (e.g. yahma/alpaca-cleaned)
+4. Huggingface model name to upload to (e.g. mervinpraison/llama3.1-instruct) (Optional)
+5. Ollama model name to upload to (e.g. mervinpraison/llama3.1-instruct) (Optional)
+
 ## To upload to ollama.com (Linux)
 
 ```bash
@@ -108,4 +122,21 @@ quantization_method:
 
 ```bash
 praisonai train
+```
+
+## wandb
+
+```bash
+wandb login
+```
+
+<Note>
+Get the key from [here](https://wandb.ai/site/login)
+</Note>
+
+```bash
+export PRAISON_WANDB=True
+export WANDB_LOG_MODEL=checkpoint
+export WANDB_PROJECT=praisonai-test
+export PRAISON_WANDB_RUN_NAME=praisonai-train  
 ```

docs/ui/streamlit/code-analysis-streamlit.mdx

@@ -0,0 +1,333 @@
+---
+title: "Code Analysis Agent UI"
+sidebarTitle: "Code Analysis"
+description: "Build an interactive web interface for analyzing code quality and providing detailed recommendations using Streamlit and AI agents."
+icon: "laptop-code"
+---
+
+```mermaid
+flowchart LR
+    Input[Input URL] --> Process[Process Code]
+    Process --> Analyze[AI Analysis]
+    Analyze --> Display[Display Results]
+    Display --> Metrics[Show Metrics]
+    Display --> Details[Show Details]
+    
+    style Input fill:#8B0000,color:#fff
+    style Process fill:#2E8B57,color:#fff
+    style Analyze fill:#2E8B57,color:#fff
+    style Display fill:#2E8B57,color:#fff
+    style Metrics fill:#2E8B57,color:#fff
+    style Details fill:#2E8B57,color:#fff
+```
+
+## What is the Code Analysis Streamlit App?
+
+The Code Analysis Streamlit App provides a user-friendly web interface for analyzing code repositories and generating comprehensive quality assessments. It combines AI-powered code analysis with an interactive dashboard to display detailed metrics, recommendations, and insights.
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Repository Analysis" icon="code-branch">
+    Support for GitHub URLs and local code repositories.
+  </Card>
+  <Card title="Real-time Processing" icon="spinner">
+    Live analysis and evaluation of code.
+  </Card>
+  <Card title="Interactive Metrics" icon="chart-column">
+    Visual presentation of code quality metrics.
+  </Card>
+  <Card title="Detailed Reports" icon="file-lines">
+    Comprehensive analysis of code structure and patterns.
+  </Card>
+  <Card title="Best Practices" icon="check-double">
+    Evaluation against industry best practices.
+  </Card>
+</CardGroup>
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Dependencies">
+        Install the required packages:
+        ```bash
+        pip install streamlit praisonaiagents gitingest
+        ```
+    </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 the App">
+        Create a new file `code_analysis_app.py` with the following code:
+```python
+import streamlit as st
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from pydantic import BaseModel
+from typing import List, Dict, Any
+from gitingest import ingest
+
+# Import the same classes and code from code-analysis-agents.py
+class CodeMetrics(BaseModel):
+    category: str
+    score: int
+    findings: List[str]
+
+class CodeAnalysisReport(BaseModel):
+    overall_quality: int
+    code_metrics: List[CodeMetrics]
+    architecture_score: int
+    maintainability_score: int
+    performance_score: int
+    security_score: int
+    test_coverage: int
+    key_strengths: List[str]
+    improvement_areas: List[str]
+    tech_stack: List[str]
+    recommendations: List[str]
+    complexity_metrics: Dict[str, int]
+    best_practices: List[Dict[str, str]]
+    potential_risks: List[str]
+    documentation_quality: int
+
+def analyze_code(code_source: str) -> CodeAnalysisReport:
+    """
+    Analyze code from directory path or GitHub URL
+    """
+    # Create code analyzer agent
+    code_analyzer = Agent(
+        role="Code Analysis Expert",
+        goal="Provide comprehensive code evaluation and recommendations",
+        backstory="""Expert code analyst specializing in architecture review, 
+        best practices, and technical debt assessment.""",
+        verbose=True
+    )
+
+    # Create analysis task
+    code_analysis_task = Task(
+        description="""Analyze code repository and provide structured evaluation:
+        
+        1. Overall Quality (0-100)
+        2. Core Metrics Analysis:
+           - Architecture and Design
+           - Code Maintainability
+           - Performance Optimization
+           - Security Practices
+           - Test Coverage
+        3. Technical Assessment:
+           - Technology Stack Review
+           - Code Complexity Analysis
+           - Best Practices Adherence
+           - Risk Assessment
+        4. Recommendations:
+           - Key Improvements
+           - Architecture Suggestions
+           - Security Enhancements""",
+        expected_output="Detailed code analysis report with metrics and recommendations",
+        agent=code_analyzer,
+        output_pydantic=CodeAnalysisReport
+    )
+
+    # Ingest code content
+    summary, tree, content = ingest(code_source)
+    
+    # Concatenate context into structured format
+    context_text = f"""
+    CODE REPOSITORY ANALYSIS
+    =======================
+    
+    SUMMARY
+    -------
+    {summary}
+    
+    REPOSITORY STRUCTURE
+    -------------------
+    {tree}
+    
+    SOURCE CODE
+    -----------
+    {content}
+    """
+    
+    # Initialize and run analysis
+    agents = PraisonAIAgents(
+        agents=[code_analyzer],
+        tasks=[code_analysis_task]
+    )
+    
+    result = agents.start(context_text)
+    
+    # Extract the Pydantic model from the result
+    if isinstance(result, dict) and 'task_results' in result:
+        # Get the first task result's pydantic output
+        analysis_result = result['task_results'][0].pydantic
+        if isinstance(analysis_result, CodeAnalysisReport):
+            return analysis_result
+    
+    # If we can't get the Pydantic model, create one from the raw data
+    return CodeAnalysisReport(**result)
+
+def display_code_metrics(metrics, cols):
+    """Display code metrics in columns with color-coded scores"""
+    for i, metric in enumerate(metrics):
+        score = metric.score
+        color = "red" if score < 60 else "orange" if score < 75 else "green"
+        
+        # Use modulo to alternate between columns
+        with cols[i % len(cols)]:
+            st.markdown(f"### {metric.category}")
+            st.markdown(f"**Score:** :{color}[{score}%]")
+            for finding in metric.findings:
+                st.markdown(f"• {finding}")
+
+def display_section(title: str, items: list, icon: str = "•"):
+    """Display a section with items in a consistent format"""
+    st.markdown(f"### {title}")
+    for item in items:
+        if isinstance(item, dict):
+            for key, value in item.items():
+                st.markdown(f"{icon} **{key}**: {value}")
+        else:
+            st.markdown(f"{icon} {item}")
+
+def main():
+    st.set_page_config(
+        page_title="Code Analysis Agent",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    st.title("Code Analysis Agent")
+    
+    with st.sidebar:
+        st.header("Input")
+        code_source = st.text_input(
+            "GitHub URL or Local Path",
+            placeholder="https://github.com/username/repo or /path/to/directory"
+        )
+        analyze_button = st.button("Analyze Code", type="primary")
+    
+    if analyze_button and code_source:
+        try:
+            with st.spinner("Analyzing code..."):
+                result = analyze_code(code_source)
+                
+                # Overall Metrics
+                st.header("Overall Metrics")
+                cols = st.columns(6)
+                metrics = {
+                    "Overall Quality": result.overall_quality,
+                    "Architecture": result.architecture_score,
+                    "Maintainability": result.maintainability_score,
+                    "Performance": result.performance_score,
+                    "Security": result.security_score,
+                    "Test Coverage": result.test_coverage
+                }
+                
+                for (metric, value), col in zip(metrics.items(), cols):
+                    color = "red" if value < 60 else "orange" if value < 75 else "green"
+                    col.metric(metric, f"{value}%")
+                    col.markdown(f":{color}[{'●' * (value // 20)}]")
+                
+                # Detailed Analysis
+                st.header("Detailed Analysis")
+                metric_cols = st.columns(2)
+                display_code_metrics(result.code_metrics, metric_cols)
+                
+                # Technology Stack
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.header("Technology Stack")
+                    for tech in result.tech_stack:
+                        st.markdown(f"🔧 {tech}")
+                
+                with col2:
+                    st.header("Complexity Metrics")
+                    for metric, value in result.complexity_metrics.items():
+                        st.metric(metric.replace('_', ' ').title(), value)
+                
+                # Key Findings
+                st.header("Key Findings")
+                cols = st.columns(2)
+                
+                with cols[0]:
+                    display_section("✅ Strengths", result.key_strengths)
+                    display_section("🔄 Best Practices", result.best_practices)
+                
+                with cols[1]:
+                    display_section("⚠️ Areas for Improvement", result.improvement_areas)
+                    display_section("❗ Potential Risks", result.potential_risks)
+                
+                # Recommendations
+                st.header("Recommendations")
+                for i, rec in enumerate(result.recommendations, 1):
+                    st.markdown(f"**{i}.** {rec}")
+                
+                # Documentation Quality
+                st.header("Documentation")
+                doc_score = result.documentation_quality
+                color = "red" if doc_score < 60 else "orange" if doc_score < 75 else "green"
+                st.markdown(f"Documentation Quality: :{color}[{doc_score}%]")
+                
+        except Exception as e:
+            st.error(f"Error analyzing code: {str(e)}")
+            st.exception(e)
+    
+    elif analyze_button:
+        st.warning("Please enter a GitHub URL or local path")
+
+if __name__ == "__main__":
+    main()
+```
+    </Step>
+
+    <Step title="Run the App">
+        Start the Streamlit app:
+        ```bash
+        streamlit run code_analysis_app.py
+        ```
+    </Step>
+</Steps>
+
+## Understanding the Interface
+
+The Streamlit app provides an intuitive interface with the following sections:
+
+- **Input**: GitHub URL or local path input in the sidebar
+- **Overall Metrics**: Visual display of key quality scores
+  - Overall Quality
+  - Architecture Score
+  - Maintainability Score
+  - Performance Score
+  - Security Score
+  - Test Coverage
+- **Detailed Analysis**:
+  - Code Metrics with Findings
+  - Technology Stack Overview
+  - Complexity Metrics
+- **Key Findings**:
+  - Strengths
+  - Best Practices
+  - Areas for Improvement
+  - Potential Risks
+- **Additional Information**:
+  - Recommendations
+  - Documentation Quality Assessment
+
+## Next Steps
+
+<CardGroup>
+  <Card title="Streamlit Docs" icon="book" href="https://docs.streamlit.io">
+    Learn more about Streamlit features
+  </Card>
+  <Card title="PraisonAI Docs" icon="bolt" href="/introduction">
+    Explore PraisonAI capabilities
+  </Card>
+  <Card title="Examples" icon="code" href="/examples">
+    View more example applications
+  </Card>
+</CardGroup>

docs/ui/streamlit/deepseek-streamlit.mdx

@@ -0,0 +1,158 @@
+---
+title: "Deepseek Streamlit UI"
+description: "Create interactive chat interfaces with Deepseek models using Streamlit"
+icon: "window"
+---
+
+```mermaid
+flowchart LR
+    In[Input] --> UI[("Streamlit UI")]
+    VDB[(Vector DB)] --> Agent
+    DS[("Deepseek")] --> Agent
+    UI --> Agent[("Knowledge Agent")]
+    Agent --> |Query| VDB
+    Agent --> Out[Output]
+    Out --> UI
+    
+    style In fill:#8B0000,color:#fff
+    style UI fill:#FF4B4B,color:#fff,shape:circle
+    style DS fill:#4169E1,color:#fff,shape:circle
+    style Agent fill:#2E8B57,color:#fff,shape:circle
+    style VDB fill:#4169E1,color:#fff,shape:cylinder
+    style Out fill:#8B0000,color:#fff
+```
+
+## Prerequisites
+
+<Steps>
+    <Step title="Install Package">
+        Install required packages:
+        ```bash
+        pip install "praisonaiagents[knowledge]" streamlit ollama
+        ```
+
+        <Note>
+        streamlit for UI
+        ollama for Deepseek model hosting
+        praisonaiagents[knowledge] for RAG capabilities
+        </Note>
+    </Step>
+
+    <Step title="Setup Model">
+        Pull Deepseek model:
+        ```bash
+        # Large Language Model
+        ollama pull deepseek-r1
+        
+        # Embedding Model
+        ollama pull nomic-embed-text
+        ```
+    </Step>
+
+    <Step title="Setup Environment">
+        Configure environment:
+        ```bash
+        export OPENAI_BASE_URL=http://localhost:11434/v1
+        export OPENAI_API_KEY=fake-key
+        ```
+    </Step>
+
+    <Step title="Create File">
+        Create a new file called `app.py` and add the following code:
+    </Step>
+
+    <Step title="Run Application">
+        Start the Streamlit application:
+        ```bash
+        streamlit run app.py
+        ```
+    </Step>
+</Steps>
+
+## Code
+
+```python
+import streamlit as st
+from praisonaiagents import Agent
+
+def init_agent():
+    config = {
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "collection_name": "praison",
+                "path": ".praison"
+            }
+        },
+        "llm": {
+            "provider": "ollama",
+            "config": {
+                "model": "deepseek-r1:latest",
+                "temperature": 0,
+                "max_tokens": 8000,
+                "ollama_base_url": "http://localhost:11434",
+            },
+        },
+        "embedder": {
+            "provider": "ollama",
+            "config": {
+                "model": "nomic-embed-text:latest",
+                "ollama_base_url": "http://localhost:11434",
+                "embedding_dims": 1536
+            },
+        },
+    }
+    
+    return Agent(
+        name="Knowledge Agent",
+        instructions="You answer questions based on the provided knowledge.",
+        knowledge=["kag-research-paper.pdf"],
+        knowledge_config=config,
+        user_id="user1",
+        llm="deepseek-r1"
+    )
+
+st.title("Knowledge Agent Chat")
+
+if "agent" not in st.session_state:
+    st.session_state.agent = init_agent()
+    st.session_state.messages = []
+
+if "messages" in st.session_state:
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+prompt = st.chat_input("Ask a question...")
+
+if prompt:
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        response = st.session_state.agent.start(prompt)
+        st.markdown(response)
+        st.session_state.messages.append({"role": "assistant", "content": response}) 
+```
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Interactive Chat" icon="comments">
+    Real-time chat interface with message history.
+  </Card>
+  <Card title="Knowledge Base" icon="database">
+    RAG capabilities with ChromaDB integration.
+  </Card>
+  <Card title="Model Integration" icon="server">
+    Uses Deepseek through Ollama.
+  </Card>
+  <Card title="Session Management" icon="clock-rotate-left">
+    Maintains chat history in session state.
+  </Card>
+</CardGroup>
+
+<Note>
+  Make sure your system meets the requirements for running Deepseek models locally through Ollama.
+</Note>

docs/ui/streamlit/gemini-streamlit.mdx

@@ -0,0 +1,119 @@
+---
+title: "Gemini Streamlit UI"
+description: "Create interactive chat interfaces with Google's Gemini models using Streamlit"
+icon: "window"
+---
+
+```mermaid
+flowchart LR
+    In[Input] --> UI[("Streamlit UI")]
+    VDB[(Vector DB)] --> Agent
+    Gemini[("Gemini")] --> Agent
+    UI --> Agent[("Knowledge Agent")]
+    Agent --> |Query| VDB
+    Agent --> Out[Output]
+    Out --> UI
+    
+    style In fill:#8B0000,color:#fff
+    style UI fill:#FF4B4B,color:#fff,shape:circle
+    style Gemini fill:#4169E1,color:#fff,shape:circle
+    style Agent fill:#2E8B57,color:#fff,shape:circle
+    style VDB fill:#4169E1,color:#fff,shape:cylinder
+    style Out fill:#8B0000,color:#fff
+```
+
+## Prerequisites
+
+<Steps>
+    <Step title="Install Package">
+        Install required packages:
+        ```bash
+        pip install "praisonaiagents[llm]" streamlit
+        ```
+
+        <Note>
+        streamlit for UI<br />
+        praisonaiagents[llm] for Gemini model access (It uses Litellm)
+        </Note>
+    </Step>
+
+    <Step title="Setup Environment">
+        Configure environment:
+        ```bash
+        export GOOGLE_API_KEY=your-api-key
+        ```
+        
+        <Note>
+        Get your API key from [Google AI Studio](https://makersuite.google.com/app/apikey)
+        </Note>
+    </Step>
+
+    <Step title="Create File">
+        Create a new file called `app.py` and add the following code:
+    </Step>
+
+    <Step title="Run Application">
+        Start the Streamlit application:
+        ```bash
+        streamlit run app.py
+        ```
+    </Step>
+</Steps>
+
+## Code
+
+```python
+import streamlit as st
+from praisonaiagents import Agent
+
+st.title("Gemini 2.0 Thinking AI Agent")
+
+# Initialize the agent
+@st.cache_resource
+def get_agent():
+    llm_config = {
+        "model": "gemini/gemini-2.0-flash-thinking-exp-01-21",
+        "response_format": {"type": "text"}
+    }
+    
+    return Agent(
+        instructions="You are a helpful assistant",
+        llm=llm_config
+    )
+
+agent = get_agent()
+
+# Create text area input field
+user_question = st.text_area("Ask your question:", height=150)
+
+# Add ask button
+if st.button("Ask"):
+    if user_question:
+        with st.spinner('Thinking...'):
+            result = agent.start(user_question)
+            st.write("### Answer")
+            st.write(result)
+    else:
+        st.warning("Please enter a question") 
+```
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Interactive Chat" icon="comments">
+    Real-time chat interface with message history.
+  </Card>
+  <Card title="Knowledge Base" icon="database">
+    RAG capabilities with ChromaDB integration.
+  </Card>
+  <Card title="Model Integration" icon="server">
+    Uses Google's Gemini Pro model.
+  </Card>
+  <Card title="Session Management" icon="clock-rotate-left">
+    Maintains chat history in session state.
+  </Card>
+</CardGroup>
+
+<Note>
+  Make sure you have a valid Google API key and sufficient quota for using Gemini models.
+</Note>

docs/ui/streamlit/hackathon-judge-streamlit.mdx

@@ -0,0 +1,323 @@
+---
+title: "Hackathon Judge Agent UI"
+sidebarTitle: "Hackathon Judge"
+description: "Build an interactive web interface for evaluating hackathon projects using Streamlit and AI agents."
+icon: "desktop"
+---
+
+```mermaid
+flowchart LR
+    Upload[Upload Video] --> Process[Process Video]
+    Process --> Evaluate[AI Evaluation]
+    Evaluate --> Display[Display Results]
+    Display --> Scores[Show Scores]
+    Display --> Feedback[Show Feedback]
+    
+    style Upload fill:#8B0000,color:#fff
+    style Process fill:#2E8B57,color:#fff
+    style Evaluate fill:#2E8B57,color:#fff
+    style Display fill:#2E8B57,color:#fff
+    style Scores fill:#2E8B57,color:#fff
+    style Feedback fill:#2E8B57,color:#fff
+```
+
+## What is the Hackathon Judge Streamlit App?
+
+The Hackathon Judge Streamlit App provides a user-friendly web interface for evaluating hackathon projects through video demonstrations. It combines the power of AI evaluation with an interactive dashboard to display comprehensive project assessments, scores, and feedback.
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Video Upload" icon="upload">
+    Easy-to-use interface for uploading project demonstration videos.
+  </Card>
+  <Card title="Real-time Processing" icon="spinner">
+    Live processing and evaluation of uploaded videos.
+  </Card>
+  <Card title="Interactive Dashboard" icon="chart-simple">
+    Visual presentation of scores and metrics.
+  </Card>
+  <Card title="Detailed Feedback" icon="comments">
+    Comprehensive display of evaluation results and recommendations.
+  </Card>
+  <Card title="Market Analysis" icon="briefcase">
+    Visual presentation of market potential and scalability.
+  </Card>
+</CardGroup>
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Dependencies">
+        Install the required packages:
+        ```bash
+        pip install streamlit praisonaiagents opencv-python moviepy
+        ```
+    </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 the App">
+        Create a new file `hackathon_judge_app.py` with the following code:
+```python
+import streamlit as st
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from pydantic import BaseModel
+from typing import List, Dict
+import tempfile
+import json
+
+class ProjectEvaluation(BaseModel):
+    innovation_score: int  # 0-100
+    technical_complexity: int # 0-100  
+    presentation_quality: int # 0-100
+    user_experience: int # 0-100
+    completeness: int # 0-100
+    overall_score: int # 0-100
+    key_strengths: List[str]
+    areas_for_improvement: List[str]
+    notable_features: List[str]
+    technical_highlights: List[str]
+    recommendations: List[str]
+    market_potential: str
+    scalability_assessment: str
+
+# Set page config
+st.set_page_config(
+    page_title="Hackathon Project Evaluator",
+    page_icon="🏆",
+    layout="wide"
+)
+
+# Create Vision Analysis Agent
+@st.cache_resource
+def get_hackathon_judge():
+    return Agent(
+        name="HackathonJudge",
+        role="Technical Project Evaluator",
+        goal="Evaluate hackathon projects through video demonstrations",
+        backstory="""You are an experienced hackathon judge and technical expert.
+        You excel at evaluating innovation, technical implementation, and presentation quality.
+        You provide constructive feedback and identify both strengths and areas for improvement.""",
+        llm="gpt-4o-mini",  # Using vision-capable model
+        self_reflect=False,
+        knowledge=""
+    )
+
+def evaluate_project(video_path: str) -> ProjectEvaluation:
+    """
+    Evaluate a hackathon project based on its video demonstration
+    """
+    hackathon_judge = get_hackathon_judge()
+    
+    evaluation_task = Task(
+        name="project_evaluation",
+        description="""Analyze this hackathon project video demonstration and provide a comprehensive evaluation:
+        
+        1. Score the following aspects (0-100):
+           - Innovation and Creativity
+           - Technical Complexity
+           - Presentation Quality
+           - User Experience
+           - Project Completeness
+           
+        2. Identify:
+           - Key strengths and standout features
+           - Areas that could be improved
+           - Notable technical implementations
+           - Market potential and scalability
+           
+        3. Provide:
+           - Specific recommendations for improvement
+           - Technical suggestions
+           - Potential future enhancements""",
+        expected_output="Detailed project evaluation with scores and feedback",
+        agent=hackathon_judge,
+        output_pydantic=ProjectEvaluation,
+        images=[video_path]  # Video input for multimodal analysis
+    )
+
+    # Initialize and run evaluation
+    agents = PraisonAIAgents(
+        agents=[hackathon_judge],
+        tasks=[evaluation_task],
+        process="sequential",
+        verbose=True
+    )
+    
+    response = agents.start()
+    
+    try:
+        # If response contains task_results, extract the Pydantic model directly
+        if isinstance(response, dict) and 'task_results' in response:
+            task_output = response['task_results'][0]
+            if hasattr(task_output, 'pydantic'):
+                return task_output.pydantic
+            elif hasattr(task_output, 'raw'):
+                # Extract JSON from raw string if it's wrapped in ```json
+                raw_text = task_output.raw
+                if raw_text.startswith('```json'):
+                    raw_text = raw_text.split('\n', 1)[1].rsplit('\n', 1)[0]
+                evaluation_data = json.loads(raw_text)
+            else:
+                evaluation_data = json.loads(task_output) if isinstance(task_output, str) else task_output
+        elif isinstance(response, str):
+            evaluation_data = json.loads(response)
+        elif isinstance(response, dict) and 'task_status' in response:
+            content = response['task_status']
+            if isinstance(content, dict):
+                evaluation_data = content
+            else:
+                evaluation_data = json.loads(content) if isinstance(content, str) else content
+        else:
+            evaluation_data = response
+            
+        # Create and return ProjectEvaluation instance
+        return ProjectEvaluation(
+            innovation_score=int(evaluation_data.get('innovation_score', 0)),
+            technical_complexity=int(evaluation_data.get('technical_complexity', 0)),
+            presentation_quality=int(evaluation_data.get('presentation_quality', 0)),
+            user_experience=int(evaluation_data.get('user_experience', 0)),
+            completeness=int(evaluation_data.get('completeness', 0)),
+            overall_score=int(evaluation_data.get('overall_score', 0)),
+            key_strengths=evaluation_data.get('key_strengths', []),
+            areas_for_improvement=evaluation_data.get('areas_for_improvement', []),
+            notable_features=evaluation_data.get('notable_features', []),
+            technical_highlights=evaluation_data.get('technical_highlights', []),
+            recommendations=evaluation_data.get('recommendations', []),
+            market_potential=str(evaluation_data.get('market_potential', '')),
+            scalability_assessment=str(evaluation_data.get('scalability_assessment', ''))
+        )
+    except Exception as e:
+        print(f"Debug - Raw response: {response}")
+        print(f"Error processing response: {e}")
+        raise
+
+# Title and description
+st.title("🏆 Hackathon Judge Agent")
+st.markdown("""
+Upload your hackathon project demonstration video for an AI-powered evaluation.
+Get comprehensive feedback on various aspects of your project.
+""")
+
+# File uploader
+uploaded_file = st.file_uploader("Choose a video file", type=['mp4', 'avi', 'mov', 'mkv'])
+
+if uploaded_file:
+    # Create a temporary file to store the video
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.'+uploaded_file.name.split('.')[-1]) as tmp_file:
+        tmp_file.write(uploaded_file.getvalue())
+        video_path = tmp_file.name
+
+    with st.spinner("🤖 AI is evaluating your project..."):
+        try:
+            # Evaluate the project
+            result = evaluate_project(video_path)
+            
+            # Display results
+            st.header("Overall Score")
+            st.metric("Overall Score", f"{result.overall_score}/100")
+            
+            # Display detailed scores
+            st.header("Detailed Scores")
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Innovation", f"{result.innovation_score}/100")
+                st.metric("Technical Complexity", f"{result.technical_complexity}/100")
+            with col2:
+                st.metric("Presentation", f"{result.presentation_quality}/100")
+                st.metric("User Experience", f"{result.user_experience}/100")
+            with col3:
+                st.metric("Completeness", f"{result.completeness}/100")
+
+            # Display qualitative feedback
+            st.header("Key Strengths")
+            for strength in result.key_strengths:
+                st.write(f"• {strength}")
+            
+            st.header("Areas for Improvement")
+            for area in result.areas_for_improvement:
+                st.write(f"• {area}")
+            
+            st.header("Technical Highlights")
+            for highlight in result.technical_highlights:
+                st.write(f"• {highlight}")
+            
+            st.header("Notable Features")
+            for feature in result.notable_features:
+                st.write(f"• {feature}")
+            
+            st.header("Recommendations")
+            for rec in result.recommendations:
+                st.write(f"• {rec}")
+            
+            # Market Analysis
+            st.header("Market Analysis")
+            col1, col2 = st.columns(2)
+            with col1:
+                st.subheader("Market Potential")
+                st.write(result.market_potential)
+            with col2:
+                st.subheader("Scalability Assessment")
+                st.write(result.scalability_assessment)
+
+        except Exception as e:
+            st.error(f"Error evaluating the project: {str(e)}")
+        finally:
+            # Clean up the temporary file
+            os.unlink(video_path)
+else:
+    # Display placeholder content
+    st.info("👆 Upload a video file to get started!") 
+```
+    </Step>
+
+    <Step title="Run the App">
+        Start the Streamlit app:
+        ```bash
+        streamlit run hackathon_judge_app.py
+        ```
+    </Step>
+</Steps>
+
+## Understanding the Interface
+
+The Streamlit app provides an intuitive interface with the following sections:
+
+- **Video Upload**: Drag and drop or browse to upload your project demo video
+- **Overall Score**: A prominent display of the project's overall rating
+- **Detailed Scores**:
+  - Innovation Score
+  - Technical Complexity
+  - Presentation Quality
+  - User Experience
+  - Project Completeness
+- **Qualitative Feedback**:
+  - Key Strengths
+  - Areas for Improvement
+  - Technical Highlights
+  - Notable Features
+  - Recommendations
+- **Market Analysis**:
+  - Market Potential
+  - Scalability Assessment
+
+## Next Steps
+
+<CardGroup>
+  <Card title="Streamlit Docs" icon="book" href="https://docs.streamlit.io">
+    Learn more about Streamlit features
+  </Card>
+  <Card title="PraisonAI Docs" icon="bolt" href="/introduction">
+    Explore PraisonAI capabilities
+  </Card>
+  <Card title="Examples" icon="code" href="/examples">
+    View more example applications
+  </Card>
+</CardGroup>

docs/ui/streamlit/ollama-streamlit.mdx

@@ -0,0 +1,158 @@
+---
+title: "Ollama Streamlit UI"
+description: "Create interactive chat interfaces with Ollama models using Streamlit"
+icon: "window"
+---
+
+```mermaid
+flowchart LR
+    In[Input] --> UI[("Streamlit UI")]
+    VDB[(Vector DB)] --> Agent
+    Ollama[("Ollama")] --> Agent
+    UI --> Agent[("Knowledge Agent")]
+    Agent --> |Query| VDB
+    Agent --> Out[Output]
+    Out --> UI
+    
+    style In fill:#8B0000,color:#fff
+    style UI fill:#FF4B4B,color:#fff,shape:circle
+    style Ollama fill:#4169E1,color:#fff,shape:circle
+    style Agent fill:#2E8B57,color:#fff,shape:circle
+    style VDB fill:#4169E1,color:#fff,shape:cylinder
+    style Out fill:#8B0000,color:#fff
+```
+
+## Prerequisites
+
+<Steps>
+    <Step title="Install Package">
+        Install required packages:
+        ```bash
+        pip install "praisonaiagents[knowledge]" streamlit ollama
+        ```
+
+        <Note>
+        streamlit for UI
+        ollama for model hosting
+        praisonaiagents[knowledge] for RAG capabilities
+        </Note>
+    </Step>
+
+    <Step title="Setup Model">
+        Pull Ollama models:
+        ```bash
+        # Large Language Model
+        ollama pull deepseek-r1
+        
+        # Embedding Model
+        ollama pull nomic-embed-text
+        ```
+    </Step>
+
+    <Step title="Setup Environment">
+        Configure environment:
+        ```bash
+        export OPENAI_BASE_URL=http://localhost:11434/v1
+        export OPENAI_API_KEY=fake-key
+        ```
+    </Step>
+
+    <Step title="Create File">
+        Create a new file called `app.py` and add the following code:
+    </Step>
+
+    <Step title="Run Application">
+        Start the Streamlit application:
+        ```bash
+        streamlit run app.py
+        ```
+    </Step>
+</Steps>
+
+## Code
+
+```python
+import streamlit as st
+from praisonaiagents import Agent
+
+def init_agent():
+    config = {
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "collection_name": "praison",
+                "path": ".praison"
+            }
+        },
+        "llm": {
+            "provider": "ollama",
+            "config": {
+                "model": "deepseek-r1:latest",
+                "temperature": 0,
+                "max_tokens": 8000,
+                "ollama_base_url": "http://localhost:11434",
+            },
+        },
+        "embedder": {
+            "provider": "ollama",
+            "config": {
+                "model": "nomic-embed-text:latest",
+                "ollama_base_url": "http://localhost:11434",
+                "embedding_dims": 1536
+            },
+        },
+    }
+    
+    return Agent(
+        name="Knowledge Agent",
+        instructions="You answer questions based on the provided knowledge.",
+        knowledge=["kag-research-paper.pdf"],
+        knowledge_config=config,
+        user_id="user1",
+        llm="deepseek-r1"
+    )
+
+st.title("Knowledge Agent Chat")
+
+if "agent" not in st.session_state:
+    st.session_state.agent = init_agent()
+    st.session_state.messages = []
+
+if "messages" in st.session_state:
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+prompt = st.chat_input("Ask a question...")
+
+if prompt:
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        response = st.session_state.agent.start(prompt)
+        st.markdown(response)
+        st.session_state.messages.append({"role": "assistant", "content": response}) 
+```
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Interactive Chat" icon="comments">
+    Real-time chat interface with message history.
+  </Card>
+  <Card title="Knowledge Base" icon="database">
+    RAG capabilities with ChromaDB integration.
+  </Card>
+  <Card title="Model Integration" icon="server">
+    Uses Ollama for local model hosting.
+  </Card>
+  <Card title="Session Management" icon="clock-rotate-left">
+    Maintains chat history in session state.
+  </Card>
+</CardGroup>
+
+<Note>
+  Make sure your system meets the requirements for running models locally through Ollama.
+</Note>

examples/concepts/knowledge-agents.py

@@ -4,7 +4,7 @@ config = {
     "vector_store": {
         "provider": "chroma",
         "config": {
-            "collection_name": "custom_knowledge",
+            "collection_name": "praison",
             "path": ".praison",
         }
     }

examples/concepts/rag-agents.py

@@ -0,0 +1,39 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Define the configuration for the Knowledge instance
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "praison",
+            "path": ".praison"
+        }
+    }
+}
+
+# Create an agent
+rag_agent = Agent(
+    name="RAG Agent",
+    role="Information Specialist",
+    goal="Retrieve knowledge efficiently",
+    llm="gpt-4o-mini"
+)
+
+# Define a task for the agent
+rag_task = Task(
+    name="RAG Task",
+    description="What is KAG?",
+    expected_output="Answer to the question",
+    agent=rag_agent,
+    context=[config] # Vector Database provided as context
+)
+
+# Build Agents
+agents = PraisonAIAgents(
+    agents=[rag_agent],
+    tasks=[rag_task],
+    user_id="user1"
+)
+
+# Start Agents
+agents.start()

examples/concepts/repetitive-agents.py

@@ -0,0 +1,22 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+agent = Agent(
+    instructions="You are a loop agent that creating a loop of tasks.",
+    llm="gpt-4o-mini"
+)
+
+task = Task(
+    description="Create the list of tasks to be looped through.",
+    agent=agent,
+    task_type="loop",
+    input_file="tasks.csv"
+)
+
+agents = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task],
+    process="workflow",
+    max_iter=30
+)
+
+agents.start()

examples/data/cot-agents.py

@@ -0,0 +1,142 @@
+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)
+
+# Keep existing agents with minimal changes
+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 improvements
+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()

examples/image/image-agent-async.py

@@ -0,0 +1,15 @@
+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())

examples/image/image-agent.py

@@ -0,0 +1,8 @@
+from praisonaiagents.agent.image_agent import ImageAgent
+
+# Create an image agent with normal mode
+agent = ImageAgent(llm="dall-e-3")
+
+# Generate an image
+result = agent.chat("A cute baby sea otter playing with a laptop")
+print("Image generation result:", result)

examples/models/deepseek/deepseek-agents.py

@@ -0,0 +1,9 @@
+# pip install praisonaiagents
+# export OPENAI_BASE_URL=http://localhost:11434/v1
+# ollama pull deepseek-r1
+
+from praisonaiagents import Agent
+
+agent = Agent(instructions="You are helpful Assisant", llm="deepseek-r1")
+
+agent.start("Why sky is Blue?")

examples/models/deepseek/deepseek-rag-agents-streamlit.py

@@ -0,0 +1,62 @@
+import streamlit as st
+from praisonaiagents import Agent
+
+def init_agent():
+    config = {
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "collection_name": "praison",
+                "path": ".praison"
+            }
+        },
+        "llm": {
+            "provider": "ollama",
+            "config": {
+                "model": "deepseek-r1:latest",
+                "temperature": 0,
+                "max_tokens": 8000,
+                "ollama_base_url": "http://localhost:11434",
+            },
+        },
+        "embedder": {
+            "provider": "ollama",
+            "config": {
+                "model": "nomic-embed-text:latest",
+                "ollama_base_url": "http://localhost:11434",
+                "embedding_dims": 1536
+            },
+        },
+    }
+    
+    return Agent(
+        name="Knowledge Agent",
+        instructions="You answer questions based on the provided knowledge.",
+        knowledge=["kag-research-paper.pdf"],
+        knowledge_config=config,
+        user_id="user1",
+        llm="deepseek-r1"
+    )
+
+st.title("Knowledge Agent Chat")
+
+if "agent" not in st.session_state:
+    st.session_state.agent = init_agent()
+    st.session_state.messages = []
+
+if "messages" in st.session_state:
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+prompt = st.chat_input("Ask a question...")
+
+if prompt:
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        response = st.session_state.agent.start(prompt)
+        st.markdown(response)
+        st.session_state.messages.append({"role": "assistant", "content": response}) 

examples/models/deepseek/deepseek-rag-agents.py

@@ -0,0 +1,39 @@
+from praisonaiagents import Agent
+
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "praison",
+            "path": ".praison"
+        }
+    },
+    "llm": {
+        "provider": "ollama",
+        "config": {
+            "model": "deepseek-r1:latest",
+            "temperature": 0,
+            "max_tokens": 8000,
+            "ollama_base_url": "http://localhost:11434",
+        },
+    },
+    "embedder": {
+        "provider": "ollama",
+        "config": {
+            "model": "nomic-embed-text:latest",
+            "ollama_base_url": "http://localhost:11434",
+            "embedding_dims": 1536
+        },
+    },
+}
+
+agent = Agent(
+    name="Knowledge Agent",
+    instructions="You answer questions based on the provided knowledge.",
+    knowledge=["kag-research-paper.pdf"], # Indexing
+    knowledge_config=config,
+    user_id="user1",
+    llm="deepseek-r1"
+)
+
+agent.start("What is KAG in one line?") # Retrieval

examples/models/googlegemini/any-llm-agents-advanced.py

@@ -0,0 +1,45 @@
+from praisonaiagents import Agent
+
+# Detailed LLM configuration
+llm_config = {
+    "model": "gemini/gemini-1.5-flash-latest",  # Model name without provider prefix
+    
+    # Core settings
+    "temperature": 0.7,                # Controls randomness (like temperature)
+    "timeout": 30,                 # Timeout in seconds
+    "top_p": 0.9,                    # Nucleus sampling parameter
+    "max_tokens": 1000,               # Max tokens in response
+    
+    # Advanced parameters
+    "presence_penalty": 0.1,         # Penalize repetition of topics (-2.0 to 2.0)
+    "frequency_penalty": 0.1,        # Penalize token repetition (-2.0 to 2.0)
+    
+    # API settings (optional)
+    "api_key": None,                 # Your API key (or use environment variable)
+    "base_url": None,                # Custom API endpoint if needed
+    
+    # Response formatting
+    "response_format": {             # Force specific response format
+        "type": "text"               # Options: "text", "json_object"
+    },
+    
+    # Additional controls
+    "seed": 42,                      # For reproducible responses
+    "stop_phrases": ["##", "END"],   # Custom stop sequences
+}
+
+agent = Agent(
+    instructions="You are a helpful Assistant specialized in scientific explanations. "
+                "Provide clear, accurate, and engaging responses.",
+    llm=llm_config,                  # Pass the detailed configuration
+    verbose=True,                    # Enable detailed output
+    markdown=True,                   # Format responses in markdown
+    self_reflect=True,              # Enable self-reflection
+    max_reflect=3,                  # Maximum reflection iterations
+    min_reflect=1                   # Minimum reflection iterations
+)
+
+# Test the agent
+response = agent.start("Why is the sky blue? Please explain in simple terms.")
+
+print(response)

examples/models/googlegemini/any-llm-agents-async.py

@@ -0,0 +1,18 @@
+import asyncio
+from praisonaiagents import Agent
+
+async def main():
+    agent = Agent(
+        instructions="You are a helpful assistant",
+        llm="gemini/gemini-1.5-flash-8b",
+        self_reflect=True,
+        verbose=True
+    )
+
+    # Use achat instead of start/chat for async operation
+    response = await agent.achat("Why sky is Blue in 1000 words?")
+    print(response)
+
+if __name__ == "__main__":
+    # Run the async main function
+    asyncio.run(main())

examples/models/googlegemini/any-llm-agents.py

@@ -0,0 +1,10 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="gemini/gemini-1.5-flash-8b",
+    self_reflect=True,
+    verbose=True
+)
+
+agent.start("Why sky is Blue?")

examples/providers/ollama/ollama-agents.py

@@ -0,0 +1,9 @@
+# pip install praisonaiagents
+# export OPENAI_BASE_URL=http://localhost:11434/v1
+# ollama pull deepseek-r1
+
+from praisonaiagents import Agent
+
+agent = Agent(instructions="You are helpful Assisant", llm="deepseek-r1")
+
+agent.start("Why sky is Blue?")

examples/ui/gemini-streamlit.py

@@ -0,0 +1,32 @@
+import streamlit as st
+from praisonaiagents import Agent
+
+st.title("Gemini 2.0 Thinking AI Agent")
+
+# Initialize the agent
+@st.cache_resource
+def get_agent():
+    llm_config = {
+        "model": "gemini/gemini-2.0-flash-thinking-exp-01-21",
+        "response_format": {"type": "text"}
+    }
+    
+    return Agent(
+        instructions="You are a helpful assistant",
+        llm=llm_config
+    )
+
+agent = get_agent()
+
+# Create text area input field
+user_question = st.text_area("Ask your question:", height=150)
+
+# Add ask button
+if st.button("Ask"):
+    if user_question:
+        with st.spinner('Thinking...'):
+            result = agent.start(user_question)
+            st.write("### Answer")
+            st.write(result)
+    else:
+        st.warning("Please enter a question") 

examples/ui/ollama-rag-agents-streamlit.py

@@ -0,0 +1,62 @@
+import streamlit as st
+from praisonaiagents import Agent
+
+def init_agent():
+    config = {
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "collection_name": "praison",
+                "path": ".praison"
+            }
+        },
+        "llm": {
+            "provider": "ollama",
+            "config": {
+                "model": "deepseek-r1:latest",
+                "temperature": 0,
+                "max_tokens": 8000,
+                "ollama_base_url": "http://localhost:11434",
+            },
+        },
+        "embedder": {
+            "provider": "ollama",
+            "config": {
+                "model": "nomic-embed-text:latest",
+                "ollama_base_url": "http://localhost:11434",
+                "embedding_dims": 1536
+            },
+        },
+    }
+    
+    return Agent(
+        name="Knowledge Agent",
+        instructions="You answer questions based on the provided knowledge.",
+        knowledge=["kag-research-paper.pdf"],
+        knowledge_config=config,
+        user_id="user1",
+        llm="deepseek-r1"
+    )
+
+st.title("Knowledge Agent Chat")
+
+if "agent" not in st.session_state:
+    st.session_state.agent = init_agent()
+    st.session_state.messages = []
+
+if "messages" in st.session_state:
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+prompt = st.chat_input("Ask a question...")
+
+if prompt:
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        response = st.session_state.agent.start(prompt)
+        st.markdown(response)
+        st.session_state.messages.append({"role": "assistant", "content": response})