Mervin Praison

Introduction to PraisonAI

PraisonAI is a production-ready Multi-AI Agents framework with self-reflection capabilities, designed to create AI agents that automate and solve problems ranging from simple tasks to complex challenges. It provides a low-code solution that streamlines the building and management of multi-agent LLM systems, emphasizing simplicity, customization, and effective human-agent collaboration.

Core Architecture

The framework integrates multiple AI agent technologies including AG2 (formerly AutoGen) and CrewAI into a unified low-code solution. This integration allows developers to leverage the strengths of different agent frameworks while maintaining a consistent development experience.

Key Unique Features

• Self-Reflection – Agents evaluate and improve their own responses for higher accuracy
• Multi-Step Reasoning – Advanced logical reasoning and autonomous problem-solving capabilities
• Persistent Memory – Zero-dependency memory system with context awareness across sessions
• MCP Integration – Model Context Protocol support for connecting to external tools and services
• Multimodal Support – Process text, images, and other data types seamlessly
• Workflow Patterns – Built-in support for route, parallel, loop, and repeat patterns
• Stateful Agents – Maintain context and learn from interactions across sessions

Advanced Capabilities

PraisonAI offers specialized features that set it apart from other frameworks:

• Planning Mode – Agents can plan and execute complex multi-step tasks
• Deep Research – Built-in research capabilities with web search integration
• Query Rewriting – Intelligent query optimization for better results
• Code Agent – Interact with entire codebases for development tasks
• Guardrails – Safety and control mechanisms for agent behavior
• Telemetry – Production monitoring and performance tracking
• Background Tasks – Asynchronous task execution

Developer Experience

The framework provides multiple interfaces for different developer preferences:

• Python SDK – Full programmatic control with praisonaiagents package
• JavaScript/TypeScript SDK – Web development support
• CLI Interface – No-code command-line operations
• YAML Configuration – Declarative agent definitions
• Visual UI – Multi-agent management interface

Integration Ecosystem

PraisonAI supports extensive integration options:

• 100+ Model Support – Compatible with OpenAI, Groq, Ollama, and more
• Database Persistence – Multiple database backends for state management
• Knowledge & RAG – Built-in retrieval-augmented generation capabilities
• Tool Ecosystem – Web search, file operations, code execution, database tools
• Custom Tools – Easy plugin development with decorators

Code Example

from praisonaiagents import Agent

# Create a simple agent
agent = Agent(instructions="You are a helpful AI assistant")
agent.start("Write a movie script about a robot on Mars")

Installation

pip install praisonaiagents
export OPENAI_API_KEY=your_api_key

Conclusion

PraisonAI stands out as a comprehensive agentic framework that combines ease of use with powerful features. Its unique combination of self-reflection, MCP integration, persistent memory, and extensive tool support makes it ideal for both simple automation tasks and complex multi-agent workflows. The framework’s low-code approach ensures accessibility while maintaining the flexibility needed for advanced applications.

EXHAUSTIVE TECHNICAL ANALYSIS: agents.yaml/tools.py vs Templates/Recipes

EXECUTIVE SUMMARY

Finding: NO DUPLICATION – Clean Separation Exists

After comprehensive code analysis across 5 repositories, agents.yaml + tools.py and Templates/Recipes serve fundamentally different purposes with no functional overlap.

A) INVENTORY (Evidence-Backed)

1. agents.yaml + tools.py Behavior

Files/Paths Involved:

Schema & Defaults:

• agents.yaml uses roles → agents normalization (lines 147-151 in yaml_parser.py)
• tools.py auto-discovered from CWD: os.path.join(root_directory, 'tools.py') (line 364)
• Precedence: tools.py in CWD > tools/ folder

Key Call Sites:

agents_generator.py:364-369 - tools.py discovery\nagents_generator.py:789-903 - _run_praisonai() execution\nyaml_parser.py:109-176 - _normalize_yaml_config()

2. Templates/Recipes System

Files/Paths Involved:

Discovery Precedence (from discovery.py:58-62):

