Enterprise
Agents
Bot
Use Cases
University
Docs

Getting Started CLI Gateway & Bots Agents Code UI Tools MCP Deploy Examples SDK JS Rust Course

Getting Started

Getting Started

Introduction
Installation
Quick Start
Windows SDK Quickstart

Install

Quick Install
macOS Desktop App
Desktop App
Installer Internals
Isolation Backends
praisonai upgrade
praisonai uninstall
Update Hint

Core Concepts

Managed Agents

Managed Agents
Local Managed Agents
Docker Compute Agents
E2B Cloud Agents
Modal Compute Agents
Daytona Workspace Agents

Guides

Guides
Documentation Style Guide
praisonai-code package migration
Building a Single Agent
Building Multi-Agent Systems
Run Fully Offline
Task handover (early access)

Templates

Recipes Guide
Create Custom Recipes
Use Existing Recipes
Add Tools to Recipes
Manage Recipes
Debug Recipes
Different Ways to Create Recipes

Tools

Tools Guide
Create Custom Tools
Assign Tools to Templates
Debug Tools
Different Ways to Create Tools
Remote Tools from GitHub
Dynamic Tool Schemas

Workflows

Workflows
Routing Workflow
Parallel Workflow
Sequential Workflow
Orchestrator Pattern

RAG & Knowledge

RAG & Knowledge
Knowledge Base Setup
Chunking Strategies
Retrieval Methods

Persistence

Persistence
Persistence Overview
Database Setup
Session Resume
Persistence Overview
Quickstart
Session Resume
Async Conversation Store
Async State Store
Async Knowledge Store
MySQL Conversation Store
Async DB Hooks
Orchestrator-Based Persistence

Deployment

Deployment
Deployment Overview
Docker Deployment
Golden Path: Agent → Gateway → Channel → Sandbox
Helm Chart (Gateway)
Gateway Troubleshooting

Platform

Recipes

Recipe Integration Guide
Integration Models
Use Cases
Personas
Decision Guide

Integration Models

Integration Models Overview
Model 1: Embedded SDK
Model 2: CLI Invocation
Model 3: Local HTTP Sidecar
Model 4: Remote Managed Runner
Model 5: Event-Driven
Model 6: Plugin Mode

Personas

Personas Overview
App Developer Persona
Platform/DevOps Persona
Recipe Author Persona

Blog Generators

Image to Blog Generator
URL to Blog Generator

Features

Packaging & Bundlers
Gateway Inbound Hooks

Desktop App

PraisonAI Desktop
Chat & Streaming
Video generation
Training
Conversations, Projects & Search
Approvals & Safety
Fine-Tuning
Models & API Keys
Settings Reference
Agent Framework
MCP Servers
Data & Privacy
Environment Variables
Engine API
Headless CLI
First-Run Provisioning
Window, Menubar & Lifecycle
Engine, Updates & Diagnostics

Mobile App

Deploy Surfaces

Deploy with Docker Compose
Scaffold a Deployment Project
Deploy with praisonai deploy helm
Helm Chart (Agents API)
Deploy to Fly.io
Deploy to Railway
Deploy to Render
24/7 Production Minimal Guide

Industry Templates

Industry Templates
Manufacturing Template
Energy Template
Healthcare Template
Agriculture Template
Transportation Template

Agent Capabilities

Five-Layer Agent Stack

Core Agent Features

Reasoning & Intelligence

Reasoning Models
Reasoning Agents
Reasoning Extract Agents
Generate Synthetic Reasoning Data Agents
Self Reflection
Model Router System
LLM-as-Judge

Specialized Agents

Code Execution AI Agent
Math AI Agent
Scientific Writer Agent
Meeting Notes Agent

Communication & Messaging

Integration & Infrastructure

Browser Automation

praisonai-browser Package
Browser Agent Module
Browser Agent Deep Dive
Offline & CI Install
Browser Extension Architecture
Browser Bridge Protocol

Workflow Patterns

Workflows
Step-Result Cache
Workflow Diagram
Workflow Checkpoint & Resume
Workflow Discussion (N-Agent Conversation Loop)
Workflow Patterns

Multi-Agent Coordination

Specialised Agents
Multi-Agent Media Pipelines
Multi-Agent Output
Agentic Orchestrator Worker
Spawn & Announce
Multi-Agent Hooks
Human-in-the-Loop Review
Multi-Agent Execution
Multi-Agent Planning
Multi-Agent Memory
AgentTeam Batch Runs
Where Each Option Belongs
AgentTeam Re-runs
AgentTeam Supported Params
AgentTeam Task Validation
AgentTeam Task Graph
Container Default LLM
Handoff Filters

Control Flow & Logic

