Merge pull request #339 from MervinPraison/develop

2.0.60

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 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,381 @@ 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
+```
+
+## 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 +466,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 +488,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 +531,33 @@ 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) |
+| 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) |
@@ -525,58 +571,3 @@ Praison AI is an open-sourced software licensed under the **[MIT license](https:
 | 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) |
 
-## 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

@@ -5,4 +5,146 @@
 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. 
+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. 
+
+
+Below is a **detailed technical overview** of the issues that have been coming up in the workflow execution (specifically around loops, resetting tasks, and continuing on to subsequent tasks). It includes:
+
+1. **How the workflow currently flows**  
+2. **What logic marks a task as “completed”**  
+3. **What issues arose in `loop` tasks**  
+4. **Why the workflow can end up “stuck” or “looping indefinitely”**  
+
+---
+
+## 1. Overall Workflow Flow
+
+### a. Building relationships among tasks
+
+- At startup, the code iterates through all `tasks`.  
+- For each `task`:
+  - It looks at `task.next_tasks`, and for each `next_task_name`:
+    - Finds the corresponding `Task` object
+    - Appends the current task’s name to the found `next_task`'s `previous_tasks` list.  
+- This means if Task A has `next_tasks=["B"]`, then Task B’s `previous_tasks` will include `"A"`.
+
+### b. Finding and starting with a “start task”
+
+- The workflow code tries to locate a task with `is_start=True`.  
+- If no such task is found, it uses the first item in the tasks dictionary instead.  
+- That “start task” is what the workflow tries to run first.
+
+### c. Execution loop in the method (e.g., `workflow()` or `aworkflow()`)
+
+- There is a `while current_task:` loop that processes tasks in sequence, or conditionally, based on `task.condition`.
+- Each time a task runs (if non-loop), it yields the `task_id` or triggers an agent to run. Once the agent finishes (with or without a final result), the workflow picks up again to see what to do next:
+  - If the `task` is a `loop` type, the code tries to create or manage sub-tasks for each row/line in an “input_file.”
+  - If the `task` is a normal (“decision” or “task” or “some-other-type”), it just executes once, sets `status="completed"`, and the code moves on.
+
+### d. Condition-based branching
+
+- If a task has a result that includes a “decision” (like `{"decision":"more"}` or `"done"`), the code checks `task.condition`. For example:
+  ```python
+  condition = {
+    "more": "generate_task",
+    "done": "evaluate_total_questions"
+  }
+  ```
+- If the result’s decision is `"done"`, it jumps to the task named `"evaluate_total_questions"`.  
+- If the result’s decision is `"more"`, it jumps right back to `"generate_task"`.  
+- If no condition matches, it can fallback to the first item in `task.next_tasks`.
+
+### e. Marking tasks as “completed”
+
+- After a task’s execution (like a typical “non-loop” task), the code sets `task.status = "completed"`.
+- Then the code has a snippet that says:
+  ```python
+  if self.tasks[task_id].status == "completed":
+      # Possibly reset to "not started" so we can re-run if needed
+  ```
+- By default, the system tries to “reset” tasks to `"not started"`, **unless** it is a loop task or a subtask of a loop.  
+
+---
+
+## 2. How a “completed” task is marked
+
+Generally, tasks are marked `status="completed"` in two primary ways:
+
+1. **Non-Loop Execution**  
+   A normal task (like a “decision” or “task”) is executed once the code calls the agent, the agent returns a final result, and the system sets `task.status = "completed"`.
+2. **Loop Execution**  
+   A loop-type task is *programmatically* set to `status="completed"` when all of its sub-tasks have finished. That is:
+   - The code checks: “Have all child tasks of this loop finished?”  
+   - If `True`, the loop task is set to `completed`.
+
+---
+
+## 3. Issues Specifically in `loop` Tasks
+
+### a. Re-Entering the Loop
+
+- Before, the same snippet that “resets completed tasks to ‘not started’ so they can re-run if needed” **also** tried to reset loop tasks or their subtasks.  
+- If a loop task got reset to `"not started"`, the code would eventually pick it back up again, leading to repeated creation of sub-tasks (or repeated attempts to re-run them).
+- This caused an **infinite loop** or repeating the same steps in the workflow, never truly exiting the loop stage.
+
+### b. Subtasks Not Marked or Overwritten
+
+- Another tricky scenario: If sub-tasks themselves got reset, the parent loop would see them as “not started” again, and might wait for them to “complete,” or might re-run them. That can lead to indefinite re-running of sub-tasks.
+
+### c. Not Proceeding to Next (e.g., “upload_to_huggingface”)
+
+- If the loop kept “restarting,” the workflow never ended up hitting the next tasks. For example, if your workflow is:
+  1. `generate_task`  
+  2. `evaluate_total_questions`  
+  3. `generate_cot` (loop)  
+  4. `upload_to_huggingface`
+- The system might get stuck in step #3 indefinitely (the sub-tasks keep getting reset, so it never actually transitions to step #4).
+
+### d. Condition Logic vs. Next Tasks
+
+- Another subtlety: If the loop tasks had a `condition` that pointed them back to a prior step, it might cause unintentional re-entry. Typically, you only want loop tasks to proceed once, **unless** you explicitly want to re-visit. But if it’s a data ingestion process, you usually want to do it once, then move on to the next step.
+
+---
+
+## 4. Why the System Can End Up Stuck or “Looping Indefinitely”
+
+1. **Reset Mechanism**  
+   - The code tries to “reset tasks to ‘not started’ once they complete,” so they can be re-run in some dynamic multi-run scenario.  
+   - But that same logic can cause loop tasks to revert back to “not started” the moment they end. The system sees “Oh, a task is ‘not started’? Let’s run it!” and you’re in a cycle.
+
+2. **No Condition for Exit**  
+   - If the loop has a condition that leads back to a prior step (like `"more" -> generate_cot`), it can keep re-running.
+
+3. **Subtasks Not Marked**  
+   - If the subtask or the loop tries to “reactivate” each other, it never exits.
+
+---
+
+## Summary of the “Core Problem”
+
+1. We want to keep the resetting mechanism for **non-loop tasks** – because in some advanced workflows, we like re-running them from a different path or after some condition.  
+2. But we want **loop tasks** to remain `"completed"` once all sub-tasks are done, so the code can seamlessly proceed to the next major step.  
+3. Before the fix, loop tasks or their sub-tasks got reset. This triggered the system to re-enter the loop, re-run the sub-tasks, etc., causing an infinite loop and preventing the workflow from reaching tasks like “upload_to_huggingface.”
+
+---
+
+## Technical Highlights to Pass On
+
+- **In the reset snippet**:  
+  ```python
+  if self.tasks[task_id].status == "completed":
+      # never reset if loop or subtask-of-loop
+      # else reset to "not started"
+  ```
+  This is crucial to skipping re-runs on loop tasks.  
+- **Ensure** that once a loop’s sub-tasks are all “completed,” the loop’s status is set to “completed,” and it transitions to the next major tasks (like `upload_to_huggingface`).  
+- **Check** if the loop’s condition is correct. If you want a single pass, do not implement a condition that leads back to the same loop.  
+- Also, you can check you do not have “overlapping conditions” that cause re-entry.
+
+---
+
+### Conclusion
+
+**Hence,** the main challenge is that the reset logic (meant to let normal tasks be re-run) conflicts with a loop task’s one-pass usage. Once you avoid resetting the loop tasks or sub-tasks, you can finish them once, mark them “completed,” and properly proceed to the next stage.
+
+Dont remove any logging or debug statements, as it will help you to understand the flow of the code.

agents/.devcontainer/Dockerfile

@@ -0,0 +1,43 @@
+FROM mcr.microsoft.com/devcontainers/python:3.11
+
+# Prevent apt from showing prompts
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    curl \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user
+ARG USERNAME=vscode
+ARG USER_UID=1000
+ARG USER_GID=$USER_UID
+
+# Create the user and group only if they don't exist
+RUN if ! getent group $USER_GID > /dev/null 2>&1; then \
+        groupadd --gid $USER_GID $USERNAME; \
+    fi && \
+    if ! getent passwd $USER_UID > /dev/null 2>&1; then \
+        useradd --uid $USER_UID --gid $USER_GID -m $USERNAME; \
+    fi && \
+    apt-get update && \
+    apt-get install -y sudo && \
+    echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME && \
+    chmod 0440 /etc/sudoers.d/$USERNAME
+
+# Set Python environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+# Install Python dependencies
+COPY requirements.txt /tmp/pip-tmp/
+RUN pip3 --disable-pip-version-check --no-cache-dir install -r /tmp/pip-tmp/requirements.txt \
+    && rm -rf /tmp/pip-tmp
+
+# Switch to non-root user
+USER $USERNAME
+
+# Set the default shell to bash
+ENV SHELL=/bin/bash

agents/.devcontainer/devcontainer.json

@@ -0,0 +1,36 @@
+{
+    "name": "PraisonAI Development",
+    "dockerFile": "Dockerfile",
+    "context": "..",
+    "runArgs": [
+        "--env-file",
+        ".env",
+        "--network=host"
+    ],
+    "customizations": {
+        "vscode": {
+            "extensions": [
+                "ms-python.python",
+                "ms-python.vscode-pylance",
+                "ms-python.black-formatter",
+                "ms-toolsai.jupyter",
+                "yzhang.markdown-all-in-one",
+                "streetsidesoftware.code-spell-checker"
+            ],
+            "settings": {
+                "python.defaultInterpreterPath": "/usr/local/bin/python",
+                "python.linting.enabled": true,
+                "python.formatting.provider": "black",
+                "editor.formatOnSave": true,
+                "editor.rulers": [88],
+                "files.trimTrailingWhitespace": true
+            }
+        }
+    },
+    "remoteUser": "vscode",
+    "updateRemoteUserUID": false,
+    "forwardPorts": [],
+    "appPort": ["56040:56040"],
+    "overrideCommand": false,
+    "init": true
+}

agents/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())

agents/async-tavily-agents-gemini.py

@@ -0,0 +1,127 @@
+import asyncio
+import logging
+from typing import List, Dict, Any
+from pydantic import BaseModel
+from praisonaiagents import Agent, Task, PraisonAIAgents, TaskOutput
+from tavily import AsyncTavilyClient
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+llm_config = {
+    "model": "gemini/gemini-1.5-flash-8b",
+    "response_format": {
+        "type": "text"
+    }
+}
+
+# Define output model
+class SearchResult(BaseModel):
+    query: str
+    results: List[Dict[str, Any]]
+    total_results: int
+
+# Define Tavily search tool
+async def tavily_search(query) -> Dict[str, Any]:
+    """Async Tavily search tool that returns structured results"""
+    client = AsyncTavilyClient()
+    try:
+        results = await client.search(query)
+        print(f"Tavily search results: {results}")
+        return {
+            "query": query,
+            "results": results.get("results", []),
+            "total_results": len(results.get("results", []))
+        }
+    except Exception as e:
+        logging.error(f"Tavily search error: {e}")
+        return {
+            "query": query,
+            "results": [],
+            "total_results": 0
+        }
+
+# Define async callback
+async def async_callback(output: TaskOutput):
+    if output.output_format == "JSON":
+        logging.info(f"Search completed: {output.json_dict.get('query', '')}")
+    elif output.output_format == "Pydantic":
+        logging.info(f"Search completed: {output.pydantic}")
+
+async def run_parallel_searches():
+    # Create search agent with direct tool function
+    search_agent = Agent(
+        name="TavilySearchAgent",
+        role="Search Specialist",
+        goal="Perform parallel web searches with high accuracy",
+        backstory="Expert in web search and information retrieval",
+        tools=[tavily_search],
+        llm=llm_config
+    )
+    
+    # Create summary agent
+    summary_agent = Agent(
+        name="ContentSynthesizer",
+        role="Research Analyst",
+        goal="Synthesize search results into coherent insights",
+        backstory="Expert in analyzing and combining multiple sources of information",
+        llm=llm_config
+    )
+    
+    # Define search topics
+    search_topics = [
+        "Latest AI breakthroughs 2024",
+        "Future of quantum computing",
+        "Advancements in robotics"
+    ]
+    
+    # Create parallel search tasks
+    search_tasks = [
+        Task(
+            name=f"search_{i}",
+            description=f"Search and analyze: {topic}",
+            expected_output="Comprehensive search results with analysis",
+            agent=search_agent,
+            async_execution=True,
+            callback=async_callback,
+        ) for i, topic in enumerate(search_topics)
+    ]
+    
+    # Create summary task
+    summary_task = Task(
+        name="synthesize_results",
+        description="Create a comprehensive summary of all search findings",
+        expected_output="Synthesized insights from all searches",
+        agent=summary_agent,
+        async_execution=False,
+        context=search_tasks
+    )
+    
+    # Initialize agents manager
+    agents = PraisonAIAgents(
+        agents=[search_agent, summary_agent],
+        tasks=search_tasks + [summary_task]
+    )
+    
+    # Execute tasks
+    results = await agents.astart()
+    return {
+        "search_results": [str(results["task_results"][i]) for i in range(len(search_tasks))],
+        "summary": str(results["task_results"][summary_task.id]),
+        "topics": search_topics
+    }
+
+async def main():
+    try:
+        logging.info("Starting parallel Tavily searches...")
+        results = await run_parallel_searches()
+        logging.info("Search process completed successfully")
+        print("\nResults Summary:")
+        for topic, result in zip(results["topics"], results["search_results"]):
+            print(f"\n{topic}:\n{result}")
+        print(f"\nFinal Summary:\n{results['summary']}")
+    except Exception as e:
+        logging.error(f"Error in execution: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(main())

agents/async-tavily-agents.py

@@ -0,0 +1,119 @@
+import asyncio
+import logging
+from typing import List, Dict, Any
+from pydantic import BaseModel
+from praisonaiagents import Agent, Task, PraisonAIAgents, TaskOutput
+from tavily import AsyncTavilyClient
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Define output model
+class SearchResult(BaseModel):
+    query: str
+    results: List[Dict[str, Any]]
+    total_results: int
+
+# Define Tavily search tool
+async def tavily_search(query: str) -> Dict[str, Any]:
+    """Async Tavily search tool that returns structured results"""
+    client = AsyncTavilyClient()
+    try:
+        results = await client.search(query)
+        print(f"Tavily search results: {results}")
+        return {
+            "query": query,
+            "results": results.get("results", []),
+            "total_results": len(results.get("results", []))
+        }
+    except Exception as e:
+        logging.error(f"Tavily search error: {e}")
+        return {
+            "query": query,
+            "results": [],
+            "total_results": 0
+        }
+
+# Define async callback
+async def async_callback(output: TaskOutput):
+    if output.output_format == "JSON":
+        logging.info(f"Search completed: {output.json_dict.get('query', '')}")
+    elif output.output_format == "Pydantic":
+        logging.info(f"Search completed: {output.pydantic}")
+
+async def run_parallel_searches():
+    # Create search agent with direct tool function
+    search_agent = Agent(
+        name="TavilySearchAgent",
+        role="Search Specialist",
+        goal="Perform parallel web searches with high accuracy",
+        backstory="Expert in web search and information retrieval",
+        tools=[tavily_search]
+    )
+    
+    # Create summary agent
+    summary_agent = Agent(
+        name="ContentSynthesizer",
+        role="Research Analyst",
+        goal="Synthesize search results into coherent insights",
+        backstory="Expert in analyzing and combining multiple sources of information"
+    )
+    
+    # Define search topics
+    search_topics = [
+        "Latest AI breakthroughs 2024",
+        "Future of quantum computing",
+        "Advancements in robotics"
+    ]
+    
+    # Create parallel search tasks
+    search_tasks = [
+        Task(
+            name=f"search_{i}",
+            description=f"Search and analyze: {topic}",
+            expected_output="Comprehensive search results with analysis",
+            agent=search_agent,
+            async_execution=True,
+            callback=async_callback,
+            output_json=SearchResult
+        ) for i, topic in enumerate(search_topics)
+    ]
+    
+    # Create summary task
+    summary_task = Task(
+        name="synthesize_results",
+        description="Create a comprehensive summary of all search findings",
+        expected_output="Synthesized insights from all searches",
+        agent=summary_agent,
+        async_execution=False,
+        context=search_tasks
+    )
+    
+    # Initialize agents manager
+    agents = PraisonAIAgents(
+        agents=[search_agent, summary_agent],
+        tasks=search_tasks + [summary_task]
+    )
+    
+    # Execute tasks
+    results = await agents.astart()
+    return {
+        "search_results": [str(results["task_results"][i]) for i in range(len(search_tasks))],
+        "summary": str(results["task_results"][summary_task.id]),
+        "topics": search_topics
+    }
+
+async def main():
+    try:
+        logging.info("Starting parallel Tavily searches...")
+        results = await run_parallel_searches()
+        logging.info("Search process completed successfully")
+        print("\nResults Summary:")
+        for topic, result in zip(results["topics"], results["search_results"]):
+            print(f"\n{topic}:\n{result}")
+        print(f"\nFinal Summary:\n{results['summary']}")
+    except Exception as e:
+        logging.error(f"Error in execution: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(main())

agents/async_example.py

@@ -12,6 +12,14 @@ from praisonaiagents.main import (
 )
 from duckduckgo_search import DDGS
 from pydantic import BaseModel
+import logging
+
+# Configure logging with more detail
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(levelname)s - %(name)s:%(lineno)d - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
 console = Console()
 
@@ -48,7 +56,7 @@ def sync_search_tool(query: str) -> List[Dict]:
         error_logs.append(error_msg)
         return []
 
-async def async_search_tool(query: str) -> List[Dict]:
+async def async_search_tool(query: str) -> Dict:
     """
     Asynchronous search using DuckDuckGo.
     Args:
@@ -56,23 +64,36 @@ async def async_search_tool(query: str) -> List[Dict]:
     Returns:
         list: Search results
     """
+    logger.debug(f"Starting async_search_tool with query: {query}")
     display_tool_call(f"Running async search for: {query}", console)
     await asyncio.sleep(1)  # Simulate network delay
     try:
         results = []
         ddgs = DDGS()
+        logger.debug("Performing DuckDuckGo search")
         for result in ddgs.text(keywords=query, max_results=5):
             results.append({
                 "title": result.get("title", ""),
                 "url": result.get("href", ""),
                 "snippet": result.get("body", "")
             })
-        return results
+        
+        logger.debug(f"Search completed, found {len(results)} results")
+        return {
+            "query": query,
+            "results": results,
+            "total_results": len(results)
+        }
     except Exception as e:
         error_msg = f"Error during async search: {e}"
+        logger.error(f"Error in async_search_tool: {e}", exc_info=True)
         display_error(error_msg, console)
         error_logs.append(error_msg)
-        return []
+        return {
+            "query": query,
+            "results": [],
+            "total_results": 0
+        }
 
 # 3. Define both sync and async callbacks
 def sync_callback(output: TaskOutput):

agents/async_example_full.py

@@ -4,6 +4,13 @@ from typing import List, Dict
 from praisonaiagents import Agent, Task, PraisonAIAgents, TaskOutput
 from duckduckgo_search import DDGS
 from pydantic import BaseModel
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
 
 # 1. Define output model for structured results
 class SearchResult(BaseModel):

agents/basic-agents.py

@@ -0,0 +1,8 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm="gpt-4o-mini"
+)
+
+agent.start("Why sky is Blue?")

agents/chunking-direct-test.py

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

agents/code-analysis-agents.py

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

agents/code-analysis-streamlit.py

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

agents/context-agents-code.py

@@ -0,0 +1,98 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from pydantic import BaseModel
+from typing import List, Dict
+
+class SkillMetrics(BaseModel):
+    name: str
+    score: int
+    comments: str
+
+class CVAnalysisReport(BaseModel):
+    overall_score: int
+    skill_metrics: List[SkillMetrics]
+    experience_score: int
+    education_score: int
+    presentation_score: int
+    achievement_impact_score: int
+    market_readiness: int
+    key_strengths: List[str]
+    areas_for_improvement: List[str]
+    market_fit: str
+    recommendations: List[str]
+    technical_skills: List[Dict[str, int]]
+    soft_skills: List[Dict[str, int]]
+    skill_gaps: List[str]
+    key_achievements: List[str]
+    impact_metrics: List[Dict[str, str]]
+    areas_of_expertise: List[str]
+
+# Create single CV analysis agent
+cv_analyzer = Agent(
+    role="CV Analysis Expert",
+    goal="Provide comprehensive CV evaluation and recommendations",
+    backstory="""You are an expert CV analyst with deep knowledge of industry requirements, 
+    market trends, and talent assessment. You excel at evaluating skills, experience, 
+    and providing actionable recommendations.""",
+    verbose=True
+)
+
+# Single comprehensive analysis task
+cv_analysis_task = Task(
+    description="""Perform a detailed CV analysis with scoring metrics and provide output in the following format:
+
+    1. Overall Score (0-100):
+       - Calculate based on weighted average of all metrics
+    
+    2. Individual Skill Metrics:
+       - For each major skill found in CV:
+         * Name of skill
+         * Score (0-100)
+         * Specific feedback/comments
+    
+    3. Core Metrics (0-100 each):
+       - Experience Score: Based on relevance and years
+       - Education Score: Based on relevance and level
+       - Presentation Score: CV format, clarity, structure
+       - Achievement Impact Score: Measurable results
+       - Market Readiness: Current market fit
+    
+    4. Technical Skills:
+       - List each skill with proficiency score (0-100)
+       - Example: {"Python": 85, "AWS": 70}
+    
+    5. Soft Skills:
+       - List each skill with proficiency score (0-100)
+       - Example: {"Communication": 90, "Leadership": 75}
+    
+    6. Detailed Analysis:
+       - Key Strengths: Top 3-5 standout points
+       - Areas for Improvement: 3-5 specific points
+       - Market Fit: Current industry alignment
+       - Skill Gaps: Missing critical skills for target role
+       - Key Achievements: Quantifiable accomplishments
+       - Impact Metrics: {"metric": "value"}
+       - Areas of Expertise: Primary domains of expertise
+    
+    7. Recommendations:
+       - 3-5 actionable steps for improvement
+       
+    Provide clear justification for all scores and ensure feedback is specific and actionable.""",
+    expected_output="Structured CV analysis report with detailed metrics and scoring justification",
+    agent=cv_analyzer,
+    output_pydantic=CVAnalysisReport
+)
+
+# Create and run the agent
+agents = PraisonAIAgents(
+    agents=[cv_analyzer],
+    tasks=[cv_analysis_task]
+)
+
+# Read and pass CV content through start()
+with open('cv.txt', 'r') as file:
+    cv_content = file.read()
+
+# Start the analysis by passing CV content
+result = agents.start(cv_content)
+
+print(result)

agents/context-agents.py

@@ -0,0 +1,202 @@
+import streamlit as st
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from pydantic import BaseModel
+from typing import List, Dict
+import json
+import asyncio
+import nest_asyncio
+from functools import partial
+
+# Enable nested event loops
+nest_asyncio.apply()
+
+class SkillMetrics(BaseModel):
+    name: str
+    score: int
+    comments: str
+
+class CVAnalysisReport(BaseModel):
+    overall_score: int
+    skill_metrics: List[SkillMetrics]
+    experience_score: int
+    education_score: int
+    presentation_score: int
+    achievement_impact_score: int
+    market_readiness: int
+    key_strengths: List[str]
+    areas_for_improvement: List[str]
+    market_fit: str
+    recommendations: List[str]
+    technical_skills: List[Dict[str, int]]
+    soft_skills: List[Dict[str, int]]
+    skill_gaps: List[str]
+    key_achievements: List[str]
+    impact_metrics: List[Dict[str, str]]
+    areas_of_expertise: List[str]
+
+async def analyze_cv_async(cv_content):
+    cv_analyzer = Agent(
+        role="CV Analysis Expert",
+        goal="Provide comprehensive CV evaluation and recommendations",
+        backstory="""You are an expert CV analyst with deep knowledge of industry requirements, 
+        market trends, and talent assessment. You excel at evaluating skills, experience, 
+        and providing actionable recommendations.""",
+        verbose=True
+    )
+
+    cv_analysis_task = Task(
+        description="""Perform a detailed CV analysis with scoring metrics and provide output in the following format:
+        1. Overall Score (0-100):
+           - Calculate based on weighted average of all metrics
+        
+        2. Individual Skill Metrics:
+           - For each major skill found in CV:
+             * Name of skill
+             * Score (0-100)
+             * Specific feedback/comments
+        
+        3. Core Metrics (0-100 each):
+           - Experience Score: Based on relevance and years
+           - Education Score: Based on relevance and level
+           - Presentation Score: CV format, clarity, structure
+           - Achievement Impact Score: Measurable results
+           - Market Readiness: Current market fit
+        
+        4. Technical Skills:
+           - List each skill with proficiency score (0-100)
+        
+        5. Soft Skills:
+           - List each skill with proficiency score (0-100)
+        
+        6. Detailed Analysis sections
+        
+        7. Recommendations:
+           - 3-5 actionable steps for improvement""",
+        expected_output="Structured CV analysis report with detailed metrics and scoring justification",
+        agent=cv_analyzer,
+        output_pydantic=CVAnalysisReport
+    )
+
+    agents = PraisonAIAgents(
+        agents=[cv_analyzer],
+        tasks=[cv_analysis_task]
+    )
+
+    try:
+        result = await agents.astart(cv_content)
+        return result['task_results'][0].pydantic
+    except Exception as e:
+        print(f"Error during analysis: {str(e)}")
+        raise e
+
+def analyze_cv(cv_content):
+    async def run_analysis():
+        return await analyze_cv_async(cv_content)
+    
+    try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        result = loop.run_until_complete(run_analysis())
+        return result
+    except Exception as e:
+        raise e
+    finally:
+        loop.close()
+
+def main():
+    st.set_page_config(page_title="CV Analyzer", layout="wide")
+    st.title("Professional CV Analyzer")
+    
+    # File upload
+    cv_file = st.file_uploader("Upload your CV (TXT format)", type=['txt'])
+    
+    if cv_file:
+        cv_content = cv_file.read().decode()
+        
+        with st.spinner('Analyzing your CV...'):
+            try:
+                analysis = analyze_cv(cv_content)
+                
+                # Display Overall Score
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("Overall Score", f"{analysis.overall_score}/100")
+                with col2:
+                    st.metric("Market Readiness", f"{analysis.market_readiness}/100")
+                with col3:
+                    st.metric("Experience Score", f"{analysis.experience_score}/100")
+
+                # Core Metrics
+                st.subheader("Core Metrics")
+                metrics_cols = st.columns(4)
+                with metrics_cols[0]:
+                    st.metric("Education", f"{analysis.education_score}/100")
+                with metrics_cols[1]:
+                    st.metric("Presentation", f"{analysis.presentation_score}/100")
+                with metrics_cols[2]:
+                    st.metric("Achievement Impact", f"{analysis.achievement_impact_score}/100")
+                with metrics_cols[3]:
+                    st.metric("Market Readiness", f"{analysis.market_readiness}/100")
+
+                # Skill Metrics
+                st.subheader("Detailed Skill Analysis")
+                for skill in analysis.skill_metrics:
+                    with st.expander(f"{skill.name} - Score: {skill.score}/100"):
+                        st.write(skill.comments)
+
+                # Technical and Soft Skills
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.subheader("Technical Skills")
+                    for skill in analysis.technical_skills:
+                        for skill_name, score in skill.items():
+                            st.progress(score/100)
+                            st.caption(f"{skill_name}: {score}/100")
+                
+                with col2:
+                    st.subheader("Soft Skills")
+                    for skill in analysis.soft_skills:
+                        for skill_name, score in skill.items():
+                            st.progress(score/100)
+                            st.caption(f"{skill_name}: {score}/100")
+
+                # Key Information
+                st.subheader("Key Analysis")
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.write("🎯 Key Strengths")
+                    for strength in analysis.key_strengths:
+                        st.write(f"• {strength}")
+                    
+                    st.write("🎮 Areas of Expertise")
+                    for expertise in analysis.areas_of_expertise:
+                        st.write(f"• {expertise}")
+
+                with col2:
+                    st.write("🔄 Areas for Improvement")
+                    for area in analysis.areas_for_improvement:
+                        st.write(f"• {area}")
+                    
+                    st.write("⚠️ Skill Gaps")
+                    for gap in analysis.skill_gaps:
+                        st.write(f"• {gap}")
+
+                # Impact Metrics
+                st.subheader("Impact Metrics")
+                for metric in analysis.impact_metrics:
+                    for key, value in metric.items():
+                        st.metric(key, value)
+
+                # Recommendations
+                st.subheader("📋 Recommendations")
+                for rec in analysis.recommendations:
+                    st.write(f"• {rec}")
+
+            except Exception as e:
+                st.error(f"An error occurred during analysis: {str(e)}")
+    
+    else:
+        st.info("Please upload your CV in TXT format to begin the analysis")
+
+if __name__ == "__main__":
+    main()

agents/context-multi-tasks.py

@@ -0,0 +1,61 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from pydantic import BaseModel
+from typing import List, Dict
+
+class CVAnalysisReport(BaseModel):
+    overall_score: int
+    key_strengths: List[str]
+    areas_for_improvement: List[str]
+    market_fit: str
+    recommendations: List[str]
+    technical_skills: List[str]
+    soft_skills: List[str]
+    skill_gaps: List[str]
+    key_achievements: List[str]
+    impact_metrics: List[Dict[str, str]]
+    areas_of_expertise: List[str]
+
+# Create single CV analysis agent
+cv_analyzer = Agent(
+    role="CV Analysis Expert",
+    goal="Provide comprehensive CV evaluation and recommendations",
+    backstory="""You are an expert CV analyst with deep knowledge of industry requirements, 
+    market trends, and talent assessment. You excel at evaluating skills, experience, 
+    and providing actionable recommendations.""",
+    verbose=True
+)
+
+# Read CV content first
+with open('cv.txt', 'r') as file:
+    cv_content = file.read()
+
+cv_key_strengths = Task(
+    description="List the key strengths to look",
+    expected_output="List of key strengths",
+    agent=cv_analyzer,
+)
+
+# Single comprehensive analysis task with CV content in context
+cv_analysis_task = Task(
+    description="""Analyze the CV comprehensively including:
+    1. Technical and soft skills assessment
+    2. Experience and achievements evaluation
+    3. Overall CV evaluation with recommendations
+    Provide detailed insights and actionable recommendations.""",
+    expected_output="Complete CV analysis report",
+    agent=cv_analyzer,
+    output_pydantic=CVAnalysisReport,
+    context=[cv_content, cv_key_strengths]  # Pass CV content directly in task context
+)
+
+# Create and run the agent
+agents = PraisonAIAgents(
+    agents=[cv_analyzer],
+    tasks=[cv_key_strengths,cv_analysis_task],
+    process="sequential"
+)
+
+# Start the analysis - no need to pass content again since it's in task context
+result = agents.start()
+
+print(result)

agents/cot-agents-batch.py

@@ -0,0 +1,73 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import cot_save, cot_upload_to_huggingface
+
+# Create a COT agent for generating and managing chain of thought solutions
+cot_agent = 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",  # Using recommended model
+)
+
+save_to_huggingface_agent = Agent(
+    name="SaveToHuggingface",
+    role="Save to Huggingface",
+    goal="Save 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",  # Using recommended model
+)
+
+# Define question-answer pairs to process in batches
+qa_pairs = [
+    {
+        "question": "What is the sum of numbers from 1 to 10?",
+        "answer": "55"
+    },
+    {
+        "question": "Calculate the area of a circle with radius 5",
+        "answer": "78.54"
+    }
+]
+
+# Process qa_pairs in batches
+batch_size = 2
+for i in range(0, len(qa_pairs), batch_size):
+    batch_qa = qa_pairs[i:i + batch_size]
+    
+    # Create task for current batch
+    qa_text = "\n".join(
+        f"- Q: {qa['question']}\n  A: {qa['answer']}" 
+        for qa in batch_qa
+    )
+    
+    cot_task = Task(
+        description=(
+            "For each Q&A pair:\n"
+            "1. Use the tool cot_save to generate a chain of thought solution\n"
+            "2. Save to CSV file with filename 'cot_dataset.csv'\n\n"
+            f"Q&A Pairs:\n{qa_text}"
+        ),
+        expected_output="Chain of thought solutions saved to CSV",
+        agent=cot_agent,
+        name=f"generate_cot_solutions_batch_{i//batch_size + 1}"
+    )
+
+    save_to_huggingface_task = Task(
+        description="Save to Huggingface dataset at mervinpraison/cot-dataset , cot_dataset.csv",
+        expected_output="Chain of thought solutions saved to Huggingface",
+        agent=save_to_huggingface_agent,
+        name=f"save_to_huggingface_batch_{i//batch_size + 1}"
+    )
+
+    # Initialize and run the agent
+    agents = PraisonAIAgents(
+        agents=[cot_agent, save_to_huggingface_agent],
+        tasks=[cot_task, save_to_huggingface_task]
+    )
+
+    # Execute current batch
+    result = agents.start()
+    print(f"\nBatch {i//batch_size + 1} completed. Solutions appended to CSV file.")

agents/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()

agents/crewai-tools-example.py

@@ -0,0 +1,27 @@
+# example tools.py
+from duckduckgo_search import DDGS
+from praisonai_tools import BaseTool
+
+class InternetSearchTool(BaseTool):
+    name: str = "InternetSearchTool"
+    description: str = "Search Internet for relevant information based on a query or latest news"
+
+    def _run(self, query: str):
+        ddgs = DDGS()
+        results = ddgs.text(keywords=query, region='wt-wt', safesearch='moderate', max_results=5)
+        return results
+
+# Example agent
+from praisonaiagents import Agent
+from praisonaiagents import PraisonAIAgents
+agent = Agent(
+    name="Internet Search Agent",
+    tools=[InternetSearchTool],
+    instructions="""
+    You are an agent that can search the internet for relevant information based on a query or latest news.
+    """
+)
+
+# Run the agent
+result = PraisonAIAgents(agents=[agent], verbose=10).start()
+print(result)

agents/cv.txt

@@ -0,0 +1,57 @@
+Name: Alex Johnson
+Location: London, UK
+
+Professional Summary
+Dynamic and results-oriented leader with a proven track record of driving innovation, scaling operations, and achieving transformational growth. Over 15 years of experience in engineering, strategic management, and executive leadership in the automotive and renewable energy sectors. Passionate about sustainable technologies and visionary leadership.
+
+Professional Experience
+Chief Operating Officer (COO)
+NextGen Mobility Ltd. | Palo Alto, CA | 2020 – Present
+
+Spearheaded global operations for an electric vehicle company, scaling production by 200% in three years.
+Introduced automation-driven supply chain strategies, reducing costs by 15%.
+Collaborated with R&D to launch three new EV models, driving 25% revenue growth annually.
+Vice President of Engineering
+ElectroDrive Systems | San Francisco, CA | 2015 – 2020
+
+Led a team of 500+ engineers in developing next-generation EV batteries, achieving a 30% increase in energy efficiency.
+Secured $50M in government funding for sustainable energy innovation.
+Drove cross-functional collaboration, aligning product development with market needs.
+Director of Renewable Energy Initiatives
+GreenTech Innovations | London, UK | 2011 – 2015
+
+Oversaw £100M projects in solar and wind energy deployment across Europe.
+Established partnerships with policymakers to influence renewable energy legislation.
+Pioneered a smart energy grid system, enhancing energy distribution efficiency by 40%.
+Senior Project Manager
+Innovate Auto Ltd. | Munich, Germany | 2008 – 2011
+
+Managed R&D projects for autonomous driving technologies.
+Delivered projects 20% under budget through strategic resource allocation.
+Filed 10+ patents in automotive AI and renewable integration.
+Mechanical Engineer
+AutoFusion Technologies | Berlin, Germany | 2005 – 2008
+
+Designed core systems for EV powertrains, optimising energy consumption by 15%.
+Collaborated with suppliers to improve material efficiency, cutting costs by £5M annually.
+Education
+MBA in Strategic Management
+Harvard Business School | Cambridge, MA | 2015
+
+MSc in Renewable Energy Engineering
+Imperial College London | London, UK | 2007
+
+BSc in Mechanical Engineering
+Technical University of Munich | Munich, Germany | 2005
+
+Skills
+Strategic Leadership & Visionary Thinking
+Electric Vehicle Engineering
+Renewable Energy Systems
+Global Operations Management
+Policy Advocacy & Government Relations
+Supply Chain Optimisation
+Achievements
+Featured in Forbes 30 Under 40 for innovations in EV technology.
+Author of The Future of Sustainable Mobility.
+Keynote speaker at World Energy Summit, 2023.

agents/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?")

agents/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}) 

agents/deepseek-rag-agents-task.py

@@ -0,0 +1,54 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+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",
+        },
+    },
+}
+
+# Create an agent
+rag_agent = Agent(
+    name="RAG Agent",
+    role="Information Specialist",
+    goal="Retrieve knowledge efficiently",
+    llm="deepseek-r1"
+)
+
+# 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()

agents/deepseek-rag-agents-ui.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}) 

agents/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

agents/deepseek-reasoning-agents.py

@@ -0,0 +1,6 @@
+from praisonaiagents import Agent
+
+agent = Agent(instructions="You are helpful Assisant", llm="deepseek-reasoner", reasoning_steps=True)
+
+result = agent.start("Why sky is Blue?")
+print(result)

agents/deepseek-reasoning-multi-agents.py

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

agents/deepseek-reasoning-output-tokens.py

@@ -0,0 +1,19 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+llm_config = {
+    "model": "deepseek/deepseek-reasoner",
+    "max_tokens": 1
+}
+
+reasoning_agent = Agent(role="Helpful Assistant", llm=llm_config, reasoning_steps=True)
+small_agent = Agent(role="Helpful Assistant", llm="openai/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()

agents/deepseek-think.py

@@ -0,0 +1,18 @@
+from openai import OpenAI
+
+client = OpenAI()
+
+response = client.chat.completions.create(
+    model="deepseek-reasoner",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant"},
+        {"role": "user", "content": "Why sky is Blue?"},
+    ],
+    stream=True
+)
+
+for chunk in response:
+    if chunk.choices[0].delta.content is not None:
+        print(chunk.choices[0].delta.content, end="", flush=True)
+    if chunk.choices[0].delta.reasoning_content is not None:
+        print(chunk.choices[0].delta.reasoning_content, end="", flush=True)

agents/document.txt

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

agents/evaluator-optimiser.py

@@ -7,8 +7,8 @@ generator = Agent(
     goal="Generate initial solutions and incorporate feedback",
     instructions=(
         "1. Look at the context from previous tasks.\n"
-        "2. If you see that you have already produced 2 points, then add another 2 new points "
-        "   so that the total becomes 10.\n"
+        "2. If you see that you have already produced 2 points, then add another 2 new points starting with 3. "
+        "   so that the total becomes 4.\n"
         "3. Otherwise, just produce the first 2 points.\n"
         "4. Return only the final list of points, with no extra explanation."
     )
@@ -17,10 +17,10 @@ generator = Agent(
 evaluator = Agent(
     name="Evaluator",
     role="Solution evaluator",
-    goal="Evaluate solutions and provide improvement feedback",
+    goal="Evaluate solutions and respond with more or done",
     instructions=(
         "1. Count how many lines in the response start with a number and a period (like '1. ' or '2. ').\n"
-        "2. If there are 10 or more, respond with 'done'.\n"
+        "2. If there are 4 or more, respond with 'done'.\n"
         "3. Otherwise, respond with 'more'.\n"
         "4. Return only the single word: 'done' or 'more'."
     )
@@ -40,10 +40,9 @@ generate_task = Task(
 
 evaluate_task = Task(
     name="evaluate",
-    description="Check if there are 10 points about AI",
+    description="Check if there are 4 points about AI. ONLY RESPOND WITH 'more' or 'done' in your response field",
     expected_output="more or done",
     agent=evaluator,
-    next_tasks=["generate"],
     context=[generate_task],
     task_type="decision",
     condition={

agents/gradio-agents.py

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

agents/hackathon-judge-agent-code.py

@@ -0,0 +1,159 @@
+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}") 

agents/hackathon-judge-agent.py

@@ -0,0 +1,159 @@
+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}") 

agents/hackathon-judge-streamlit.py

@@ -0,0 +1,210 @@
+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!") 

agents/knowledge-agents-task.py

@@ -0,0 +1,70 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import logging
+import os
+import json
+
+# 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 = {
+    "version": "v1.1",
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "praison",
+            "path": os.path.abspath("./.praison"),
+            "host": None,
+            "port": None
+        }
+    },
+    "embedder": {
+        "provider": "openai",
+        "config": {
+            "model": "text-embedding-3-small",
+            "embedding_dims": 1536
+        }
+    },
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4o-mini",
+            "temperature": 0,
+            "max_tokens": 1000
+        }
+    }
+}
+
+# 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",
+    verbose=True
+)
+
+# Define a task for the agent
+knowledge_task = Task(
+    name="knowledge_task",
+    description="KAG",
+    expected_output="Answer to the question",
+    agent=knowledge_agent,
+    context=[
+        {
+            "embedding_db_config": json.dumps(config["vector_store"])
+        }
+    ]
+)
+
+# Create and start the agents
+agents = PraisonAIAgents(
+    agents=[knowledge_agent],
+    tasks=[knowledge_task],
+    process="sequential",
+    user_id="user1"
+)
+
+# Start execution
+result = agents.start()

agents/knowledge-agents.py

@@ -0,0 +1,21 @@
+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=["large.pdf"],
+    knowledge_config=config,
+    user_id="user1"
+)
+
+agent.start("What is KAG in one line?")

agents/knowledge-direct-simple-test.py

@@ -0,0 +1,44 @@
+import logging
+from praisonaiagents.knowledge import Knowledge
+import os
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+config = {
+    "version": "v1.1",
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "praison",
+            "path": os.path.abspath("./.praison"),
+            "host": None,
+            "port": None
+        }
+    },
+    "embedder": {
+        "provider": "openai",
+        "config": {
+            "model": "text-embedding-3-small",
+            "embedding_dims": 1536
+        }
+    },
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4o-mini",
+            "temperature": 0,
+            "max_tokens": 1000
+        }
+    }
+}
+
+knowledge = Knowledge(config)
+
+# Search for memories based on a query
+query = "KAG"
+logger.info(f"Searching for memories with query: {query}")
+search_results = knowledge.search(query, user_id="user1")
+logger.info(f"Search results: {search_results}")
+print(f"\nSearch results for '{query}':")
+print(search_results)

agents/knowledge-direct-test.py

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

agents/knowledge-large-pdf-test.py

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

agents/litellm-reasoning.py

@@ -0,0 +1,14 @@
+from litellm import completion
+
+messages = [{"role": "user", "content": "What is 1+1?"}]
+resp = completion(
+    model="deepseek/deepseek-reasoner",
+    messages=messages,
+    stream=False
+)
+
+reasoning_content = resp.choices[0].message.provider_specific_fields["reasoning_content"]
+content = resp.choices[0].message.content
+
+print(reasoning_content)
+print(content)

agents/llm-deepseek-agents.py

@@ -0,0 +1,9 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are helpful Assisant", 
+    llm="deepseek/deepseek-reasoner"
+)
+
+result = agent.start("Why sky is Blue?")
+print(result)

agents/llm-deepseek-reasoning-agents.py

@@ -0,0 +1,10 @@
+from praisonaiagents import Agent
+
+agent = Agent(
+    instructions="You are helpful Assisant", 
+    llm="deepseek/deepseek-reasoner", 
+    reasoning_steps=True
+)
+
+result = agent.start("Why sky is Blue?")
+print(result)

agents/llm-deepseek-reasoning-steps.py

@@ -0,0 +1,14 @@
+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="openai/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()

agents/llm-gemini-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)

agents/llm-gemini.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?")

agents/llm-langchain-toolcall.py

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

agents/md.py

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

agents/memory-add-search.py

@@ -0,0 +1,220 @@
+from mem0 import Memory
+import logging
+import json
+import os
+import time
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class MemoryManager:
+    def __init__(self):
+        """Initialize Mem0 Memory manager with configuration"""
+        # Define the complete configuration with only supported fields
+        config = {
+            "version": "v1.1",
+            "custom_prompt": None,
+            "vector_store": {
+                "provider": "chroma",
+                "config": {
+                    "collection_name": "praison",
+                    "path": os.path.abspath("./.praison/storage"),
+                    "host": None,
+                    "port": None
+                }
+            },
+            "embedder": {
+                "provider": "openai",
+                "config": {
+                    "model": "text-embedding-3-small",
+                    "embedding_dims": 1536
+                }
+            },
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-4o-mini",
+                    "temperature": 0,
+                    "max_tokens": 1000
+                }
+            }
+        }
+        
+        # Ensure storage directory exists
+        storage_path = os.path.abspath("./.praison/storage")
+        if os.path.exists(storage_path):
+            logger.info(f"Clearing existing storage at {storage_path}")
+            import shutil
+            shutil.rmtree(storage_path)
+        os.makedirs(storage_path, exist_ok=True)
+        logger.info(f"Created storage path: {storage_path}")
+        
+        # Initialize memory
+        self.memory = Memory.from_config(config)
+        logger.info("Memory manager initialized")
+
+    def pretty_print(self, data: Any) -> None:
+        """Helper function to print memory data in a readable format"""
+        if isinstance(data, (dict, list)):
+            print(json.dumps(data, indent=2))
+        else:
+            print(data)
+            
+    def extract_memory_id(self, result: Any) -> Optional[str]:
+        """Extract memory ID from the result, handling different formats"""
+        try:
+            if isinstance(result, dict):
+                # v1.1 format
+                memories = result.get('results', [])
+                return memories[0]['id'] if memories else None
+            elif isinstance(result, list):
+                # v1.0 format
+                return result[0]['id'] if result else None
+            return None
+        except (KeyError, IndexError) as e:
+            logger.warning(f"Could not extract memory ID from result: {e}")
+            return None
+
+    def prepare_metadata(self, metadata: Optional[Dict]) -> Dict:
+        """Prepare metadata by converting values to acceptable types"""
+        if not metadata:
+            return {}
+            
+        clean_metadata = {}
+        for key, value in metadata.items():
+            if isinstance(value, (str, int, float, bool)):
+                clean_metadata[key] = value
+            elif isinstance(value, list):
+                clean_metadata[key] = ','.join(map(str, value))
+            elif isinstance(value, dict):
+                clean_metadata[key] = json.dumps(value)
+            else:
+                clean_metadata[key] = str(value)
+        return clean_metadata
+
+    def verify_memory_addition(self, user_id: str, max_retries: int = 3) -> bool:
+        """Verify that memory was added successfully"""
+        for attempt in range(max_retries):
+            try:
+                time.sleep(0.5)  # Brief pause to allow indexing
+                memories = self.memory.get_all(user_id=user_id)
+                if len(memories.get('results', [])) > 0:
+                    return True
+                logger.warning(f"Memory not found on attempt {attempt + 1}")
+            except Exception as e:
+                logger.warning(f"Verification attempt {attempt + 1} failed: {e}")
+            if attempt < max_retries - 1:
+                time.sleep(1)
+        return False
+
+    def add_memory(self, text: str, user_id: Optional[str] = None, metadata: Optional[Dict] = None) -> Dict:
+        """Add a new memory with error handling and verification"""
+        try:
+            logger.info(f"Adding memory for user {user_id}")
+            clean_metadata = self.prepare_metadata(metadata)
+            logger.debug(f"Prepared metadata: {clean_metadata}")
+            
+            messages = [{"role": "user", "content": text}]
+            result = self.memory.add(
+                messages=messages,
+                user_id=user_id,
+                metadata=clean_metadata
+            )
+            
+            if self.verify_memory_addition(user_id):
+                logger.info("Memory added and verified successfully")
+            else:
+                logger.warning("Memory addition could not be verified")
+                
+            return result
+            
+        except Exception as e:
+            logger.error(f"Failed to add memory: {str(e)}")
+            raise
+
+    def get_all_memories(self, user_id: Optional[str] = None) -> Dict:
+        """Retrieve all memories for a user"""
+        try:
+            logger.info(f"Retrieving all memories for user {user_id}")
+            memories = self.memory.get_all(user_id=user_id)
+            count = len(memories.get('results', []))
+            logger.info(f"Retrieved {count} memories")
+            return memories
+        except Exception as e:
+            logger.error(f"Failed to retrieve memories: {str(e)}")
+            raise
+
+    def search_memories(self, query: str, user_id: Optional[str] = None, limit: int = 5) -> Dict:
+        """Search memories with a query"""
+        try:
+            logger.info(f"Searching memories with query: {query}")
+            results = self.memory.search(
+                query=query,
+                user_id=user_id,
+                limit=limit
+            )
+            count = len(results.get('results', []))
+            logger.info(f"Found {count} matching memories")
+            return results
+        except Exception as e:
+            logger.error(f"Search failed: {str(e)}")
+            raise
+
+def main():
+    try:
+        # Initialize memory manager
+        manager = MemoryManager()
+        
+        # Add a test memory
+        print("\n1. Adding a new memory:")
+        metadata = {
+            "category": "hobbies",
+            "timestamp": datetime.now().isoformat(),
+            "tags": "tennis,learning",
+            "priority": 1,
+            "source": "user_input"
+        }
+        
+        result = manager.add_memory(
+            text="I am working on improving my tennis skills. Suggest some online courses.",
+            user_id="alice",
+            metadata=metadata
+        )
+        manager.pretty_print(result)
+        
+        # Wait briefly for indexing
+        time.sleep(1)
+        
+        print("\n2. Retrieving all memories:")
+        all_memories = manager.get_all_memories(user_id="alice")
+        manager.pretty_print(all_memories)
+        
+        print("\n3. Searching memories:")
+        search_results = manager.search_memories(
+            query="What are Alice's hobbies?",
+            user_id="alice",
+            limit=5
+        )
+        manager.pretty_print(search_results)
+        
+        # Print summary
+        print("\nMemory Store Summary:")
+        total_memories = len(all_memories.get('results', []))
+        print(f"Total memories stored: {total_memories}")
+        if total_memories > 0:
+            print("Available memories:")
+            for mem in all_memories['results']:
+                print(f"- {mem.get('memory', 'No content')}")
+
+    except Exception as e:
+        logger.error(f"Main process failed: {str(e)}", exc_info=True)
+        raise
+
+if __name__ == "__main__":
+    main()

agents/memory-search-advanced.py

@@ -0,0 +1,143 @@
+from mem0 import Memory
+import logging
+import json
+import os
+from typing import Dict, Any, Optional
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class MemorySearcher:
+    def __init__(self):
+        """Initialize Mem0 Memory searcher with configuration"""
+        # Define the configuration
+        config = {
+            "version": "v1.1",
+            "vector_store": {
+                "provider": "chroma",
+                "config": {
+                    "collection_name": "praison",
+                    "path": os.path.abspath("./.praison/storage"),
+                    "host": None,
+                    "port": None
+                }
+            },
+            "embedder": {
+                "provider": "openai",
+                "config": {
+                    "model": "text-embedding-3-small",
+                    "embedding_dims": 1536
+                }
+            },
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-4o-mini",
+                    "temperature": 0,
+                    "max_tokens": 1000
+                }
+            }
+        }
+        
+        # Initialize memory
+        self.memory = Memory.from_config(config)
+        logger.info("Memory searcher initialized")
+
+    def pretty_print(self, data: Any) -> None:
+        """Helper function to print data in a readable format"""
+        if isinstance(data, (dict, list)):
+            print(json.dumps(data, indent=2))
+        else:
+            print(data)
+
+    def get_all_memories(self, user_id: Optional[str] = None) -> Dict:
+        """Retrieve all memories for a user"""
+        try:
+            logger.info(f"Retrieving all memories for user {user_id}")
+            memories = self.memory.get_all(user_id=user_id)
+            count = len(memories.get('results', []))
+            logger.info(f"Retrieved {count} memories")
+            return memories
+        except Exception as e:
+            logger.error(f"Failed to retrieve memories: {str(e)}")
+            raise
+
+    def search_memories(self, query: str, user_id: Optional[str] = None, limit: int = 5) -> Dict:
+        """Search memories with a query"""
+        try:
+            logger.info(f"Searching memories with query: {query}")
+            results = self.memory.search(
+                query=query,
+                user_id=user_id,
+                limit=limit
+            )
+            count = len(results.get('results', []))
+            logger.info(f"Found {count} matching memories")
+            return results
+        except Exception as e:
+            logger.error(f"Search failed: {str(e)}")
+            raise
+
+    def list_unique_users(self) -> list:
+        """List all unique users in the memory store"""
+        try:
+            all_memories = self.memory.get_all()
+            users = set()
+            for memory in all_memories.get('results', []):
+                if 'user_id' in memory:
+                    users.add(memory['user_id'])
+            return sorted(list(users))
+        except Exception as e:
+            logger.error(f"Failed to list users: {str(e)}")
+            raise
+
+def main():
+    try:
+        # Initialize memory searcher
+        searcher = MemorySearcher()
+        
+        # Get list of users
+        print("\n1. Available users in the memory store:")
+        users = searcher.list_unique_users()
+        searcher.pretty_print(users)
+        
+        if not users:
+            print("No users found in the memory store. Please add some memories first.")
+            return
+            
+        # Example user (using first user found)
+        example_user = users[0]
+        
+        print(f"\n2. All memories for user '{example_user}':")
+        all_memories = searcher.get_all_memories(user_id=example_user)
+        searcher.pretty_print(all_memories)
+        
+        print(f"\n3. Searching memories for user '{example_user}':")
+        search_results = searcher.search_memories(
+            query="What are their hobbies?",
+            user_id=example_user,
+            limit=5
+        )
+        searcher.pretty_print(search_results)
+        
+        # Print summary
+        print("\nMemory Store Summary:")
+        total_memories = len(all_memories.get('results', []))
+        print(f"Total memories for {example_user}: {total_memories}")
+        if total_memories > 0:
+            print("Available memories:")
+            for mem in all_memories['results']:
+                print(f"- {mem.get('memory', 'No content')}")
+                if 'metadata' in mem:
+                    print(f"  Metadata: {mem['metadata']}")
+
+    except Exception as e:
+        logger.error(f"Main process failed: {str(e)}", exc_info=True)
+        raise
+
+if __name__ == "__main__":
+    main()

agents/memory-search-simple-test.py

@@ -0,0 +1,26 @@
+from mem0 import Memory
+import os
+import json
+
+# Basic configuration
+config = {
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "praison",
+            "path": ".praison",
+        }
+    }
+}
+
+# Initialize memory
+memory = Memory.from_config(config)
+
+# Search Alice's hobbies
+search_results = memory.search(
+    query="KAG",
+    user_id="user1",
+    limit=5
+)
+
+print(search_results)

agents/memory-search-simple.py

@@ -0,0 +1,46 @@
+from mem0 import Memory
+import os
+import json
+
+# Basic configuration
+config = {
+    "version": "v1.1",
+    "vector_store": {
+        "provider": "chroma",
+        "config": {
+            "collection_name": "praison",
+            "path": os.path.abspath("./.praison/storage")
+        }
+    },
+    "embedder": {
+        "provider": "openai",
+        "config": {
+            "model": "text-embedding-3-small"
+        }
+    },
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4o-mini"
+        }
+    }
+}
+
+# Initialize memory
+memory = Memory.from_config(config)
+
+# Search Alice's hobbies
+search_results = memory.search(
+    query="What are Alice's hobbies?",
+    user_id="alice",
+    limit=5
+)
+
+# Print results in a readable format
+print("\nAlice's Memories:")
+for memory in search_results['results']:
+    print(f"\nMemory: {memory['memory']}")
+    print(f"Score: {memory['score']}")
+    if 'metadata' in memory:
+        print("Metadata:")
+        print(json.dumps(memory['metadata'], indent=2))

agents/orchestrator-workers.py

@@ -97,7 +97,8 @@ workflow = PraisonAIAgents(
     agents=[router, worker1, worker2, worker3, synthesizer],
     tasks=[router_task, worker1_task, worker2_task, worker3_task, synthesize_task],
     process="workflow",
-    verbose=True
+    verbose=True,
+    max_iter=10
 )
 
 # Run orchestrated workflow

agents/praisonaiagents/__init__.py

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

agents/praisonaiagents/agents/agents.py

@@ -12,6 +12,7 @@ from ..agent.agent import Agent
 from ..task.task import Task
 from ..process.process import Process, LoopItems
 import asyncio
+import uuid
 
 # Set up logger
 logger = logging.getLogger(__name__)
@@ -44,10 +45,29 @@ def process_video(video_path: str, seconds_per_frame=2):
     return base64_frames
 
 class PraisonAIAgents:
-    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None, memory=False, memory_config=None, embedder=None):
+    def __init__(self, agents, tasks=None, verbose=0, completion_checker=None, max_retries=5, process="sequential", manager_llm=None, memory=False, memory_config=None, embedder=None, user_id=None, max_iter=10):
+        # Add check at the start if memory is requested
+        if memory:
+            try:
+                from ..memory.memory import Memory
+                MEMORY_AVAILABLE = True
+            except ImportError:
+                raise ImportError(
+                    "Memory features requested but memory dependencies not installed. "
+                    "Please install with: pip install \"praisonaiagents[memory]\""
+                )
+
         if not agents:
             raise ValueError("At least one agent must be provided")
-            
+        
+        self.run_id = str(uuid.uuid4())  # Auto-generate run_id
+        self.user_id = user_id or "praison"  # Optional user_id
+        self.max_iter = max_iter  # Add max_iter parameter
+
+        # Pass user_id to each agent
+        for agent in agents:
+            agent.user_id = self.user_id
+
         self.agents = agents
         self.tasks = {}
         if max_retries < 3:
@@ -221,15 +241,46 @@ You need to do the following task: {task.description}.
 Expected Output: {task.expected_output}.
 """
         if task.context:
-            context_results = ""
-            for context_task in task.context:
-                if context_task.result:
-                    context_results += f"Result of previous task {context_task.name if context_task.name else context_task.description}: {context_task.result.raw}\n"
-                else:
-                    context_results += f"Previous task {context_task.name if context_task.name else context_task.description} had no result.\n"
+            context_results = []  # Use list to avoid duplicates
+            for context_item in task.context:
+                if isinstance(context_item, str):
+                    context_results.append(f"Input Content:\n{context_item}")
+                elif isinstance(context_item, list):
+                    context_results.append(f"Input Content: {' '.join(str(x) for x in context_item)}")
+                elif hasattr(context_item, 'result'):  # Task object
+                    if context_item.result:
+                        context_results.append(
+                            f"Result of previous task {context_item.name if context_item.name else context_item.description}:\n{context_item.result.raw}"
+                        )
+                    else:
+                        context_results.append(
+                            f"Previous task {context_item.name if context_item.name else context_item.description} has no result yet."
+                        )
+                elif isinstance(context_item, dict) and "vector_store" in context_item:
+                    from ..knowledge.knowledge import Knowledge
+                    try:
+                        # Handle both string and dict configs
+                        cfg = context_item["vector_store"]
+                        if isinstance(cfg, str):
+                            cfg = json.loads(cfg)
+                        
+                        knowledge = Knowledge(config={"vector_store": cfg}, verbose=self.verbose)
+                        
+                        # Only use user_id as filter
+                        db_results = knowledge.search(
+                            task.description,
+                            user_id=self.user_id if self.user_id else None
+                        )
+                        context_results.append(f"[DB Context]: {str(db_results)}")
+                    except Exception as e:
+                        context_results.append(f"[Vector DB Error]: {e}")
+            
+            # Join unique context results
+            unique_contexts = list(dict.fromkeys(context_results))  # Remove duplicates
             task_prompt += f"""
-Here are the results of previous tasks that might be useful:\n
-{context_results}
+Context:
+
+{'  '.join(unique_contexts)}
 """
         task_prompt += "Please provide only the final result of your work. Do not add any conversation or extra explanation."
 
@@ -339,7 +390,8 @@ Here are the results of previous tasks that might be useful:\n
                     task.status = "completed"
                     # Run execute_callback for memory operations
                     try:
-                        await task.execute_callback(task_output)
+                        # Use the new sync wrapper to avoid pending coroutine issues
+                        task.execute_callback_sync(task_output)
                     except Exception as e:
                         logger.error(f"Error executing memory callback for task {task_id}: {e}")
                         logger.exception(e)
@@ -348,7 +400,12 @@ Here are the results of previous tasks that might be useful:\n
                     if task.callback:
                         try:
                             if asyncio.iscoroutinefunction(task.callback):
-                                await task.callback(task_output)
+                                if asyncio.get_event_loop().is_running():
+                                    asyncio.create_task(task.callback(task_output))
+                                else:
+                                    loop = asyncio.new_event_loop()
+                                    asyncio.set_event_loop(loop)
+                                    loop.run_until_complete(task.callback(task_output))
                             else:
                                 task.callback(task_output)
                         except Exception as e:
@@ -381,7 +438,8 @@ Here are the results of previous tasks that might be useful:\n
             tasks=self.tasks,
             agents=self.agents,
             manager_llm=self.manager_llm,
-            verbose=self.verbose
+            verbose=self.verbose,
+            max_iter=self.max_iter
         )
         
         if self.process == "workflow":
@@ -419,8 +477,16 @@ Here are the results of previous tasks that might be useful:\n
                 else:
                     self.run_task(task_id)
 
-    async def astart(self):
+    async def astart(self, content=None, **kwargs):
         """Async version of start method"""
+        if content:
+            # Add content to context of all tasks
+            for task in self.tasks.values():
+                if isinstance(content, (str, list)):
+                    if not task.context:
+                        task.context = []
+                    task.context.append(content)
+
         await self.arun_all_tasks()
         return {
             "task_status": self.get_all_tasks_status(),
@@ -477,16 +543,48 @@ You need to do the following task: {task.description}.
 Expected Output: {task.expected_output}.
 """
         if task.context:
-            context_results = ""
-            for context_task in task.context:
-                if context_task.result:
-                    context_results += f"Result of previous task {context_task.name if context_task.name else context_task.description}: {context_task.result.raw}\n"
-                else:
-                    context_results += f"Previous task {context_task.name if context_task.name else context_task.description} had no result.\n"
+            context_results = []  # Use list to avoid duplicates
+            for context_item in task.context:
+                if isinstance(context_item, str):
+                    context_results.append(f"Input Content:\n{context_item}")
+                elif isinstance(context_item, list):
+                    context_results.append(f"Input Content: {' '.join(str(x) for x in context_item)}")
+                elif hasattr(context_item, 'result'):  # Task object
+                    if context_item.result:
+                        context_results.append(
+                            f"Result of previous task {context_item.name if context_item.name else context_item.description}:\n{context_item.result.raw}"
+                        )
+                    else:
+                        context_results.append(
+                            f"Previous task {context_item.name if context_item.name else context_item.description} has no result yet."
+                        )
+                elif isinstance(context_item, dict) and "vector_store" in context_item:
+                    from ..knowledge.knowledge import Knowledge
+                    try:
+                        # Handle both string and dict configs
+                        cfg = context_item["vector_store"]
+                        if isinstance(cfg, str):
+                            cfg = json.loads(cfg)
+                        
+                        knowledge = Knowledge(config={"vector_store": cfg}, verbose=self.verbose)
+                        
+                        # Only use user_id as filter
+                        db_results = knowledge.search(
+                            task.description,
+                            user_id=self.user_id if self.user_id else None
+                        )
+                        context_results.append(f"[DB Context]: {str(db_results)}")
+                    except Exception as e:
+                        context_results.append(f"[Vector DB Error]: {e}")
+            
+            # Join unique context results
+            unique_contexts = list(dict.fromkeys(context_results))  # Remove duplicates
             task_prompt += f"""
-Here are the results of previous tasks that might be useful:\n
-{context_results}
+Context:
+
+{'  '.join(unique_contexts)}
 """
+
         # Add memory context if available
         if task.memory:
             try:
@@ -615,12 +713,8 @@ Here are the results of previous tasks that might be useful:\n
                     task.status = "completed"
                     # Run execute_callback for memory operations
                     try:
-                        if asyncio.get_event_loop().is_running():
-                            asyncio.create_task(task.execute_callback(task_output))
-                        else:
-                            loop = asyncio.new_event_loop()
-                            asyncio.set_event_loop(loop)
-                            loop.run_until_complete(task.execute_callback(task_output))
+                        # Use the new sync wrapper to avoid pending coroutine issues
+                        task.execute_callback_sync(task_output)
                     except Exception as e:
                         logger.error(f"Error executing memory callback for task {task_id}: {e}")
                         logger.exception(e)
@@ -667,7 +761,8 @@ Here are the results of previous tasks that might be useful:\n
             tasks=self.tasks,
             agents=self.agents,
             manager_llm=self.manager_llm,
-            verbose=self.verbose
+            verbose=self.verbose,
+            max_iter=self.max_iter
         )
         
         if self.process == "workflow":
@@ -706,12 +801,24 @@ Here are the results of previous tasks that might be useful:\n
             return str(agent[0])
         return None
 
-    def start(self):
+    def start(self, content=None, **kwargs):
+        """Start agent execution with optional content and config"""
+        if content:
+            # Add content to context of all tasks
+            for task in self.tasks.values():
+                if isinstance(content, (str, list)):
+                    # If context is empty, initialize it
+                    if not task.context:
+                        task.context = []
+                    # Add content to context
+                    task.context.append(content)
+                
+        # Run tasks as before
         self.run_all_tasks()
         return {
             "task_status": self.get_all_tasks_status(),
             "task_results": {task_id: self.get_task_result(task_id) for task_id in self.tasks}
-        } 
+        }
 
     def set_state(self, key: str, value: Any) -> None:
         """Set a state value"""

agents/praisonaiagents/knowledge/__init__.py

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

agents/praisonaiagents/knowledge/chunking.py

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

agents/praisonaiagents/knowledge/knowledge.py

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

agents/praisonaiagents/llm/__init__.py

@@ -0,0 +1,20 @@
+import logging
+import warnings
+
+# Suppress all relevant logs at module level
+logging.getLogger("litellm").setLevel(logging.ERROR)
+logging.getLogger("openai").setLevel(logging.ERROR)
+logging.getLogger("httpx").setLevel(logging.ERROR)
+logging.getLogger("httpcore").setLevel(logging.ERROR)
+logging.getLogger("pydantic").setLevel(logging.ERROR)
+
+# Suppress pydantic warnings
+warnings.filterwarnings("ignore", category=UserWarning, module="pydantic")
+
+# Configure logging to suppress all INFO messages
+logging.basicConfig(level=logging.WARNING)
+
+# Import after suppressing warnings
+from .llm import LLM, LLMContextLengthExceededException
+
+__all__ = ["LLM", "LLMContextLengthExceededException"]

agents/praisonaiagents/main.py

@@ -14,6 +14,15 @@ from rich.logging import RichHandler
 from rich.live import Live
 import asyncio
 
+# # Configure root logger
+# logging.basicConfig(level=logging.WARNING)
+
+# Suppress litellm logs
+logging.getLogger("litellm").handlers = []
+logging.getLogger("litellm.utils").handlers = []
+logging.getLogger("litellm").propagate = False
+logging.getLogger("litellm.utils").propagate = False
+
 LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
 
 logging.basicConfig(
@@ -23,6 +32,10 @@ logging.basicConfig(
     handlers=[RichHandler(rich_tracebacks=True)]
 )
 
+# Add these lines to suppress markdown parser debug logs
+logging.getLogger('markdown_it').setLevel(logging.WARNING)
+logging.getLogger('rich.markdown').setLevel(logging.WARNING)
+
 # Global list to store error logs
 error_logs = []
 
@@ -340,7 +353,7 @@ class ReflectionOutput(BaseModel):
     reflection: str
     satisfactory: Literal["yes", "no"]
 
-client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+client = OpenAI(api_key=(os.environ["OPENAI_API_KEY"] if os.environ.get("OPENAI_API_KEY") else "xxxx"))
 
 class TaskOutput(BaseModel):
     description: str

agents/praisonaiagents/memory/memory.py

@@ -15,7 +15,7 @@ try:
     CHROMADB_AVAILABLE = True
 except ImportError:
     CHROMADB_AVAILABLE = False
-    logger.warning("To use memory features, please run: pip install \"praisonaiagents[memory]\"")
+    pass
 
 try:
     import mem0

agents/praisonaiagents/task/task.py

@@ -1,6 +1,6 @@
 import logging
 import asyncio
-from typing import List, Optional, Dict, Any, Type, Callable, Union, Coroutine
+from typing import List, Optional, Dict, Any, Type, Callable, Union, Coroutine, Literal
 from pydantic import BaseModel
 from ..main import TaskOutput
 from ..agent.agent import Agent
@@ -19,7 +19,7 @@ class Task:
         agent: Optional[Agent] = None,
         name: Optional[str] = None,
         tools: Optional[List[Any]] = None,
-        context: Optional[List["Task"]] = None,
+        context: Optional[List[Union[str, List, 'Task']]] = None,
         async_execution: Optional[bool] = False,
         config: Optional[Dict[str, Any]] = None,
         output_file: Optional[str] = None,
@@ -37,8 +37,22 @@ class Task:
         is_start: bool = False,
         loop_state: Optional[Dict[str, Union[str, int]]] = None,
         memory=None,
-        quality_check=True
+        quality_check=True,
+        input_file: Optional[str] = None,
+        rerun: bool = False # Renamed from can_rerun and logic inverted, default True for backward compatibility
     ):
+        # Add check if memory config is provided
+        if memory is not None or (config and config.get('memory_config')):
+            try:
+                from ..memory.memory import Memory
+                MEMORY_AVAILABLE = True
+            except ImportError:
+                raise ImportError(
+                    "Memory features requested in Task but memory dependencies not installed. "
+                    "Please install with: pip install \"praisonaiagents[memory]\""
+                )
+
+        self.input_file = input_file
         self.id = str(uuid.uuid4()) if id is None else str(id)
         self.name = name
         self.description = description
@@ -63,6 +77,7 @@ class Task:
         self.loop_state = loop_state if loop_state else {}
         self.memory = memory
         self.quality_check = quality_check
+        self.rerun = rerun # Assigning the rerun parameter
 
         # Set logger level based on config verbose level
         verbose = self.config.get("verbose", 0)
@@ -70,7 +85,7 @@ class Task:
             logger.setLevel(logging.INFO)
         else:
             logger.setLevel(logging.WARNING)
-            
+
         # Also set third-party loggers to WARNING
         logging.getLogger('chromadb').setLevel(logging.WARNING)
         logging.getLogger('openai').setLevel(logging.WARNING)
@@ -83,6 +98,47 @@ class Task:
         # Track previous tasks based on next_tasks relationships
         self.previous_tasks = []
 
+        # If task_type="decision" and output_pydantic is not set
+        if self.task_type == "decision" and not self.output_pydantic:
+            from pydantic import BaseModel
+            from typing import Literal
+
+            # Gather condition keys for the "decision" field
+            condition_keys = list(self.condition.keys())
+            if not condition_keys:
+                # Fall back to placeholders if nothing is specified
+                condition_keys = ["next_task", "exit"]
+
+            # Create a dynamic literal type from condition keys
+            DecisionLiteral = Literal.__getitem__(tuple(condition_keys))
+
+            class DecisionModel(BaseModel):
+                response: str
+                decision: DecisionLiteral
+
+            self.output_pydantic = DecisionModel
+
+        # If task_type="loop" and output_pydantic is not set
+        if self.task_type == "loop" and not self.output_pydantic:
+            from pydantic import BaseModel
+            from typing import Literal
+
+            # Gather condition keys for the "decision" field
+            condition_keys = list(self.condition.keys())
+            if not condition_keys:
+                # Fall back to placeholders if nothing is specified
+                condition_keys = ["next_item", "exit"]
+
+            # Create a dynamic literal type
+            LoopLiteral = Literal.__getitem__(tuple(condition_keys))
+
+            class LoopModel(BaseModel):
+                response: str
+                decision: LoopLiteral
+                loop_id: str  # Additional field for loop
+
+            self.output_pydantic = LoopModel
+
     def __str__(self):
         return f"Task(name='{self.name if self.name else 'None'}', description='{self.description}', agent='{self.agent.name if self.agent else 'None'}', status='{self.status}')"
 
@@ -94,7 +150,7 @@ class Task:
                 logger.info(f"Task {self.id}: Initializing memory from config: {self.config['memory_config']}")
                 self.memory = Memory(config=self.config['memory_config'])
                 logger.info(f"Task {self.id}: Memory initialized successfully")
-                
+
                 # Verify database was created
                 if os.path.exists(self.config['memory_config']['storage']['path']):
                     logger.info(f"Task {self.id}: Memory database exists after initialization")
@@ -128,11 +184,11 @@ class Task:
         """Execute callback and store quality metrics if enabled"""
         logger.info(f"Task {self.id}: execute_callback called")
         logger.info(f"Quality check enabled: {self.quality_check}")
-        
+
         # Initialize memory if not already initialized
         if not self.memory:
             self.memory = self.initialize_memory()
-        
+
         logger.info(f"Memory object exists: {self.memory is not None}")
         if self.memory:
             logger.info(f"Memory config: {self.memory.cfg}")
@@ -148,24 +204,24 @@ class Task:
             except Exception as e:
                 logger.error(f"Task {self.id}: Failed to store task output in memory: {e}")
                 logger.exception(e)
-        
+
         logger.info(f"Task output: {task_output.raw[:100]}...")
-        
+
         if self.quality_check and self.memory:
             try:
                 logger.info(f"Task {self.id}: Starting memory operations")
                 logger.info(f"Task {self.id}: Calculating quality metrics for output: {task_output.raw[:100]}...")
-                
+
                 # Get quality metrics from LLM
                 metrics = self.memory.calculate_quality_metrics(
                     task_output.raw,
                     self.expected_output
                 )
                 logger.info(f"Task {self.id}: Quality metrics calculated: {metrics}")
-                
+
                 quality_score = metrics.get("accuracy", 0.0)
                 logger.info(f"Task {self.id}: Quality score: {quality_score}")
-                
+
                 # Store in both short and long-term memory with higher threshold
                 logger.info(f"Task {self.id}: Finalizing task output in memory...")
                 self.memory.finalize_task_output(
@@ -177,7 +233,7 @@ class Task:
                     task_id=self.id
                 )
                 logger.info(f"Task {self.id}: Finalized task output in memory")
-                
+
                 # Store quality metrics separately
                 logger.info(f"Task {self.id}: Storing quality metrics...")
                 self.memory.store_quality(
@@ -186,7 +242,7 @@ class Task:
                     task_id=self.id,
                     metrics=metrics
                 )
-                
+
                 # Store in both short and long-term memory with higher threshold
                 self.memory.finalize_task_output(
                     content=task_output.raw,
@@ -194,7 +250,7 @@ class Task:
                     quality_score=quality_score,
                     threshold=0.7  # Only high quality outputs in long-term memory
                 )
-                
+
                 # Build context for next tasks
                 if self.next_tasks:
                     logger.info(f"Task {self.id}: Building context for next tasks...")
@@ -203,7 +259,7 @@ class Task:
                         max_items=5
                     )
                     logger.info(f"Task {self.id}: Built context for next tasks: {len(context)} items")
-                
+
                 logger.info(f"Task {self.id}: Memory operations complete")
             except Exception as e:
                 logger.error(f"Task {self.id}: Failed to process memory operations: {e}")
@@ -219,4 +275,50 @@ class Task:
                     self.callback(task_output)
             except Exception as e:
                 logger.error(f"Task {self.id}: Failed to execute callback: {e}")
-                logger.exception(e)
+                logger.exception(e)
+
+        task_prompt = f"""
+You need to do the following task: {self.description}.
+Expected Output: {self.expected_output}.
+"""
+        if self.context:
+            context_results = []  # Use list to avoid duplicates
+            for context_item in self.context:
+                if isinstance(context_item, str):
+                    context_results.append(f"Input Content:\n{context_item}")
+                elif isinstance(context_item, list):
+                    context_results.append(f"Input Content: {' '.join(str(x) for x in context_item)}")
+                elif hasattr(context_item, 'result'):  # Task object
+                    if context_item.result:
+                        context_results.append(
+                            f"Result of previous task {context_item.name if context_item.name else context_item.description}:\n{context_item.result.raw}"
+                        )
+                    else:
+                        context_results.append(
+                            f"Previous task {context_item.name if context_item.name else context_item.description} has no result yet."
+                        )
+
+            # Join unique context results
+            unique_contexts = list(dict.fromkeys(context_results))  # Remove duplicates
+            task_prompt += f"""
+Context:
+
+{'  '.join(unique_contexts)}
+"""
+
+    def execute_callback_sync(self, task_output: TaskOutput) -> None:
+        """
+        Synchronous wrapper to ensure that execute_callback is awaited,
+        preventing 'Task was destroyed but pending!' warnings if called
+        from non-async code.
+        """
+        import asyncio
+        try:
+            loop = asyncio.get_running_loop()
+            if loop.is_running():
+                loop.create_task(self.execute_callback(task_output))
+            else:
+                loop.run_until_complete(self.execute_callback(task_output))
+        except RuntimeError:
+            # If no loop is running in this context
+            asyncio.run(self.execute_callback(task_output))

agents/praisonaiagents/tools/__init__.py

@@ -135,6 +135,27 @@ TOOL_MAPPINGS = {
     'group_by': ('.pandas_tools', 'PandasTools'),
     'pivot_table': ('.pandas_tools', 'PandasTools'),
     'pandas_tools': ('.pandas_tools', 'PandasTools'),
+
+    # Chain of Thought Training Tools
+    'cot_run': ('.train.data.generatecot', 'GenerateCOT'),           # Orchestrates text solution
+    'cot_run_dict': ('.train.data.generatecot', 'GenerateCOT'),      # Orchestrates dict-based solution
+    'cot_generate': ('.train.data.generatecot', 'GenerateCOT'),      # Generate text solution
+    'cot_generate_dict': ('.train.data.generatecot', 'GenerateCOT'), # Generate structured solution
+    'cot_improve': ('.train.data.generatecot', 'GenerateCOT'),       # Improve text solution
+    'cot_improve_dict': ('.train.data.generatecot', 'GenerateCOT'),  # Improve dict-based solution
+    'cot_check': ('.train.data.generatecot', 'GenerateCOT'),         # Check correctness
+    'cot_find_error': ('.train.data.generatecot', 'GenerateCOT'),    # Locate error in solution
+    'cot_load_answers': ('.train.data.generatecot', 'GenerateCOT'),  # Load QA pairs
+    
+    # COT Save/Export with QA Pairs
+    'cot_save_solutions_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),    # Save with QA pairs
+    'cot_append_solutions_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),  # Append with QA pairs
+    'cot_export_json_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),       # Export JSON with QA pairs
+    'cot_export_csv_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),        # Export CSV with QA pairs
+    'cot_append_csv_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),        # Append CSV with QA pairs
+    'cot_save': ('.train.data.generatecot', 'GenerateCOT'),                           # Save single QA to file
+    'cot_upload_to_huggingface': ('.train.data.generatecot', 'GenerateCOT'),           # Upload dataset to HuggingFace
+    'cot_tools': ('.train.data.generatecot', 'GenerateCOT'),                           # Full toolkit access
 }
 
 _instances = {}  # Cache for class instances
@@ -161,7 +182,7 @@ def __getattr__(name: str) -> Any:
         ]:
             return getattr(module, name)
         if name in ['file_tools', 'pandas_tools', 'wikipedia_tools',
-                   'newspaper_tools', 'arxiv_tools', 'spider_tools', 'duckdb_tools', 'csv_tools', 'json_tools', 'excel_tools', 'xml_tools', 'yaml_tools', 'calculator_tools', 'python_tools', 'shell_tools']:
+                   'newspaper_tools', 'arxiv_tools', 'spider_tools', 'duckdb_tools', 'csv_tools', 'json_tools', 'excel_tools', 'xml_tools', 'yaml_tools', 'calculator_tools', 'python_tools', 'shell_tools', 'cot_tools']:
             return module  # Returns the callable module
         return getattr(module, name)
     else:

agents/praisonaiagents/tools/csv_tools.py

@@ -89,7 +89,7 @@ class CSVTools:
     def write_csv(
         self,
         filepath: str,
-        data: List[Dict[str, Any]],
+        data: Union[List[Dict[str, Any]], str],
         encoding: str = 'utf-8',
         delimiter: str = ',',
         index: bool = False,
@@ -102,35 +102,66 @@ class CSVTools:
         
         Args:
             filepath: Path to CSV file
-            data: List of row dicts to write
-            encoding: File encoding
-            delimiter: Column delimiter
-            index: Whether to write row indices
-            header: Whether to write column headers
-            float_format: Format string for float values
-            date_format: Format string for date values
-            mode: Write mode ('w' for write, 'a' for append)
-            
+            data: Either a list of dictionaries or a string containing CSV data
+                  If string, each line should be comma-separated values
+            encoding: File encoding (default: 'utf-8')
+            delimiter: Column delimiter (default: ',')
+            index: Whether to write row indices (default: False)
+            header: Whether to write column headers (default: True)
+            float_format: Format string for float values (default: None)
+            date_format: Format string for date values (default: None)
+            mode: Write mode - 'w' for write, 'a' for append (default: 'w')
+        
         Returns:
-            bool: Success status
+            bool: True if successful, False otherwise
         """
         try:
             pd = self._get_pandas()
             if pd is None:
                 return False
 
-            df = pd.DataFrame(data)
-            df.to_csv(
-                filepath,
-                encoding=encoding,
-                sep=delimiter,
-                index=index,
-                header=header,
-                float_format=float_format,
-                date_format=date_format,
-                mode=mode
-            )
-            return True
+            # Handle string input
+            if isinstance(data, str):
+                # Convert string to list of dicts
+                rows = []
+                if delimiter in data:
+                    # Get existing columns if file exists and in append mode
+                    existing_cols = []
+                    if mode == 'a' and Path(filepath).exists():
+                        try:
+                            existing_df = pd.read_csv(filepath, nrows=1)
+                            existing_cols = existing_df.columns.tolist()
+                        except:
+                            pass
+
+                    values = [v.strip() for v in data.split(delimiter)]
+                    
+                    if existing_cols:
+                        # Use existing column names
+                        row_dict = dict(zip(existing_cols, values))
+                    else:
+                        # Create generic column names
+                        row_dict = {f'col{i}': val for i, val in enumerate(values)}
+                    
+                    rows.append(row_dict)
+                    data = rows
+
+                df = pd.DataFrame(data)
+                
+                # Handle append mode properly
+                write_header = header if mode == 'w' else (header and not Path(filepath).exists())
+                
+                df.to_csv(
+                    filepath,
+                    encoding=encoding,
+                    sep=delimiter,
+                    index=index,
+                    header=write_header,
+                    float_format=float_format,
+                    date_format=date_format,
+                    mode=mode
+                )
+                return True
             
         except Exception as e:
             error_msg = f"Error writing CSV file {filepath}: {str(e)}"

agents/praisonaiagents/tools/train/data/generatecot.py

@@ -0,0 +1,531 @@
+from typing import Dict, Optional, Union, Any
+import json
+from datetime import datetime
+import os
+import logging
+
+# Setup logging based on environment variable
+log_level = os.getenv('LOGLEVEL', 'INFO').upper()
+logging.basicConfig(
+    level=log_level,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Lazy loader for LLM
+def get_llm():
+    try:
+        from praisonaiagents.llm.llm import LLM
+        return LLM
+    except ImportError:
+        raise ImportError(
+            "LLM is required for this toolbut not installed. "
+            "Please install with: pip install 'praisonaiagents[llm]' datasets huggingface-hub pandas"
+        )
+
+class GenerateCOT:
+    def __init__(
+        self,
+        qa_pairs: Optional[Dict[str, str]] = None,
+        model: str = "gpt-4o-mini",
+        api_key: Optional[str] = None,
+        max_attempts: int = 3,
+        verbose: bool = True,
+        temperature: float = 0.5
+    ):
+        self.qa_pairs = qa_pairs or {}
+        self.max_attempts = max_attempts
+        self.solutions = {}
+        self.llm = get_llm()(model=model)  # Get LLM class and instantiate
+        self.model = model
+        self.temperature = temperature
+        self.verbose = verbose
+        logger.debug(f"Initialized GenerateCOT with model={model}, max_attempts={max_attempts}")
+        
+    def _ask_ai(self, prompt: str) -> str:
+        logger.debug(f"Sending prompt to LLM: {prompt[:100]}...")
+        response = self.llm.response(prompt, temperature=self.temperature)
+        logger.debug(f"Received response: {response[:100]}...")
+        return response
+        
+    def _build_solution_prompt(self, question: str, context: str) -> str:
+        return f"""
+        Solve this problem step by step: {question}
+        Context: {context}
+        Steps needed:
+        1. Break down the problem
+        2. Show your work
+        3. Explain each step
+        4. Give final answer
+        """
+
+    def cot_generate(self, question: str, context: str = "") -> str:
+        prompt = self._build_solution_prompt(question, context)
+        return self._ask_ai(prompt)
+        
+    def cot_check(self, question: str, answer: str) -> bool:
+        if question not in self.qa_pairs:
+            raise ValueError(f"No correct answer found for: {question}")
+            
+        prompt = f"""
+        Question: {question}
+        Given Answer: {answer}
+        Correct Answer: {self.qa_pairs[question]}
+        Is the given answer correct? Reply only with 'true' or 'false'.
+        """
+        return self._ask_ai(prompt).lower().strip() == "true"
+        
+    def cot_find_error(self, question: str, solution: str) -> int:
+        if self.cot_check(question, solution):
+            return -1
+            
+        sentences = [s.strip() for s in solution.replace('。', '.').split('.') if s.strip()]
+        left, right = 0, len(sentences)
+        
+        while left < right:
+            mid = (left + right) // 2
+            partial = '. '.join(sentences[:mid]) + '.'
+            if self.cot_check(question, partial):
+                left = mid + 1
+            else:
+                right = mid
+                
+        return left
+        
+    def cot_improve(self, question: str, current: str) -> str:
+        best_solution = current
+        best_score = self._rate_solution(question, current)
+        attempts = 0
+        
+        while attempts < self.max_attempts:
+            attempts += 1
+            new_solution = self.cot_generate(question, current)
+            new_score = self._rate_solution(question, new_solution)
+            
+            if new_score > best_score:
+                best_solution = new_solution
+                best_score = new_score
+                
+            if best_score > 0.8:
+                break
+                
+        return best_solution
+        
+    def _rate_solution(self, question: str, solution: str) -> float:
+        prompt = f"""
+        Rate this solution from 0 to 1:
+        Question: {question}
+        Solution: {solution}
+        Correct Answer: {self.qa_pairs.get(question, '')}
+        Return only a number between 0 and 1.
+        """
+        try:
+            score = float(self._ask_ai(prompt))
+            return min(max(score, 0), 1)
+        except ValueError:
+            return 0.0
+            
+    def cot_run(self, question: str) -> str:
+        """Run COT generation for a single question."""
+        solution = self.cot_generate(question)
+        if self.cot_check(question, solution):
+            return solution
+
+        solution = self.cot_improve(question, solution)
+        
+        error_pos = self.cot_find_error(question, solution)
+        if error_pos != -1:
+            correct_part = '. '.join(solution.split('. ')[:error_pos]) + '.'
+            solution = self.cot_generate(question, correct_part)
+
+        self.solutions[question] = {
+            "solution": solution,
+            "error_position": error_pos,
+        }
+        return solution
+        
+    def cot_load_answers(self, filepath: str) -> bool:
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            self.qa_pairs.update(data)
+            return True
+        except Exception as e:
+            print(f"Error loading answers: {e}")
+            return False
+            
+    def _is_qa_pairs(self, qa_pairs: Any) -> bool:
+        """Validate if input is a proper QA pairs dictionary."""
+        if not qa_pairs:
+            return True  # None or empty is valid
+        if not isinstance(qa_pairs, dict):
+            raise ValueError("qa_pairs must be a dictionary with questions as keys and answers as values")
+        return True
+
+    def cot_append_solutions_with_qa_pairs(
+        self,
+        filepath: str = 'solutions.json',
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> None:
+        """Appends current solutions to existing file or creates a new one."""
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+
+            data = {
+                "solutions": self.solutions,
+                "qa_pairs": self.qa_pairs,
+                "saved_at": datetime.now().isoformat()
+            }
+
+            existing_data = {}
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    existing_data = json.load(f)
+            except (FileNotFoundError, json.JSONDecodeError):
+                pass
+
+            if existing_data:
+                existing_data["solutions"].update(data["solutions"])
+                existing_data["qa_pairs"].update(data["qa_pairs"])
+                existing_data["saved_at"] = data["saved_at"]
+                data = existing_data
+
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"Error appending solutions: {e}")
+
+    def cot_save_solutions_with_qa_pairs(
+        self,
+        filepath: str = 'solutions.json',
+        append: bool = False,
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> None:
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+
+            if append:
+                self.cot_append_solutions_with_qa_pairs(filepath)
+                return
+
+            data = {
+                "solutions": self.solutions,
+                "qa_pairs": self.qa_pairs,
+                "saved_at": datetime.now().isoformat()
+            }
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"Error saving solutions: {e}")
+
+    def cot_generate_dict(self, question: str, context: str = "") -> dict:
+        prompt = self._build_solution_prompt(question, context)
+        thought_process = self._ask_ai(prompt)
+        
+        final_answer_prompt = f"""
+        Based on this solution, what is the final answer only:
+        {thought_process}
+        Give only the final answer, no explanation.
+        """
+        final_answer = self._ask_ai(final_answer_prompt)
+        return {
+            "thought_process": thought_process,
+            "final_answer": final_answer
+        }
+
+    def cot_improve_dict(self, question: str, current_solution: str) -> dict:
+        """
+        Improves the existing solution (text form), returning the best dictionary-based version.
+        """
+        best_solution = {
+            "thought_process": current_solution,
+            "final_answer": current_solution
+        }
+        best_score = self._rate_solution(question, current_solution)
+        attempts = 0
+
+        while attempts < self.max_attempts:
+            attempts += 1
+            new_solution = self.cot_generate_dict(question, current_solution)
+            new_score = self._rate_solution(question, new_solution["thought_process"])
+            if new_score > best_score:
+                best_solution = new_solution
+                best_score = new_score
+            if best_score > 0.8:
+                break
+        return best_solution
+
+    def cot_run_dict(self, question: str) -> dict:
+        """Uses the dictionary-based solution approach, storing the final solution in self.solutions."""
+        logger.debug(f"Starting cot_run_dict for question: {question}")
+        
+        solution = self.cot_generate_dict(question)
+        logger.debug(f"Initial solution generated: {str(solution)[:100]}...")
+        
+        if self.cot_check(question, solution["final_answer"]):
+            logger.debug("Initial solution passed verification")
+            self.solutions[question] = solution
+            return solution
+
+        logger.debug("Initial solution failed verification, attempting improvement")
+        improved = self.cot_improve_dict(question, solution["thought_process"])
+        if self.cot_check(question, improved["final_answer"]):
+            logger.debug("Improved solution passed verification")
+            self.solutions[question] = improved
+            return improved
+
+        logger.debug("Checking for errors in improved solution")
+        error_pos = self.cot_find_error(question, improved["thought_process"])
+        if error_pos != -1:
+            logger.debug(f"Found error at position {error_pos}, generating final solution")
+            partial_solution = '. '.join(improved["thought_process"].split('. ')[:error_pos]) + '.'
+            final = self.cot_generate_dict(question, partial_solution)
+            self.solutions[question] = final
+            return final
+
+        logger.debug("Using improved solution as final result")
+        self.solutions[question] = improved
+        return improved
+
+    def cot_export_json_with_qa_pairs(
+        self,
+        filepath: str = 'dataset.json',
+        save_to_file: bool = True,
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> Union[str, list]:
+        """
+        Export solutions in Alpaca training format with their full thought process.
+        """
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+                # Generate solutions if empty
+                if not self.solutions:
+                    for question in qa_pairs:
+                        self.cot_run_dict(question)
+
+            alpaca_data = []
+            for question, sol in self.solutions.items():
+                alpaca_data.append({
+                    "instruction": question,
+                    "input": "",
+                    "output": sol.get("thought_process", "")
+                })
+
+            if not save_to_file:
+                return alpaca_data
+
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(alpaca_data, f, ensure_ascii=False, indent=2)
+            return filepath
+        except Exception as e:
+            print(f"Error exporting to Alpaca format: {e}")
+            return None
+
+    def cot_export_csv_with_qa_pairs(
+        self,
+        filepath: str = 'dataset.csv',
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> Optional[str]:
+        """Export solutions in CSV format."""
+        try:
+            import csv
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+                # Generate solutions if empty
+                if not self.solutions:
+                    for question in qa_pairs:
+                        self.cot_run_dict(question)
+
+            with open(filepath, 'w', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                writer.writerow(['instruction', 'input', 'output'])
+                for question, sol in self.solutions.items():
+                    writer.writerow([question, '', sol.get("thought_process", "")])
+            return filepath
+        except Exception as e:
+            print(f"Error exporting to CSV format: {e}")
+            return None
+
+    def cot_save(
+        self,
+        question: str,
+        answer: str,
+        filepath: str = 'dataset.csv'
+    ) -> Optional[str]:
+        """Save a single question-answer pair with chain of thought to CSV file."""
+        logger.debug(f"Saving QA pair to {filepath}")
+        try:
+            self.qa_pairs[question] = answer
+            logger.debug("Added QA pair to internal dictionary")
+            
+            solution = self.cot_run_dict(question)
+            logger.debug("Generated solution for question")
+            
+            import csv
+            import os
+            file_exists = os.path.exists(filepath)
+            logger.debug(f"File exists: {file_exists}")
+
+            with open(filepath, 'a', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                if not file_exists:
+                    logger.debug("Creating new file with headers")
+                    writer.writerow(['instruction', 'input', 'output'])
+                writer.writerow([question, '', solution.get("thought_process", "")])
+                logger.debug("Wrote solution to file")
+            return filepath
+        except Exception as e:
+            logger.error(f"Error saving to CSV: {str(e)}")
+            return None
+
+    # Rename existing function to indicate it handles qa_pairs dictionary
+    def cot_append_csv_with_qa_pairs(
+        self,
+        filepath: str = 'dataset.csv',
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> Optional[str]:
+        """Append solutions to CSV file using qa_pairs dictionary."""
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+            
+            import csv
+            import os
+            file_exists = os.path.exists(filepath)
+
+            with open(filepath, 'a', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                if not file_exists:
+                    writer.writerow(['instruction', 'input', 'output'])
+
+                for question, sol in self.solutions.items():
+                    writer.writerow([question, '', sol.get("thought_process", "")])
+            return filepath
+        except Exception as e:
+            print(f"Error appending to CSV: {e}")
+            return None
+
+    def cot_upload_to_huggingface(
+        self,
+        huggingface_username: str,
+        dataset_name: str,
+        filepath: str,
+        private: bool = False
+    ) -> str:
+        """Upload generated solutions to HuggingFace datasets."""
+        logger.debug(f"Attempting to upload {filepath} to HuggingFace as {dataset_name}")
+        try:
+            from datasets import Dataset
+            import pandas as pd
+            
+            logger.debug(f"Loading data from {filepath}")
+            if filepath.endswith('.csv'):
+                data = pd.read_csv(filepath)
+                logger.debug(f"Loaded CSV with {len(data)} rows")
+            elif filepath.endswith('.json'):
+                data = pd.read_json(filepath)
+                logger.debug(f"Loaded JSON with {len(data)} records")
+            else:
+                raise ValueError("Only CSV and JSON files are supported")
+                
+            logger.debug("Converting to HuggingFace dataset")
+            dataset = Dataset.from_pandas(data)
+            
+            repo_id = f"{huggingface_username}/{dataset_name}"
+            logger.debug(f"Pushing to hub: {repo_id}")
+            dataset.push_to_hub(
+                repo_id,
+                private=private
+            )
+            
+            logger.debug("Upload completed successfully")
+            return f"Dataset uploaded successfully to {repo_id}"
+            
+        except Exception as e:
+            logger.error(f"Error uploading to HuggingFace: {str(e)}")
+            return None
+
+# Usage example:
+if __name__ == "__main__":
+    # Direct QA Pairs Export Example
+    print("\n=== Direct QA Pairs Export Example ===")
+    direct_qa_data = {
+        "Number of r's in the word strawberry": "3"
+    }
+    
+    direct_generator = GenerateCOT()
+
+    # Export with qa_pairs passed directly to functions
+    direct_generator.cot_export_csv_with_qa_pairs(
+        filepath='direct_solutions.csv',
+        qa_pairs=direct_qa_data
+    )
+    
+    # Example of using cot_save for a single QA pair
+    direct_generator.cot_save(
+        question="What is the capital of France?",
+        answer="Paris",
+        filepath="single_qa.csv"
+    )
+    
+
+    
+    # Upload to HuggingFace
+    direct_generator.cot_upload_to_huggingface(
+        huggingface_username="mervinpraison",
+        dataset_name="cot-test",
+        filepath="single_qa.csv"
+    )
+    
+    # direct_generator.cot_export_json_with_qa_pairs(
+    #     filepath='direct_solutions.json',
+    #     qa_pairs=direct_qa_data
+    # )
+
+    # # Rest of the original examples...
+    # qa_data = {
+    #     "What is 2+2?": "4",
+    #     "How many letters in 'hello'?": "5"
+    # }
+    
+    # generator = GenerateCOT(qa_pairs=qa_data)
+    # for question in qa_data:
+    #     solution = generator.cot_run(question)
+    #     print(f"Question: {question}")
+    #     print(f"Solution: {solution}\n")
+    # answer = generator.cot_run("What is 2+2?")
+    # print(answer)
+
+    # # Additional QA data processing example
+    # print("\n=== Processing Additional QA Data ===")
+    # extra_qa_data = {
+
+    #     "What is 5 * 3?": "15"
+    # }
+    
+    # # Create separate generator for additional data
+    # extra_generator = GenerateCOT(qa_pairs=extra_qa_data)
+    
+    # # Process and save solutions
+    # for question in extra_qa_data:
+    #     solution = extra_generator.cot_run_dict(question)
+    #     print(f"Processing extra question: {question}")
+    
+    # # Save solutions separately
+    # extra_generator.cot_save_solutions_with_qa_pairs('extra_qa_solutions.json')
+    
+    # # Export in Alpaca format
+    # extra_generator.cot_export_json_with_qa_pairs(filepath='extra_qa_alpaca.json', save_to_file=True)
+    
+    # # Demonstrate loading saved data
+    # loaded_generator = GenerateCOT(qa_pairs={})
+    # loaded_generator.cot_load_answers('extra_qa_solutions.json')
+    # print("\nLoaded extra QA pairs:", loaded_generator.qa_pairs)

agents/pyproject.toml

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

agents/repetitive-agents.py

@@ -0,0 +1,23 @@
+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="complete the task",
+    expected_output="task completed",
+    agent=agent,
+    task_type="loop",
+    input_file="tasks.csv"
+)
+
+agents = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task],
+    process="workflow",
+    max_iter=30
+)
+
+agents.start()

agents/repetitive-manual-agents.py

@@ -0,0 +1,139 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import read_csv, write_csv
+import pandas as pd
+
+def read_csv_smart(csv_path: str) -> pd.DataFrame:
+    """Read CSV and use first column as task, handling both header/no-header cases"""
+    # Try reading with headers first
+    df = pd.read_csv(csv_path)
+    
+    # Check if first row looks like data
+    if not any(col.lower() in ['task', 'description', 'status', 'state'] for col in df.columns):
+        # If no header-like names found, read without headers
+        df = pd.read_csv(csv_path, header=None)
+        
+    # Rename columns consistently
+    df.columns = [*['task'], *[f'col_{i}' for i in range(1, len(df.columns))]]
+    if 'status' not in df.columns:
+        df['status'] = 'pending'
+    if 'loop_id' not in df.columns:
+        # Start loop_id from 1 instead of 0
+        df['loop_id'] = (df.index + 1).astype(str)
+    return df[['task', 'status', 'loop_id']]
+
+def has_pending_tasks(df: pd.DataFrame) -> bool:
+    """Check if there are any pending tasks in the DataFrame"""
+    return not df[df['status'] == 'pending'].empty
+
+def check_task_status(csv_path: str) -> dict:
+    """Read task status from CSV file"""
+    try:
+        # Always read directly from CSV file
+        df = pd.read_csv(csv_path, keep_default_na=False)
+        
+        # Get only pending tasks from original status
+        pending_tasks = df[df['status'].str.lower() == 'pending']
+        
+        if not pending_tasks.empty:
+            task_data = pending_tasks.iloc[0].to_dict()
+            return {
+                'has_pending': True,
+                'next_task': task_data
+            }
+        return {'has_pending': False, 'next_task': None}
+    except Exception as e:
+        print(f"Error reading CSV: {e}")
+        return {'has_pending': False, 'next_task': None, 'error': str(e)}
+
+def get_next_task() -> dict:
+    """Get the next pending task from CSV"""
+    status = check_task_status("tasks.csv")
+    if status['has_pending'] and status['next_task']:
+        task = status['next_task']
+        if task['status'].lower() == 'pending':
+            return {
+                'loop_data': {
+                    'task': task['task'],
+                    'loop_id': task['loop_id'],
+                    'status': task['status']
+                }
+            }
+    return None
+
+def update_task_status(loop_id: str, new_status: str) -> bool:
+    """Update task status in CSV file using loop_id as identifier"""
+    try:
+        # Read directly from CSV file
+        df = pd.read_csv("tasks.csv", keep_default_na=False)
+        df['loop_id'] = df['loop_id'].astype(str)
+        mask = df['loop_id'] == str(loop_id)
+        if mask.any():
+            df.loc[mask, 'status'] = new_status
+            df.to_csv("tasks.csv", index=False)
+            return True
+        print(f"No task found with loop_id: {loop_id}")
+        return False
+    except Exception as e:
+        print(f"Error updating status: {e}")
+        return False
+
+identify_agent = Agent(
+    name="Identify Agent",
+    role="Pending Task Identifier",
+    goal="Identify the next pending task",
+    tools=[get_next_task],
+    llm="gpt-4o-mini"
+)
+
+# Create the repetitive agent
+repetitive_agent = Agent(
+    name="TaskProcessor",
+    role="Task Processing Specialist",
+    goal="Complete the task response",
+    llm="gpt-4o-mini"
+)
+
+update_status_agent = Agent(
+    name="UpdateStatusAgent",
+    role="Status Updater",
+    goal="Update the status of the task in CSV",
+    tools=[update_task_status],
+    llm="gpt-4o-mini"
+)
+
+# Define the repetitive task
+identify_task = Task(
+    name="identify_task",
+    description="Identify the next pending task. If there are no pending tasks decision is completed.",
+    agent=identify_agent,
+    task_type="loop",
+    condition={
+        "pending": ["process_task"],
+        "completed": "exit"
+    }
+)
+
+process_task = Task(
+    name="process_task",
+    description="Complete the task mentioned in the response",
+    agent=repetitive_agent,
+    context=[identify_task],
+    task_type="loop",
+    next_tasks=["update_task"]
+)
+
+update_task = Task(
+    name="update_task",
+    description="Update the task status",
+    agent=update_status_agent,
+    next_tasks= ["identify_task"]
+)
+
+# Create and run agents manager
+agents = PraisonAIAgents(
+    agents=[identify_agent, repetitive_agent],
+    tasks=[identify_task, process_task, update_task],
+    process="workflow"
+)
+
+agents.start()

agents/requirements.txt

@@ -0,0 +1,15 @@
+# Core dependencies
+pydantic
+rich
+openai>=1.30.0
+
+# Memory dependencies
+chromadb>=0.5.23
+
+# Knowledge dependencies
+mem0ai>=0.1.0
+markitdown
+chonkie
+
+# Development dependencies
+python-dotenv>=0.19.0

agents/sample.md

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

agents/sample.txt

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

agents/streamlit-agents.py

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

agents/tasks.csv

@@ -0,0 +1,100 @@
+Write a product description for a smartwatch in 2 lines.
+Create a user manual for a blender in 2 lines.
+Draft an apology email for delayed delivery in 2 lines.
+Write a blog post on "Benefits of Meditation" in 2 lines.
+Create a privacy policy for a website in 2 lines.
+Write instructions for setting up a Wi-Fi router in 2 lines.
+Draft an email to follow up after a job interview in 2 lines.
+Create a FAQ page for an e-commerce store in 2 lines.
+Write an invitation email for a webinar in 2 lines.
+Create a terms and conditions page for an app in 2 lines.
+Write a press release for a product launch in 2 lines.
+Create a checklist for house cleaning tasks in 2 lines.
+Draft a resignation letter template in 2 lines.
+Write a cover letter for a software developer role in 2 lines.
+Create onboarding instructions for new employees in 2 lines.
+Write a memo announcing a new policy in a company in 2 lines.
+Create a safety guidelines document for a workplace in 2 lines.
+Write a pitch email to potential investors in 2 lines.
+Draft a thank-you email for attending a conference in 2 lines.
+Create a refund policy template for an online store in 2 lines.
+Write a blog on "How to Improve Time Management" in 2 lines.
+Create step-by-step instructions for changing a car tyre in 2 lines.
+Write a welcome email for new subscribers in 2 lines.
+Draft an event agenda template in 2 lines.
+Create a code of conduct for an online forum in 2 lines.
+Write a guide for beginners to start a blog in 2 lines.
+Create a checklist for organising a party in 2 lines.
+Draft an email to request a product review in 2 lines.
+Write a policy for remote work in a company in 2 lines.
+Create a simple tutorial for using Excel formulas in 2 lines.
+Write a thank-you letter for a donation in 2 lines.
+Draft a meeting minutes template in 2 lines.
+Create an FAQ for a gym membership in 2 lines.
+Write a blog post about "Healthy Snacks for Kids" in 2 lines.
+Create a guide for securing your social media accounts in 2 lines.
+Draft an email to request a testimonial from a client in 2 lines.
+Write a safety checklist for camping trips in 2 lines.
+Create a script for a customer service call in 2 lines.
+Write a tutorial for creating a simple PowerPoint presentation in 2 lines.
+Create a packing list for a beach vacation in 2 lines.
+Draft an email to cancel a service subscription in 2 lines.
+Write a personal statement for university admission in 2 lines.
+Create a template for tracking monthly expenses in 2 lines.
+Write a guide for planting and caring for succulents in 2 lines.
+Create a simple user guide for a mobile app in 2 lines.
+Draft an email to announce a team-building activity in 2 lines.
+Write a step-by-step guide for baking a cake in 2 lines.
+Create a list of house maintenance tasks in 2 lines.
+Draft a partnership proposal email in 2 lines.
+Write a guide for basic photography tips in 2 lines.
+Create a feedback form template for an online course in 2 lines.
+Write a blog on "Top 5 Budget Travel Destinations" in 2 lines.
+Draft a letter of recommendation for a colleague in 2 lines.
+Create a workout plan for beginners in 2 lines.
+Write a guide for troubleshooting common tech issues in 2 lines.
+Draft a reminder email for an upcoming appointment in 2 lines.
+Create a guide for setting personal goals in 2 lines.
+Write a blog post about "How to Start Freelancing" in 2 lines.
+Create a template for event planning in 2 lines.
+Draft an email to notify users about system maintenance in 2 lines.
+Write a guide for choosing the right laptop in 2 lines.
+Create a checklist for moving to a new house in 2 lines.
+Draft an email to update a client on project status in 2 lines.
+Write a guide for reducing screen time in 2 lines.
+Create a shopping list template for weekly groceries in 2 lines.
+Draft a thank-you email for completing a survey in 2 lines.
+Write a blog on "Simple DIY Crafts for Beginners" in 2 lines.
+Create a checklist for starting a small business in 2 lines.
+Draft an email to apologise for a customer complaint in 2 lines.
+Write a guide for setting up a personal budget in 2 lines.
+Create a policy for using company-provided equipment in 2 lines.
+Draft an email to notify about a price increase in 2 lines.
+Write a tutorial for creating a resume using Word in 2 lines.
+Create a simple guide for organising a charity event in 2 lines.
+Draft a formal invitation letter for a conference in 2 lines.
+Write a blog post about "Top Productivity Apps" in 2 lines.
+Create a checklist for first-time pet owners in 2 lines.
+Draft an email to confirm a service appointment in 2 lines.
+Write a beginner’s guide for learning to code in 2 lines.
+Create a guide for assembling a basic toolkit in 2 lines.
+Draft a welcome email for a new team member in 2 lines.
+Write a guide for preparing a home for winter in 2 lines.
+Create a schedule template for meal planning in 2 lines.
+Draft an email to request feedback from a customer in 2 lines.
+Write a guide on "How to Build a Morning Routine" in 2 lines.
+Create a checklist for hosting a virtual meeting in 2 lines.
+Draft a newsletter for a non-profit organisation in 2 lines.
+Write a guide for beginners to use Canva in 2 lines.
+Create a guide for organising your workspace in 2 lines.
+Draft an email to invite users to a beta program in 2 lines.
+Write a step-by-step guide for creating a podcast in 2 lines.
+Create a simple guide for buying your first car in 2 lines.
+Draft an email to announce a new team member in 2 lines.
+Write a tutorial on creating basic charts in Excel in 2 lines.
+Create a guide for teaching basic first aid in 2 lines.
+Draft an email to follow up after a sales call in 2 lines.
+Write a blog post on "How to Save Money on Utilities" in 2 lines.
+Create a guide for designing a basic website in 2 lines.
+Draft a thank-you email for a business referral in 2 lines.
+Write a guide for setting up a new smartphone in 2 lines.

agents/vector-db-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()

agents/wikipedia-agent.py

@@ -7,6 +7,7 @@ agent = Agent(
     self_reflect=True,
     min_reflect=3,
     max_reflect=5,
+    llm="gpt-4o-mini"
 )
 agent.start(
     "What is the history of AI?"

agents/workflow-test-agents.py

@@ -0,0 +1,124 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import cot_save, cot_upload_to_huggingface
+from pydantic import BaseModel
+import os
+
+def print_data(data):
+    print(data)
+    return "done"
+
+def upload_to_huggingface(data):
+    print(data)
+    return "done"
+
+# Define Pydantic model for structured output
+class DecisionModel(BaseModel):
+    response: str
+    decision: str
+
+def write_csv(file_path, data):
+    """Write data to CSV file."""
+    # delete file if exists
+    if os.path.exists(file_path):
+        os.remove(file_path)
+    with open(file_path, 'w') 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]
+)
+
+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=[print_data],
+    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=[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 1 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": "generate_cot"
+    }
+)
+
+generate_cot_task = Task(
+    name="generate_cot",
+    description="""Generate chain of thought solutions for each question in the input file. 
+After processing all questions, 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
+)
+
+# Initialize workflow
+agents = PraisonAIAgents(
+    agents=[qa_generator, cot_generator, upload_to_huggingface],
+    tasks=[generate_task, generate_cot_task, upload_to_huggingface_task],
+    process="workflow",
+    max_iter=10,
+    verbose=False
+)
+
+agents.start()

docker/Dockerfile

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

docs/agents/agents.mdx

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

docs/agents/image-to-text.mdx

@@ -2,7 +2,7 @@
 title: "Image to Text Agent"
 sidebarTitle: "Image to Text"
 description: "Learn how to create AI agents for converting images to textual descriptions and extracting text from images."
-icon: "image-to-text"
+icon: "text"
 ---
 
 ```mermaid