1. ~/.praison/templates (custom, priority 1)
2. ~/.config/praison/templates (custom, priority 2)
3. ./.praison/templates (project, priority 3)
4. agent_recipes.templates (package, lowest priority)

Template Structure (TEMPLATE.yaml):

name: transcript-generator\nversion: "1.0.0"\nrequires:\n  tools: [youtube_tool]\n  packages: [openai]\n  env: [OPENAI_API_KEY]\nworkflow: workflow.yaml\nagents: agents.yaml\nconfig: {...}  # Schema for user inputs\ndefaults: {...}\ncli: {...}  # CLI integration

B) SEMANTIC MODEL (Taxonomy)

Precise Definitions

Key Differentiators

C) SIDE-BY-SIDE COMPARISON MATRIX

D) USER CONFUSION AUDIT

Identified Overlap Points

1. Both use agents.yaml filename
   • Project config: praisonai agents.yaml
   • Template: agents_file: str = "agents.yaml" in TemplateConfig (line 36 of loader.py)
   • Confusion: User sees “agents.yaml” in both contexts
2. Both use tools.py
   • Project config: Auto-loaded from CWD
   • Template: Can include tools.py in template directory
   • Confusion: Same filename, different discovery mechanisms
3. CLI overlap
   • praisonai agents.yaml (project config)
   • praisonai templates run transcript-generator (template)
   • Confusion: Two different invocation patterns for similar outcomes
4. Documentation uses “template” loosely
   • Docs reference “agents.yaml” as a “template” in some places
   • Example: /Users/praison/PraisonAIDocs/docs/nocode/introduction.mdx uses “agents.yaml” terminology
   • No clear distinction in docs between “project config” vs “distributable template”
5. Workflow vs agents.yaml naming
   • Templates use workflow.yaml as primary
   • Project config uses agents.yaml as primary
   • Both are valid entry points with normalization

Specific Confusion Sources

E) RECOMMENDATION

Decision: KEEP BOTH with CLEAR SEPARATION

Rationale:

1. Different Use Cases
   • Project Config (agents.yaml + tools.py): Rapid prototyping, local development, iteration
   • Templates/Recipes: Distribution, sharing, reproducibility, dependency management
2. No Functional Duplication
   • Project config has NO dependency checking, NO versioning, NO distribution
   • Templates have ALL of these features
   • They serve fundamentally different lifecycle stages
3. Minimal Changes Required
   • The systems are already cleanly separated in code
   • Only documentation and messaging need clarification

Proposed Changes (Minimal)

1. Terminology Clarification in Docs
   • Rename “agents.yaml” references to “Project Configuration” or “Local Config”
   • Add clear section: “Project Config vs Templates”
2. CLI Help Enhancement
   • Add explanatory text distinguishing the two modes
3. Error Message Improvement
   • When agents.yaml not found, suggest templates as alternative
4. No Code Changes Required
   • The architecture is sound
   • Templates are a superset of project config functionality

F) IMPLEMENTATION

Based on analysis, the systems are already cleanly separated. The confusion is purely terminological/documentation-based, not architectural.

Added clarifying section to /Users/praison/Agent-Recipes/README.md:5-14:

## Templates vs Project Config\n\n| Concept | What It Is | When to Use |\n|---------|------------|-------------|\n| **Project Config** (agents.yaml + tools.py) | Local, ad-hoc agent definition | Rapid prototyping |\n| **Templates/Recipes** (this repo) | Distributable, versioned bundles | Production use |

G) VERIFICATION

# README updated successfully\ncat /Users/praison/Agent-Recipes/README.md | head -15\n# Shows new "Templates vs Project Config" section

CONCLUSION

Missing = 0

• ✅ No code duplication exists
• ✅ Systems serve different purposes
• ✅ Architecture is sound
• ✅ Documentation clarification added
• ✅ No breaking changes required

The user’s concern stemmed from terminology confusion, not architectural duplication. The README update provides clear guidance on when to use each approach.

Building AI-powered applications doesn’t have to be complicated. With PraisonAI’s modular architecture, you can go from zero to a working AI agent in minutes.

Quick Start with CLI

Run a pre-built AI template with one command:

