Complete Reference

Comprehensive reference documentation for PraisonAI including all features, diagrams, and examples.

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

Install Package
bash
```
pip install praisonaiagents
```

Set API Key

bash

export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx

Create File

Create app.py file

## Code Example

Single Agent

from praisonaiagents import Agent

agent = Agent(instructions="Your are a helpful AI assistant")
agent.start("Write a movie script about a robot in Mars")

Multi Agents

from praisonaiagents import Agent, AgentTeam

research_agent = Agent(instructions="Research about AI")
summarise_agent = Agent(instructions="Summarise research agent's findings")

agents = AgentTeam(agents=[research_agent, summarise_agent])
agents.start()

Run Script
bash
```
python app.py
```

No Code

Install Package
Install the No Code PraisonAI Package:
bash
```
pip install praisonaiagents
```
Set API Key
bash
```
export OPENAI_API_KEY=your_openai_key
```

Create Config

Create agents.yaml:

Single Agent

agents:  # Canonical
  summarise_agent:
    instructions: Summarise Photosynthesis

Multiple Agents

agents:  # Canonical
  diet_agent:
    instructions: Give me 5 healthy food recipes
  blog_agent:
    instructions: Write a blog post about the food recipes

Run Agents
Execute your config:
bash
```
praisonai agents.yaml
```

JavaScript

Install Package
bash
```
npm install praisonai
```

Set API Key

bash

export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx

Create File

Create app.js file

## Code Example

Single Agent

const { Agent } = require('praisonai');
const agent = new Agent({ instructions: 'You are a helpful AI assistant' });
agent.start('Write a movie script about a robot in Mars');

Multi AgentTeam

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

const researchAgent = new Agent({ instructions: 'Research about AI' });
const summariseAgent = new Agent({ instructions: 'Summarise research agent\'s findings' });

const agents = new AgentTeam({ agents: [researchAgent, summariseAgent] });
agents.start();

Run Script
bash
```
node app.js
```

TypeScript

Install Package
npm
```
npm install praisonai
```
yarn
```
yarn add praisonai
```

Set API Key

bash

export OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxxx

Create File

Create app.ts file

## Code Example

Single Agent

import { Agent } from 'praisonai';

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

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

Multi AgentTeam

import { Agent, AgentTeam } from 'praisonai';

const storyAgent = new Agent({
  instructions: "Generate a very short story (2-3 sentences) about artificial intelligence with emojis.",
  name: "StoryAgent"
});

const summaryAgent = new Agent({
  instructions: "Summarize the provided AI story in one sentence with emojis.",
  name: "SummaryAgent"
});

const agents = new AgentTeam({
  agents: [storyAgent, summaryAgent]
});

agents.start()

Run Script
bash
```
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.

python

from praisonaiagents import Agent

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

Diagram

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.

python

from praisonaiagents import Agent, AgentFlow

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

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

Diagram

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.

bash

# List available recipes
praisonai recipe list

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

Diagram

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.

python

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")

Diagram

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

bash

# 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

Diagram

AI Agents with Tools

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

Diagram

AI Agents with Memory

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

Diagram

AI Agents with Different Processes

Sequential Process

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

Diagram

Hierarchical Process

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

Diagram

Workflow Process

Advanced process type supporting complex task relationships and conditional execution.

Diagram

Agentic Routing Workflow

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

Diagram

Agentic Orchestrator Worker

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

Diagram

Agentic Autonomous Workflow

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

Diagram

Agentic Parallelization

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

Diagram

Agentic Prompt Chaining

Create AI agents with sequential prompt chaining for complex workflows.

Diagram

Agentic Evaluator Optimizer

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

Diagram

Repetitive Agents

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

Diagram

Integration Options

Ollama Integration

Name the model with the ollama/ prefix — it resolves the base URL automatically and routes through the OllamaAdapter:

bash

export OPENAI_MODEL_NAME=ollama/llama3.2

Or pass it directly to the agent:

python

from praisonaiagents import Agent

agent = Agent(instructions="You are a helpful assistant", llm="ollama/llama3.2")
agent.start("Why is the sky blue?")

Setting only OPENAI_BASE_URL with no model sends the OpenAI default gpt-4o-mini to Ollama and fails with 404 model 'gpt-4o-mini' not found. See Ollama.

Groq Integration

bash

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

Logging Configuration

bash

# 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

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

Video Tutorials

Topic	Video
AI Agents with Self Reflection	![Self Reflection](https://www.youtube.com/watch?v=vLXobEN2Vc8)
Reasoning Data Generating Agent	![Reasoning Data](https://www.youtube.com/watch?v=fUT332Y2zA8)
AI Agents with Reasoning	![Reasoning](https://www.youtube.com/watch?v=KNDVWGN3TpM)
Multimodal AI Agents	![Multimodal](https://www.youtube.com/watch?v=hjAWmUT1qqY)
AI Agents Workflow	![Workflow](https://www.youtube.com/watch?v=yWTH44QPl2A)
Async AI Agents	![Async](https://www.youtube.com/watch?v=VhVQfgo00LE)
Mini AI Agents	![Mini](https://www.youtube.com/watch?v=OkvYp5aAGSg)
AI Agents with Memory	![Memory](https://www.youtube.com/watch?v=1hVfVxvPnnQ)
Repetitive Agents	![Repetitive](https://www.youtube.com/watch?v=dAYGxsjDOPg)
Introduction	![Introduction](https://www.youtube.com/watch?v=Fn1lQjC0GO0)
Tools Overview	![Tools Overview](https://www.youtube.com/watch?v=XaQRgRpV7jo)
Custom Tools	![Custom Tools](https://www.youtube.com/watch?v=JSU2Rndh06c)
Firecrawl Integration	![Firecrawl](https://www.youtube.com/watch?v=UoqUDcLcOYo)
User Interface	![UI](https://www.youtube.com/watch?v=tg-ZjNl3OCg)
Crawl4AI Integration	![Crawl4AI](https://www.youtube.com/watch?v=KAvuVUh0XU8)
Chat Interface	![Chat](https://www.youtube.com/watch?v=sw3uDqn2h1Y)
Code Interface	![Code](https://www.youtube.com/watch?v=_5jQayO-MQY)
Mem0 Integration	![Mem0](https://www.youtube.com/watch?v=KIGSgRxf1cY)
Training	![Training](https://www.youtube.com/watch?v=aLawE8kwCrI)
Realtime Voice Interface	![Realtime](https://www.youtube.com/watch?v=frRHfevTCSw)
Call Interface	![Call](https://www.youtube.com/watch?v=m1cwrUG2iAk)
Reasoning Extract Agents	![Reasoning Extract](https://www.youtube.com/watch?v=2PPamsADjJA)