docs/agents/shopping.mdx

@@ -2,7 +2,7 @@
 title: "Shopping Agent"
 sidebarTitle: "Shopping"
 description: "Learn how to create AI agents for price comparison and shopping assistance."
-icon: "shopping-cart"
+icon: "shop"
 ---
 
 ```mermaid

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.46 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.0.60 gunicorn markdown\n&#34;)
             file.write(&#34;EXPOSE 8080\n&#34;)
             file.write(&#39;CMD [&#34;gunicorn&#34;, &#34;-b&#34;, &#34;0.0.0.0:8080&#34;, &#34;api:app&#34;]\n&#39;)
             

docs/concepts/agents.mdx

@@ -4,11 +4,8 @@ description: "Understanding Agents in PraisonAI"
 icon: "user"
 ---
 
-<Note>
-  Agents are the core building blocks of PraisonAI. Each agent is an autonomous AI entity with specific roles, goals, and capabilities.
-</Note>
-
 # Understanding Agents
+Agents are the core building blocks of PraisonAI. Each agent is an autonomous AI entity with specific roles, goals, and capabilities.
 
 ```mermaid
 graph LR
@@ -19,45 +16,34 @@ graph LR
     Agent2 --> Output([✓ Output])
     Process -.-> Agent1
     
-    %% Styling for main elements
-    style Start fill:#2D3047,stroke:#7C90A0,color:#fff
-    style Output fill:#2D3047,stroke:#7C90A0,color:#fff
-    style Process fill:#5C80BC,stroke:#7C90A0,color:#fff
-    
     %% Define subgraphs for agents and their tasks