pip install praisonai agent-recipes
praisonai templates run ai-video-editor --input video.mp4

List available templates:

praisonai templates list

Add custom tools:

praisonai tools add ./my_tools.py

Python Code Approach

Create an agent with custom tools:

from praisonaiagents import Agent

def analyze_data(csv_data: str) -> str:
    """Analyze CSV data.
    
    Args:
        csv_data: CSV string
    
    Returns:
        Analysis summary
    """
    import pandas as pd
    from io import StringIO
    df = pd.read_csv(StringIO(csv_data))
    return f"Rows: {len(df)}, Columns: {list(df.columns)}"

agent = Agent(
    name="analyst",
    role="Data Analyst",
    tools=[analyze_data]
)

result = agent.start("Analyze: name,age\nAlice,30")

Why Modular Architecture?

PraisonAI uses three separate repositories:

Benefits:

• Independent versioning – Tools update without breaking core
• Community contributions – Easy to add templates without touching core
• Selective installation – Install only what you need
• Separation of concerns – Core logic vs extensions vs recipes

Auto-Discovery

Tools in ~/.praison/tools/ are automatically discovered. Just drop a Python file there:

# ~/.praison/tools/my_tools.py
def my_tool(query: str) -> str:
    """Process query."""
    return f"Result: {query}"

Your tool is now available to all agents without any configuration.

Create Your Own Template

mkdir my-template
cd my-template

# TEMPLATE.yaml
name: my-template
version: "1.0.0"
variables:
  task:
    required: true

# agents.yaml  
roles:
  agent:
    role: Assistant
    tasks:
      main:
        description: "{{task}}"

Add and run:

praisonai templates add ./my-template
praisonai templates run my-template --task "Hello World"

Resources

• Documentation
• GitHub – PraisonAI
• GitHub – Agent Recipes

Build AI agents in TypeScript with the same simplicity as Python. The PraisonAI TypeScript SDK brings powerful agent orchestration to Node.js with a clean, intuitive API.

Installation

npm install praisonai

Quick Start

Create your first agent in 3 lines:

import { Agent } from 'praisonai';
const agent = new Agent({ instructions: "You are helpful" });
await agent.chat("Hello!");

Core Features

1. Simple Agent

import { Agent } from 'praisonai';

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

const response = await agent.chat("What is TypeScript?");
console.log(response);

2. Agent with Tools

Pass functions directly – schemas are auto-generated:

import { Agent } from 'praisonai';

const getWeather = (city: string) => `Weather in ${city}: 22°C`;
const calculate = (expr: string) => eval(expr).toString();

const agent = new Agent({
  instructions: "You help with weather and calculations",
  tools: [getWeather, calculate]
});

await agent.chat("What's the weather in Paris?");

3. Multi-Agent System

import { Agent, Agents } from 'praisonai';

const researcher = new Agent({ 
  instructions: "Research topics thoroughly" 
});

const writer = new Agent({ 
  instructions: "Write based on research" 
});

const agents = new Agents([researcher, writer]);
await agents.start();

4. Persistent Memory

import { Agent, db } from 'praisonai';

const agent = new Agent({
  instructions: "You remember conversations",
  db: db("sqlite:./conversations.db"),
  sessionId: "user-123"
});

await agent.chat("My name is Alice");
await agent.chat("What's my name?"); // Remembers: Alice

5. Different LLM Providers

import { Agent } from 'praisonai';

// OpenAI
const gptAgent = new Agent({
  instructions: "You are helpful",
  llm: "gpt-4o-mini"
});

// Anthropic Claude
const claudeAgent = new Agent({
  instructions: "You are helpful",
  llm: "anthropic/claude-3-5-sonnet"
});

// Google Gemini
const geminiAgent = new Agent({
  instructions: "You are helpful",
  llm: "google/gemini-2.0-flash"
});

How to Run

1. Create a TypeScript file

touch agent.ts

2. Add your code

import { Agent } from 'praisonai';

const agent = new Agent({ 
  instructions: "You are helpful" 
});

const response = await agent.chat("Hello!");
console.log(response);