Agentic Routing
Conditional Execution
Conditional Branching
Markdown Workflow Branches
Workflow Routing
Workflow Validation Loop
Typed Workflow State

Execution Patterns

Agentic Autonomous Workflow
Agentic Parallelisation
Workflow Parallel Execution
Error Handling
Workflow Error Recovery
Workflow Error Handling
Agentic Prompt Chaining
Execution & Extension Systems

Loops & Repetition

Repetitive Agents
Loop Tasks
Workflow Loop Processing
Workflow Repeat (Evaluator-Optimizer)

YAML Configuration

YAML Workflows
Job Workflows
YAML Configuration Reference
YAML Validation
Editor Autocomplete for agents.yaml
Workflow YAML Framework Field

Advanced Patterns

Agentic Evaluator Optimizer
Custom Actions
Handler Tasks
Output Variables
Hybrid Workflows
Modular Recipes
Nested Workflows
Hierarchical Workflows

Evaluation

Evaluation Loop
Evaluation Suite
Run Fingerprint
Eval Datasets
Loop Evaluator
Judge
Recipe Judge
Grade Your Last Run
Context Evaluator
Harness Evaluator
EvalPort Adapter
Safety Evaluation
Media Evaluator
Goal Engineering
Terminal-Bench Integration

Safety & Control

Cloud Databases

Cloud-Native Serverless Databases
Neon Serverless PostgreSQL
Supabase Database
Turso Edge Database
CockroachDB Serverless
Xata Serverless Database

State & Sessions

Context Management

Async & Background

Activity Log
Async Agents
Async Crew Kickoff
Async Bridge
Async Self-Reflection
Async Jobs
Jobs agent_file Root
Background Tasks
Run Ledger
Run-State Journal
Durable Tool Runs
Durable Background Jobs
Kanban
Kanban CLI
Middleware
HOL Guard Tool Policy
Async Agent Scheduler
Background Subagents

LLM & Models

Model Catalogue
Standalone LLM Modules
AutoGen Config List
Model Capabilities
Model Fallback
RouteLLM Integration
Panel LLM (Mixture-of-Agents)
Configurable Model
Rate Limiter
LLM Timeouts
Reasoning Effort
Thinking Budgets
Advanced Multi-Provider Patterns
Default Model Selection
Multi-Model Panel

UI & Display

Display System
Display Callbacks
Output Styles
Save Agent Output
Headless YAML Runs
Generative UI
A2UI Protocol
Integrate A2UI with Your Frontend
Integrating PraisonAI with PraisonAIUI

Integrations

Capabilities

Capabilities Overview
Completions
Completions CLI
Embeddings
Embeddings CLI
Images
Images CLI
Videos
Videos CLI
Messages
Messages CLI
Moderations
Moderations CLI
Audio
Audio CLI
Realtime
Realtime CLI
Search
Vector Store Files
Containers
Passthrough api_base SSRF Guard
Audio Tools
Chat with PDF Agents

Embedding Providers

Embedding Providers

Cloud Providers

OpenAI Embeddings
Azure OpenAI Embeddings
Azure AI Embeddings
Google Vertex AI Embeddings
Google Gemini Embeddings
AWS Bedrock Embeddings

Specialized Providers

Cohere Embeddings
Voyage AI Embeddings
Jina AI Embeddings
Mistral Embeddings

Open Source & Self-Hosted

HuggingFace Embeddings
Ollama Embeddings
Infinity Embeddings
vLLM Embeddings
LM Studio Embeddings

Additional Providers

Together AI Embeddings
Fireworks AI Embeddings
NVIDIA NIM Embeddings
Databricks Embeddings
Snowflake Embeddings
IBM Watsonx Embeddings
SambaNova Embeddings
Nebius Embeddings
OVHcloud Embeddings
Volcengine Embeddings

Advanced Features

Performance & Optimization

Lazy Imports & Fast Startup
Fast CLI Startup
Lite Package (BYO-LLM)
Logging Configuration
MCP Lifecycle Management
MCP CLI Tools Path Safety
Performance Benchmarks
Thread-Safe Agent State
ToolRegistry AutoGen Migration
AutoGen Code Execution
AutoGen v0.2 YAML Tools
Real API Key Testing
Offline Testing

Database Persistence

Database Persistence
Run History
SQLite Persistence
Hardened SQLite Storage
PostgreSQL Persistence
MySQL Persistence
Redis State Store
MongoDB State Store
ClickHouse Persistence
JSON File Persistence
Storage Backends

TUI

TUI Overview
TUI Commands
Queue System
TUI Simulation

Deploy Package (praisonai-deploy)

Deploy Package
Deploy Quick Start
Deploy Python API
Deploy Config Reference
Deploy CLI
Custom cloud providers
Deploy Doctor
Deploy Migration

Models

