https://github.com/MervinPraison/PraisonAI

PraisonAI is a production-ready Multi AI Agents framework, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. It provides a low-code solution to streamline the building and management of multi-agent LLM systems, emphasising simplicity, customisation, and effective human-agent collaboration.
https://github.com/MervinPraison/PraisonAI

agents ai ai-agent-framework ai-agent-sdk ai-agents ai-agents-framework ai-agents-sdk ai-framwork aiagent aiagentframework aiagents aiagentsframework framework multi-agent multi-agent-collaboration multi-agent-system multi-agent-systems multi-agents multi-ai-agent multi-ai-agents

Last synced: 6 months ago
JSON representation

Host: GitHub
URL: https://github.com/MervinPraison/PraisonAI
Owner: MervinPraison
License: mit
Created: 2024-03-19T16:45:25.000Z (over 1 year ago)
Default Branch: main
Last Pushed: 2025-04-08T11:05:05.000Z (7 months ago)
Last Synced: 2025-04-09T03:00:45.411Z (7 months ago)
Topics: agents, ai, ai-agent-framework, ai-agent-sdk, ai-agents, ai-agents-framework, ai-agents-sdk, ai-framwork, aiagent, aiagentframework, aiagents, aiagentsframework, framework, multi-agent, multi-agent-collaboration, multi-agent-system, multi-agent-systems, multi-agents, multi-ai-agent, multi-ai-agents
Language: Jupyter Notebook
Homepage: https://docs.praison.ai
Size: 20.9 MB
Stars: 4,005
Watchers: 62
Forks: 573
Open Issues: 83
Metadata Files:
- Readme: README.md
- Contributing: docs/contributing.mdx
- Funding: .github/FUNDING.yml
- License: LICENSE

Awesome Lists containing this project