3. Set your API key

export OPENAI_API_KEY="your-key-here"

4. Run with tsx or ts-node

npx tsx agent.ts

Key Features

• Simple API: One import, one class, one method
• Auto-schema: Pass functions directly as tools
• Multi-provider: OpenAI, Anthropic, Google support
• Persistence: SQLite, PostgreSQL, Redis adapters
• Memory: Semantic memory for context recall
• Workflows: Sequential, parallel, conditional flows
• TypeScript-first: Full type safety

Learn More

• GitHub Repository
• Documentation
• NPM Package

Using Knowledge Export/Import with PraisonAI Agents

PraisonAI Agents now support programmatic export and import of knowledge bases, enabling seamless backup and migration workflows in your AI applications.

Creating an Agent with Knowledge

from praisonaiagents import Agent

# Create agent with knowledge
agent = Agent(
    name='KnowledgeAgent',
    instructions='Answer questions based on the provided knowledge.',
    knowledge=['document.pdf', './docs/'],
    verbose=True
)

# Query the knowledge base
result = agent.start('What are the key features?')

Exporting Knowledge Programmatically

from praisonai.cli.features.knowledge import KnowledgeHandler

# Initialize handler
handler = KnowledgeHandler()

# Export knowledge base
handler.action_export(['backup.json'])

# Export with custom path
handler.action_export(['/backups/knowledge_2024.json'])

Importing Knowledge Programmatically

from praisonai.cli.features.knowledge import KnowledgeHandler

# Initialize handler
handler = KnowledgeHandler()

# Import knowledge base
handler.action_import(['backup.json'])

# Import from custom path
handler.action_import(['/backups/knowledge_2024.json'])

Complete Example: Backup and Restore

from praisonaiagents import Agent
from praisonai.cli.features.knowledge import KnowledgeHandler
import tempfile
import os

# Create agent with knowledge
doc_path = 'healthcare_guide.txt'
agent = Agent(
    name='HealthcareAgent',
    role='Healthcare AI Expert',
    knowledge=[doc_path],
    instructions='Provide accurate healthcare information.'
)

# Query before backup
result1 = agent.start('What are AI applications in healthcare?')

# Backup knowledge base
handler = KnowledgeHandler()
backup_file = 'knowledge_backup.json'
handler.action_export([backup_file])

# Later: Restore knowledge base
handler.action_import([backup_file])

# Verify restored knowledge
result2 = agent.start('What are AI applications in healthcare?')

# Cleanup
os.unlink(backup_file)

Key Features

• JSON format with version metadata
• Preserves document content and metadata
• Multi-agent safe with session support
• Works with all vector stores (Chroma, Qdrant, Pinecone, etc.)
• Automatic timestamped filenames

The export/import functionality integrates seamlessly with PraisonAI’s knowledge management system, supporting all retrieval strategies and rerankers.

Knowledge Export/Import CLI Commands

PraisonAI now supports exporting and importing knowledge bases via CLI commands, enabling easy backup, migration, and sharing of your RAG knowledge bases.

Export Knowledge Base

# Export to default timestamped file
praisonai knowledge export

# Export to specific file
praisonai knowledge export backup.json

# Export to specific path
praisonai knowledge export /path/to/knowledge_backup.json

Import Knowledge Base

# Import from JSON file
praisonai knowledge import backup.json

# Import from specific path
praisonai knowledge import /path/to/knowledge_backup.json

All Knowledge CLI Commands

praisonai knowledge add <source>        # Add documents
praisonai knowledge query "<question>"   # Query with RAG
praisonai knowledge list                 # List documents
praisonai knowledge clear                # Clear knowledge base
praisonai knowledge stats                # Show statistics
praisonai knowledge export <file.json>   # Export to JSON
praisonai knowledge import <file.json>   # Import from JSON
praisonai knowledge help                 # Show help

Use Cases

• Backup knowledge bases before updates
• Migrate knowledge between environments
• Share knowledge bases with team members
• Version control for RAG data
• Disaster recovery

The export format is JSON with version metadata, making it easy to track and manage your knowledge base snapshots.