Praison AI - PraisonAI Documentation

Key Features

AI Agents Creation

Automated creation and management of AI agents with self-reflection capabilities

Workflow Patterns

Sequential, parallel, hierarchical, and custom workflow orchestration

LLM Support

Support for 100+ Language Learning Models

Code Integration

Chat with your entire codebase using advanced context understanding

Interactive UI

Rich, interactive user interfaces for better control and monitoring

Configuration

YAML-based configuration for easy setup and customization

Tool Integration

Custom tool integration for extended functionality

Search Capability

Internet search using Crawl4AI and Tavily

Install

Code
No Code
JavaScript
TypeScript

Install Package

pip install praisonaiagents

Set API Key

export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx

Create File

Create app.py file

Code Example

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 Script

python app.py

Install Package

Install the No Code PraisonAI Package:

pip install praisonaiagents

Set API Key

export OPENAI_API_KEY=your_openai_key

Create Config

Create agents.yaml:

agents:  # Canonical
  summarise_agent:
    instructions: Summarise Photosynthesis

You can automatically create agents.yaml using:

praisonai --init "your task description"

Run Agents

Execute your config:

praisonai agents.yaml

Install Package

npm install praisonai

Set API Key

export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx

Create File

Create app.js file

Code Example

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');

Run Script

node app.js

Install Package

npm install praisonai

Set API Key

export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx

Create File

Create app.ts file

Code Example

import { Agent } from 'praisonai';

const agent = new Agent({ 
  instructions: `You are a creative writer who writes short stories with emojis.`,
  name: "StoryWriter"
});

agent.start("Write a story about a time traveler")

Run Script

npx ts-node app.ts

How Execution Works

PraisonAI offers multiple ways to run AI agents. Choose the approach that fits your use case.

1. Agent Execution

The simplest way to run AI—create an agent and give it a task.

from praisonaiagents import Agent

agent = Agent(instructions="You are a helpful assistant")
agent.start("Summarize the latest AI news")

Learn more about Agents

Create single agents, configure instructions, add tools, and enable memory.

2. Workflow Execution

For complex tasks, use workflows to chain multiple agents together.

from praisonaiagents import Agent, Workflow

researcher = Agent(name="Researcher", instructions="Research topics")
writer = Agent(name="Writer", instructions="Write content")

workflow = Workflow(steps=[researcher, writer])
result = workflow.start("Write an article about AI trends")

Learn more about Workflows

Build multi-step workflows with routing, parallel execution, loops, and conditionals.

3. Agent Recipes

Recipes are pre-built, production-ready AI tools you can run instantly. 55+ recipes available.

# List available recipes
praisonai recipe list

# Run a recipe
praisonai recipe run ai-blog-generator --input '{"topic": "AI trends"}'

Browse Agent Recipes

55+ production-ready AI tools for video, documents, images, code, and more.

4. Custom Tools

Extend agent capabilities by creating custom tools.

from praisonaiagents import Agent

def search_web(query: str) -> str:
    """Search the web for information."""
    return f"Results for: {query}"

agent = Agent(
    instructions="You are a research assistant",
    tools=[search_web]
)
agent.start("Find the latest news about Python")

Learn more about Tools

Create custom tools, use built-in tools, and integrate with external APIs.

Feature Map

Python SDK (praisonaiagents)

Single Agent

Create a single AI agent

Multi Agents

Coordinate multiple agents

Workflows

Build multi-step pipelines

Memory

Persistent agent memory

Knowledge/RAG

Document retrieval

Guardrails

Safety and validation

Tools Ecosystem

Web Search

Search the internet

File Tools

Read/write files

Code Execution

Run Python code

Database Tools

Query databases

Custom Tools

Build your own

All Tools

Browse all tools

MCP (Model Context Protocol)

MCP Overview

What is MCP?

Stdio Transport

Local process communication

SSE Transport

HTTP streaming

GitHub MCP