awesome-generative-ai - MervinPraison/PraisonAI - code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration. (Large Language Models (LLMs) / Autonomous LLM Agents)
StarryDivineSky - MervinPraison/PraisonAI
awesome-rainmana - MervinPraison/PraisonAI - PraisonAI is a production-ready Multi AI Agents framework, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. It provides a low-code solution (Python)
awesome-AI-driven-development - PraisonAI - Combines AutoGen and CrewAI or similar frameworks into a low-code solution for building and managing multi-agent LLM systems (Multi-Agent & Orchestration / Other IDEs)
awesome - MervinPraison/PraisonAI - PraisonAI is a production-ready Multi AI Agents framework, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. It provides a low-code solution to streamline the building and management of multi-agent LLM systems, emphasising simplicity, customisation, and effective human-agent collaboration. (Python)
awesome-hacking-lists - MervinPraison/PraisonAI - PraisonAI is a production-ready Multi AI Agents framework, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. It provides a low-code solution (Jupyter Notebook)
AiTreasureBox - MervinPraison/PraisonAI - 10-21_5434_0](https://img.shields.io/github/stars/MervinPraison/PraisonAI.svg)|PraisonAI application combines AutoGen and CrewAI or similar frameworks into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.| (Repos)

README

          


  

    

    

    

  















# Praison AI





PraisonAI is a production-ready Multi-AI Agents framework with self-reflection, designed to create AI Agents to automate and solve problems ranging from simple tasks to complex challenges. By integrating PraisonAI Agents, AG2 (Formerly AutoGen), and CrewAI into a low-code solution, it streamlines the building and management of multi-agent LLM systems, emphasising simplicity, customisation, and effective human-agent collaboration.



  

    

      

    

  



## Key Features

- 🤖 Automated AI Agents Creation

- 🔄 Self Reflection AI Agents

- 🧠 Reasoning AI Agents

- 👁️ Multi Modal AI Agents

- 🤝 Multi Agent Collaboration

- 🎭 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

## Using Python Code

Light weight package dedicated for coding:

```bash

pip install praisonaiagents

```

```bash

export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx

```

### 1. Single Agent

Create app.py file and add the code below:

```python

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:

```bash

python app.py

```

### 2. Multi Agents

Create app.py file and add the code below:

```python

from praisonaiagents import Agent, PraisonAIAgents

research_agent = Agent(instructions="Research about AI")

summarise_agent = Agent(instructions="Summarise research agent's findings")

agents = PraisonAIAgents(agents=[research_agent, summarise_agent])

agents.start()

```

Run:

```bash

python app.py

```

## Using No Code

### Auto Mode:

```bash

pip install praisonai

export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx

praisonai --auto create a movie script about Robots in Mars

```

## Using JavaScript Code

```bash

npm install praisonai

export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx

```

```javascript

const { Agent } = require('praisonai');

const agent = new Agent({ instructions: 'You are a helpful AI assistant' });

agent.start('Write a movie script about a robot in Mars');

```

![PraisonAI CLI Demo](docs/demo/praisonai-cli-demo.gif)

## AI Agents Flow

```mermaid

graph LR

    %% Define the main flow

    Start([▶ Start]) --> Agent1

    Agent1 --> Process[⚙ Process]

    Process --> Agent2

    Agent2 --> Output([✓ Output])

    Process -.-> Agent1

    

    %% Define subgraphs for agents and their tasks

    subgraph Agent1[ ]

        Task1[📋 Task]

        AgentIcon1[🤖 AI Agent]

        Tools1[🔧 Tools]

        

        Task1 --- AgentIcon1

        AgentIcon1 --- Tools1

    end

    

    subgraph Agent2[ ]

        Task2[📋 Task]

        AgentIcon2[🤖 AI Agent]

        Tools2[🔧 Tools]

        

        Task2 --- AgentIcon2

        AgentIcon2 --- Tools2

    end

    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff

    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff

    classDef tools fill:#2E8B57,stroke:#7C90A0,color:#fff

    classDef transparent fill:none,stroke:none

    class Start,Output,Task1,Task2 input

    class Process,AgentIcon1,AgentIcon2 process

    class Tools1,Tools2 tools

    class Agent1,Agent2 transparent

```

## AI Agents with Tools

Create AI agents that can use tools to interact with external systems and perform actions.

```mermaid

flowchart TB

    subgraph Tools

        direction TB

        T3[Internet Search]

        T1[Code Execution]

        T2[Formatting]

    end

    Input[Input] ---> Agents

    subgraph Agents

        direction LR

        A1[Agent 1]

        A2[Agent 2]

        A3[Agent 3]

    end

    Agents ---> Output[Output]

    T3 --> A1

    T1 --> A2

    T2 --> A3

    style Tools fill:#189AB4,color:#fff

    style Agents fill:#8B0000,color:#fff

    style Input fill:#8B0000,color:#fff

    style Output fill:#8B0000,color:#fff

```

## AI Agents with Memory

Create AI agents with memory capabilities for maintaining context and information across tasks.

```mermaid

flowchart TB

    subgraph Memory

        direction TB

        STM[Short Term]

        LTM[Long Term]

    end

    subgraph Store

        direction TB

        DB[(Vector DB)]

    end

    Input[Input] ---> Agents

    subgraph Agents

        direction LR

        A1[Agent 1]

        A2[Agent 2]

        A3[Agent 3]

    end

    Agents ---> Output[Output]

    Memory <--> Store

    Store <--> A1

    Store <--> A2

    Store <--> A3

    style Memory fill:#189AB4,color:#fff

    style Store fill:#2E8B57,color:#fff

    style Agents fill:#8B0000,color:#fff

    style Input fill:#8B0000,color:#fff

    style Output fill:#8B0000,color:#fff

```

## AI Agents with Different Processes

### Sequential Process

The simplest form of task execution where tasks are performed one after another.

```mermaid

graph LR

    Input[Input] --> A1

    subgraph Agents

        direction LR

        A1[Agent 1] --> A2[Agent 2] --> A3[Agent 3]

    end

    A3 --> Output[Output]

    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff

    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff

    classDef transparent fill:none,stroke:none

    class Input,Output input

    class A1,A2,A3 process

    class Agents transparent

```

### Hierarchical Process

Uses a manager agent to coordinate task execution and agent assignments.

```mermaid

graph TB

    Input[Input] --> Manager

    

    subgraph Agents

        Manager[Manager Agent]

        

        subgraph Workers

            direction LR

            W1[Worker 1]

            W2[Worker 2]

            W3[Worker 3]

        end

        

        Manager --> W1

        Manager --> W2

        Manager --> W3

    end

    

    W1 --> Manager

    W2 --> Manager

    W3 --> Manager

    Manager --> Output[Output]

    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff

    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff

    classDef transparent fill:none,stroke:none

    class Input,Output input

    class Manager,W1,W2,W3 process

    class Agents,Workers transparent

```

### Workflow Process

Advanced process type supporting complex task relationships and conditional execution.

```mermaid

graph LR

    Input[Input] --> Start

    

    subgraph Workflow

        direction LR

        Start[Start] --> C1{Condition}

        C1 --> |Yes| A1[Agent 1]

        C1 --> |No| A2[Agent 2]

        A1 --> Join

        A2 --> Join

        Join --> A3[Agent 3]

    end

    

    A3 --> Output[Output]

    classDef input fill:#8B0000,stroke:#7C90A0,color:#fff

    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff

    classDef decision fill:#2E8B57,stroke:#7C90A0,color:#fff

    classDef transparent fill:none,stroke:none

    class Input,Output input

    class Start,A1,A2,A3,Join process

    class C1 decision

    class Workflow transparent

```

#### Agentic Routing Workflow

Create AI agents that can dynamically route tasks to specialized LLM instances.

```mermaid

flowchart LR

    In[In] --> Router[LLM Call Router]

    Router --> LLM1[LLM Call 1]

    Router --> LLM2[LLM Call 2]

    Router --> LLM3[LLM Call 3]

    LLM1 --> Out[Out]

    LLM2 --> Out

    LLM3 --> Out

    

    style In fill:#8B0000,color:#fff

    style Router fill:#2E8B57,color:#fff

    style LLM1 fill:#2E8B57,color:#fff

    style LLM2 fill:#2E8B57,color:#fff

    style LLM3 fill:#2E8B57,color:#fff

    style Out fill:#8B0000,color:#fff

```

#### Agentic Orchestrator Worker

Create AI agents that orchestrate and distribute tasks among specialized workers.

```mermaid

flowchart LR

    In[In] --> Router[LLM Call Router]

    Router --> LLM1[LLM Call 1]

    Router --> LLM2[LLM Call 2]

    Router --> LLM3[LLM Call 3]

    LLM1 --> Synthesizer[Synthesizer]

    LLM2 --> Synthesizer

    LLM3 --> Synthesizer

    Synthesizer --> Out[Out]

    

    style In fill:#8B0000,color:#fff

    style Router fill:#2E8B57,color:#fff

    style LLM1 fill:#2E8B57,color:#fff

    style LLM2 fill:#2E8B57,color:#fff

    style LLM3 fill:#2E8B57,color:#fff

    style Synthesizer fill:#2E8B57,color:#fff

    style Out fill:#8B0000,color:#fff

```

#### Agentic Autonomous Workflow

Create AI agents that can autonomously monitor, act, and adapt based on environment feedback.

```mermaid

flowchart LR

    Human[Human] <--> LLM[LLM Call]

    LLM -->|ACTION| Environment[Environment]

    Environment -->|FEEDBACK| LLM

    LLM --> Stop[Stop]

    

    style Human fill:#8B0000,color:#fff

    style LLM fill:#2E8B57,color:#fff

    style Environment fill:#8B0000,color:#fff

    style Stop fill:#333,color:#fff

```

#### Agentic Parallelization

Create AI agents that can execute tasks in parallel for improved performance.

```mermaid

flowchart LR

    In[In] --> LLM2[LLM Call 2]

    In --> LLM1[LLM Call 1]

    In --> LLM3[LLM Call 3]

    LLM1 --> Aggregator[Aggregator]

    LLM2 --> Aggregator

    LLM3 --> Aggregator

    Aggregator --> Out[Out]

    

    style In fill:#8B0000,color:#fff

    style LLM1 fill:#2E8B57,color:#fff

    style LLM2 fill:#2E8B57,color:#fff

    style LLM3 fill:#2E8B57,color:#fff

    style Aggregator fill:#fff,color:#000

    style Out fill:#8B0000,color:#fff

```

#### Agentic Prompt Chaining

Create AI agents with sequential prompt chaining for complex workflows.

```mermaid

flowchart LR

    In[In] --> LLM1[LLM Call 1] --> Gate{Gate}

    Gate -->|Pass| LLM2[LLM Call 2] -->|Output 2| LLM3[LLM Call 3] --> Out[Out]

    Gate -->|Fail| Exit[Exit]

    

    style In fill:#8B0000,color:#fff

    style LLM1 fill:#2E8B57,color:#fff

    style LLM2 fill:#2E8B57,color:#fff

    style LLM3 fill:#2E8B57,color:#fff

    style Out fill:#8B0000,color:#fff

    style Exit fill:#8B0000,color:#fff

```

#### Agentic Evaluator Optimizer

Create AI agents that can generate and optimize solutions through iterative feedback.

```mermaid

flowchart LR

    In[In] --> Generator[LLM Call Generator] 

    Generator -->|SOLUTION| Evaluator[LLM Call Evaluator] -->|ACCEPTED| Out[Out]

    Evaluator -->|REJECTED + FEEDBACK| Generator

    

    style In fill:#8B0000,color:#fff

    style Generator fill:#2E8B57,color:#fff

    style Evaluator fill:#2E8B57,color:#fff

    style Out fill:#8B0000,color:#fff

```

#### Repetitive Agents

Create AI agents that can efficiently handle repetitive tasks through automated loops.

```mermaid

flowchart LR

    In[Input] --> LoopAgent[("Looping Agent")]

    LoopAgent --> Task[Task]

    Task --> |Next iteration| LoopAgent

    Task --> |Done| Out[Output]

    

    style In fill:#8B0000,color:#fff

    style LoopAgent fill:#2E8B57,color:#fff,shape:circle

    style Task fill:#2E8B57,color:#fff

    style Out fill:#8B0000,color:#fff

```

## Adding Models



  

    

      

    

  



## Ollama Integration

```bash

export OPENAI_BASE_URL=http://localhost:11434/v1

```

## Groq Integration

Replace xxxx with Groq API KEY:

```bash

export OPENAI_API_KEY=xxxxxxxxxxx

export OPENAI_BASE_URL=https://api.groq.com/openai/v1

```

## No Code Options

## Agents Playbook

### Simple Playbook Example

Create `agents.yaml` file and add the code below:

```yaml

framework: praisonai

topic: Artificial Intelligence

roles:

  screenwriter:

    backstory: "Skilled in crafting scripts with engaging dialogue about {topic}."

    goal: Create scripts from concepts.

    role: Screenwriter

    tasks:

      scriptwriting_task:

        description: "Develop scripts with compelling characters and dialogue about {topic}."

        expected_output: "Complete script ready for production."

```

*To run the playbook:*

```bash

praisonai agents.yaml

```

## Use 100+ Models

- https://docs.praison.ai/models/



  

    

      

    

  



## Development:

Below is used for development only.

### Using uv

```bash

# Install uv if you haven't already

pip install uv

# Install from requirements

uv pip install -r pyproject.toml

# Install with extras

uv pip install -r pyproject.toml --extra code

uv pip install -r pyproject.toml --extra "crewai,autogen"

```

## Contributing

- Fork on GitHub: Use the "Fork" button on the repository page.

- Clone your fork: `git clone https://github.com/yourusername/praisonAI.git`

- Create a branch: `git checkout -b new-feature`

- Make changes and commit: `git commit -am "Add some feature"`

- Push to your fork: `git push origin new-feature`

- Submit a pull request via GitHub's web interface.

- Await feedback from project maintainers.

## Other Features

- 🔄 Use CrewAI or AG2 (Formerly AutoGen) Framework

- 💻 Chat with ENTIRE Codebase

- 🎨 Interactive UIs

- 📄 YAML-based Configuration

- 🛠️ Custom Tool Integration

- 🔍 Internet Search Capability (using Crawl4AI and Tavily)

- 🖼️ Vision Language Model (VLM) Support

- 🎙️ Real-time Voice Interaction

## Star History

[![Star History Chart](https://api.star-history.com/svg?repos=MervinPraison/PraisonAI&type=Date)](https://docs.praison.ai)

## Video Tutorials

| Topic | Video |

|-------|--------|

| AI Agents with Self Reflection | [![Self Reflection](https://img.youtube.com/vi/vLXobEN2Vc8/0.jpg)](https://www.youtube.com/watch?v=vLXobEN2Vc8) |

| Reasoning Data Generating Agent | [![Reasoning Data](https://img.youtube.com/vi/fUT332Y2zA8/0.jpg)](https://www.youtube.com/watch?v=fUT332Y2zA8) |

| AI Agents with Reasoning | [![Reasoning](https://img.youtube.com/vi/KNDVWGN3TpM/0.jpg)](https://www.youtube.com/watch?v=KNDVWGN3TpM) |

| Multimodal AI Agents | [![Multimodal](https://img.youtube.com/vi/hjAWmUT1qqY/0.jpg)](https://www.youtube.com/watch?v=hjAWmUT1qqY) |

| AI Agents Workflow | [![Workflow](https://img.youtube.com/vi/yWTH44QPl2A/0.jpg)](https://www.youtube.com/watch?v=yWTH44QPl2A) |

| Async AI Agents | [![Async](https://img.youtube.com/vi/VhVQfgo00LE/0.jpg)](https://www.youtube.com/watch?v=VhVQfgo00LE) |

| Mini AI Agents | [![Mini](https://img.youtube.com/vi/OkvYp5aAGSg/0.jpg)](https://www.youtube.com/watch?v=OkvYp5aAGSg) |

| AI Agents with Memory | [![Memory](https://img.youtube.com/vi/1hVfVxvPnnQ/0.jpg)](https://www.youtube.com/watch?v=1hVfVxvPnnQ) |

| Repetitive Agents | [![Repetitive](https://img.youtube.com/vi/dAYGxsjDOPg/0.jpg)](https://www.youtube.com/watch?v=dAYGxsjDOPg) |

| Introduction | [![Introduction](https://img.youtube.com/vi/Fn1lQjC0GO0/0.jpg)](https://www.youtube.com/watch?v=Fn1lQjC0GO0) |

| Tools Overview | [![Tools Overview](https://img.youtube.com/vi/XaQRgRpV7jo/0.jpg)](https://www.youtube.com/watch?v=XaQRgRpV7jo) |

| Custom Tools | [![Custom Tools](https://img.youtube.com/vi/JSU2Rndh06c/0.jpg)](https://www.youtube.com/watch?v=JSU2Rndh06c) |

| Firecrawl Integration | [![Firecrawl](https://img.youtube.com/vi/UoqUDcLcOYo/0.jpg)](https://www.youtube.com/watch?v=UoqUDcLcOYo) |

| User Interface | [![UI](https://img.youtube.com/vi/tg-ZjNl3OCg/0.jpg)](https://www.youtube.com/watch?v=tg-ZjNl3OCg) |

| Crawl4AI Integration | [![Crawl4AI](https://img.youtube.com/vi/KAvuVUh0XU8/0.jpg)](https://www.youtube.com/watch?v=KAvuVUh0XU8) |

| Chat Interface | [![Chat](https://img.youtube.com/vi/sw3uDqn2h1Y/0.jpg)](https://www.youtube.com/watch?v=sw3uDqn2h1Y) |

| Code Interface | [![Code](https://img.youtube.com/vi/_5jQayO-MQY/0.jpg)](https://www.youtube.com/watch?v=_5jQayO-MQY) |

| Mem0 Integration | [![Mem0](https://img.youtube.com/vi/KIGSgRxf1cY/0.jpg)](https://www.youtube.com/watch?v=KIGSgRxf1cY) |

| Training | [![Training](https://img.youtube.com/vi/aLawE8kwCrI/0.jpg)](https://www.youtube.com/watch?v=aLawE8kwCrI) |

| Realtime Voice Interface | [![Realtime](https://img.youtube.com/vi/frRHfevTCSw/0.jpg)](https://www.youtube.com/watch?v=frRHfevTCSw) |

| Call Interface | [![Call](https://img.youtube.com/vi/m1cwrUG2iAk/0.jpg)](https://www.youtube.com/watch?v=m1cwrUG2iAk) |

| Reasoning Extract Agents | [![Reasoning Extract](https://img.youtube.com/vi/2PPamsADjJA/0.jpg)](https://www.youtube.com/watch?v=2PPamsADjJA) |

ecosyste.ms

Data

Tools

Indexes

Applications

Experiments

Awesome

https://github.com/MervinPraison/PraisonAI

Awesome Lists containing this project

README