Models in PraisonAI
OpenAI ChatGPT
OpenAI-Compatible Endpoints
Ollama
Groq
Google Gemini
OpenRouter
LiteLLM Proxy
Anthropic Claude
AWS Bedrock
Cohere
Mistral
NVIDIA NIM
DeepSeek
Together AI
Other Models
Custom Provider Registry

Databases

Databases Overview

Conversation Stores

PostgreSQL
MySQL
SQLite
JSON
SingleStore
Supabase
SurrealDB
Neon

Knowledge Stores

Qdrant
ChromaDB
Pinecone
Weaviate
LanceDB
Milvus
PGVector
Cassandra
ClickHouse
Couchbase
Azure Cosmos DB
MongoDB Knowledge

State Stores

Redis
MongoDB
DynamoDB
Firestore
Upstash
Google Cloud Storage

Observability

Observability Overview
Performance Profiling
AgentOps
Langextract
Langfuse
LangSmith
Traceloop
Arize Phoenix
OpenLIT
Langtrace
LangWatch
Datadog
MLflow
Opik
Portkey
Braintrust
Maxim
Weave
Neatlogs
LangDB
Atla
Patronus
TrueFoundry
AgentOps PraisonAI Monitoring
Latency Tracking

Memory

Memory Overview
Memory Storage
Quickstart
Session Resume
Advanced Memory System
Graph Memory
Memory Advanced Search
Memory Lifecycle Hooks
Memory Consolidation
Custom Memory Adapters
MongoDB Memory
Local Memory & Knowledge
Dakera Memory

Telemetry & Analytics

Token Usage Protocol
Durable Token Usage Sink (SQLite)
Usage Reporting

Knowledge

Knowledge Overview
Knowledge Quick Start
Knowledge Storage
Knowledge Erasure
Knowledge Base
Knowledge Backends
Chat with PDF Agents

RAG

RAG Overview
RAG Quickstart
RAG Quick Start
Retrieval Configuration
Quality-Based RAG Patterns
RAG Module
Citations
RAG CLI

Chunking Strategies

Chunking Strategies Overview
Token Chunking
Sentence Chunking
Recursive Chunking
Semantic Chunking
SDPM Chunking
Late Chunking

Web Scraping

Firecrawl PraisonAI Integration

Task Management

Linear Tools

Other Features

PraisonAI Train
Praison AI Agents Playground
CrewAI with PraisonAI
AutoGen with PraisonAI
PraisonAI Agents
Google ADK with PraisonAI
Agno with PraisonAI
Pydantic AI with PraisonAI
OpenAI Agents with PraisonAI
API Reference
API Reference
API Reference
Workflow API
PraisonAI Call
Praison AI
Features Overview

API Reference

Simplified API Reference
praisonaiagents API

A2A Endpoints

A2A API
GET Agent Card API
GET Status API
POST A2A API
A2A Architecture

AGUI Endpoints

AG-UI API
GET /status
POST /agui API

Launch Endpoints

Agent Launch API
POST Agent Endpoint API

MCP Endpoints

MCP Server API
GET /sse API
POST Messages API

Developers

Complete Reference
Testing Guide
Pytest Failure Categories
Agents Playbook
PraisonAI Package Integration
Integrate with Tools
Google Colab Integration
Google Colab Tools
Local Development
Development Setup
Benchmarks
Production Deployment Guide
Testing Agents Guide
Advanced Tool Development
Contributing
Video Tutorials

SDK Internals

Core Principles
SDK Architecture

Configuration

Configuration Reference
Agent Configuration
Task Configuration
LLM Configuration
Memory Configuration
LearnConfig
KnowledgeConfig
PlanningConfig
ReflectionConfig
WebConfig
OutputConfig
ExecutionConfig
TemplateConfig
CachingConfig
HooksConfig
SkillsConfig
AutonomyConfig
Tool Configuration
Guardrail Configuration
Handoff Configuration
Configuration Best Practices

Best Practices

Error Handling in Multi-Agent Systems
Debugging Multi-Agent Systems
Performance Tuning Guidelines
Security Best Practices
Token Usage Optimization
Memory Cleanup for Long-Running Apps
Agent Retry Strategies
Graceful Degradation Patterns
Multi-User Session Handling
State Conflict Resolution
Task Orchestration Best Practices

Getting Started (No Code)

Introduction
TL;DR
Installation
Initialise
Run
Auto Generation Mode

Docs/Getting Started/Advanced Features/Test

Test

Instructions for running and writing tests for PraisonAI components, including unit tests and test automation

Test

bash

python -m unittest tests.test

Platform
Use Cases
Agents
Bot
Enterprise
Partners
Community
FAQ
About
University
Documentation
GitHub

© Praison AI Limited.

Search inAllDocsUniversity