GitHub integration

Custom MCP

Build MCP servers

PraisonAI MCP Server

Expose agents via MCP

Deploy

Deploy Overview

Deployment options

Agents Server

HTTP API for agents

MCP Server

Deploy as MCP server

A2A Protocol

Agent-to-agent communication

Docker

Container deployment

Cloud Deploy

AWS, Azure, GCP

JavaScript/TypeScript SDK

JS Overview

Getting started

TypeScript

TypeScript guide

Agent API

Create agents

Tools

Add tools

Memory

Agent memory

Workflows

Multi-step workflows

CLI at a Glance

# Install CLI
pip install praisonai

# Run an agent with a prompt
praisonai "Summarize the latest AI news"

# Run agents from YAML config
praisonai agents.yaml

# Start interactive mode
praisonai --auto

# Deep research mode
praisonai --deep-research "What are the latest AI trends?"

# List available recipes
praisonai recipe list

# Start agent server
praisonai serve

Command	Description
`praisonai "prompt"`	Run agent with prompt
`praisonai agents.yaml`	Run from YAML config
`praisonai --auto`	Interactive auto mode
`praisonai --deep-research`	Deep research mode
`praisonai recipe list`	List recipes
`praisonai recipe run`	Run a recipe
`praisonai serve`	Start HTTP server
`praisonai mcp list`	List MCP servers

Full CLI Reference

Complete documentation for all CLI commands and options.

AI Agents Flow

AI Agents with Tools

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

AI Agents with Memory

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

AI Agents with Different Processes

Sequential Process

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

Hierarchical Process

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

Workflow Process

Advanced process type supporting complex task relationships and conditional execution.

Agentic Routing Workflow

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

Agentic Orchestrator Worker

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

Agentic Autonomous Workflow

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

Agentic Parallelization

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

Agentic Prompt Chaining

Create AI agents with sequential prompt chaining for complex workflows.

Agentic Evaluator Optimizer

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

Repetitive Agents

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

Integration Options

Ollama Integration

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

Groq Integration

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

Logging Configuration

# Basic logging
export LOGLEVEL=info

# Advanced logging
export LOGLEVEL=debug

Use Cases

Customer Service

Build intelligent support agents that can handle customer inquiries and resolve issues autonomously.

Data Analysis

Create agents that can process, analyze, and derive insights from complex datasets.

Content Creation

Deploy agents that can generate, edit, and optimize content across various formats.

Process Automation

Automate complex workflows with intelligent agents that can coordinate and execute tasks.

Praison AI Package Overall Features

PraisonAI Features Overview

Features

Self-Reflection

Agents that evaluate and improve their own responses for higher accuracy

Reasoning

Multi-step logical reasoning and autonomous problem solving

Memory & Knowledge

Persistent memory and RAG-powered knowledge bases for context-aware agents

MCP Integration

Connect to external tools and services via Model Context Protocol

Multimodal Agents

Work with agents that can process text, images, and other data types

Train

Train and fine-tune your LLMs for specific tasks and domains. Then use it as an AI Agent.

User Interfaces

Multi Agents UI

Visual interface for building and managing multi-agent systems

Chat Interface

Chat with 100+ LLMs using a single AI Agent

Code Interface

Interact with your entire codebase

Welcome to PraisonAI - Your comprehensive solution for building and managing multi-agent LLM systems with self-reflection capabilities.

Video Tutorials

Topic	Video
AI Agents with Self Reflection
Reasoning Data Generating Agent
AI Agents with Reasoning
Multimodal AI Agents
AI Agents Workflow
Async AI Agents
Mini AI Agents
AI Agents with Memory
Repetitive Agents
Introduction
Tools Overview
Custom Tools
Firecrawl Integration
User Interface
Crawl4AI Integration
Chat Interface
Code Interface
Mem0 Integration
Training
Realtime Voice Interface
Call Interface
Reasoning Extract Agents