-    subgraph Agent1[" "]
+    subgraph Agent1[ ]
         Task1[📋 Task]
         AgentIcon1[🤖 AI Agent]
         Tools1[🔧 Tools]
         
         Task1 --- AgentIcon1
         AgentIcon1 --- Tools1
-        
-        style Task1 fill:#2D3047,stroke:#7C90A0,color:#fff
-        style AgentIcon1 fill:#5C80BC,stroke:#7C90A0,color:#fff
-        style Tools1 fill:#2D3047,stroke:#7C90A0,color:#fff
     end
     
-    subgraph Agent2[" "]
+    subgraph Agent2[ ]
         Task2[📋 Task]
         AgentIcon2[🤖 AI Agent]
         Tools2[🔧 Tools]
         
         Task2 --- AgentIcon2
         AgentIcon2 --- Tools2
-        
-        style Task2 fill:#2D3047,stroke:#7C90A0,color:#fff
-        style AgentIcon2 fill:#5C80BC,stroke:#7C90A0,color:#fff
-        style Tools2 fill:#2D3047,stroke:#7C90A0,color:#fff
     end
-    
-    %% Style for agent containers
-    style Agent1 fill:#1B1F3B,stroke:#7C90A0,color:#fff
-    style Agent2 fill:#1B1F3B,stroke:#7C90A0,color:#fff
-    
-    %% Global styles
-    classDef default fill:#2D3047,stroke:#7C90A0,color:#fff
-    linkStyle default stroke:#7C90A0,stroke-width:2px
+
+    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff
+    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
+    classDef tools fill:#2E8B57,stroke:#7C90A0,color:#fff
+    classDef transparent fill:none,stroke:none
+
+    class Start,Output,Task1,Task2 input
+    class Process,AgentIcon1,AgentIcon2 process
+    class Tools1,Tools2 tools
+    class Agent1,Agent2 transparent
 ```
 
 ## Key Components
@@ -126,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/concepts/knowledge.mdx

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

docs/concepts/memory.mdx

@@ -5,6 +5,48 @@ description: "Learn how to create AI agents with memory capabilities for maintai
 icon: "brain"
 ---
 
+```mermaid
+flowchart TB
+    subgraph Memory
+        direction TB
+        STM[Short Term]
+        LTM[Long Term]
+    end
+
+    subgraph Store
+        direction TB
+        DB[(Vector DB)]
+    end
+
+    Input[Input] ---> Agents
+    subgraph Agents
+        direction LR
+        A1[Agent 1]
+        A2[Agent 2]
+        A3[Agent 3]
+    end
+    Agents ---> Output[Output]
+
+    Memory <--> Store
+    Store <--> A1
+    Store <--> A2
+    Store <--> A3
+
+    style Memory fill:#189AB4,color:#fff
+    style Store fill:#2E8B57,color:#fff
+    style Agents fill:#8B0000,color:#fff
+    style Input fill:#8B0000,color:#fff
+    style Output fill:#8B0000,color:#fff
+```
+
+| Feature | [Knowledge](/concepts/knowledge) | [Memory](/concepts/memory) |
+|---------|--------------------------------|---------------------------|
+| When Used | Pre-loaded before agent execution | Created and updated during runtime |
+| Purpose | Provide static reference information | Store dynamic context and interactions |
+| Storage | Read-only knowledge base | Read-write memory store |
+| Persistence | Permanent until explicitly changed | Can be temporary (STM) or persistent (LTM) |
+| Updates | Manual updates through knowledge files | Automatic updates during agent execution |
+
 ## Quick Start
 
 <Tabs>
@@ -396,16 +438,6 @@ PraisonAI's memory system includes several types of memory:
     - Semantic search capabilities with RAG
     - Quality-based storage decisions
   </Card>
-  <Card title="Entity Memory" icon="diagram-project">
-    - Store information about specific entities
-    - Track relationships and attributes
-    - Specialized search for entity information
-  </Card>
-  <Card title="User Memory" icon="user">
-    - Store user-specific information
-    - Personalized context for each user
-    - Persistent across sessions
-  </Card>
 </CardGroup>
 
 ### Memory Quality Control
@@ -437,5 +469,4 @@ results = agents.memory.search_long_term(
     query="search query",
     min_quality=0.8,     # Only return high-quality matches
     limit=5              # Maximum number of results
-)
-```
+)

docs/concepts/process.mdx

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