​
Understanding Agents

Agents are the core building blocks of PraisonAI. Each agent is an autonomous AI entity with specific roles, goals, and capabilities.

​
Key Components

Role & Goal

Defines the agent’s purpose and objectives through role definition and specific goals

Capabilities

Tools and functions available to the agent for task execution

Memory

Context retention and learning capabilities across interactions

Language Model

The underlying AI model powering the agent’s intelligence

​
Component Details

​
Role and Goal

Clear role and goal definitions are crucial for optimal agent performance.

ComponentDescriptionExample
RoleAgent’s function and expertiseResearch Analyst, Code Developer
GoalSpecific objectives to achieveAnalyze market trends, Generate reports
BackstoryContextual backgroundExpert with 10 years of experience

​
Capabilities

agent = Agent(
    name="Researcher",
    role="Senior Research Analyst",
    goal="Uncover cutting-edge developments in AI",
    backstory="You are an expert at a technology research group",
    verbose=True,
    llm="gpt-4o",
    markdown=True
)
1

Install PraisonAI

Install the core package:

Terminal
pip install praisonaiagents
2

Configure Environment

Terminal
export OPENAI_API_KEY=your_openai_key

Generate your OpenAI API key from OpenAI Use other LLM providers like Ollama, Anthropic, Groq, Google, etc. Please refer to the Models for more information.

3

Create Agent

Create app.py:

from praisonaiagents import Agent

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

Start Agents

Execute your script:

Terminal
python app.py

You should see:

  • Agent initialization
  • Agents progress
  • Final results
  • Generated report

​
Agent Types

Basic Agent

Specialized Agent

Collaborative Agent

​
Best Practices

Always implement proper error handling and resource management in your agent configurations.

Agent Design

1

Role Definition

Define clear, specific roles for each agent

2

Goal Setting

Set specific, measurable goals

3

Tool Selection

Choose relevant tools for the task

4

Memory Setup

Configure appropriate memory settings

Agent Interaction

1

Communication

Establish clear communication protocols

2

Delegation

Define explicit delegation rules

3

Error Handling

Implement robust error handling

4

Resource Management

Set up efficient resource allocation

​
Async Capabilities

Key Features

async def main():
    agent = Agent(name="AsyncAgent")
    result = await agent.aprocess_task()
  • Full async/await support
  • Non-blocking operations
  • Enhanced performance

​
Advanced Features

Memory Management

  • Short-term conversation memory
  • Long-term knowledge retention
  • Context preservation

Tool Integration

  • Custom tool development
  • External API integration
  • Resource access control

​
Async Support

Agents now support asynchronous operations through the following methods:

  • achat: Async version of the chat method
  • astart: Async version of start method
  • aexecute_task: Async version of execute_task method
  • arun_task: Async version of run_task method
  • arun_all_tasks: Async version of run_all_tasks method

​
Example Usage:

import asyncio
from praisonaiagents import Agent, Task, PraisonAIAgents

async def main():
    # Create an async agent
    async_agent = Agent(
        name="AsyncAgent",
        role="Async Task Specialist",
        goal="Perform async operations",
        backstory="Expert in async operations",
        tools=[async_search_tool],  # Your async tool
        verbose=True
    )

    # Create an async task
    async_task = Task(
        description="Perform async operation",
        expected_output="Async result",
        agent=async_agent,
        async_execution=True  # Enable async execution
    )

    # Create and start agents with async support
    agents = PraisonAIAgents(
        agents=[async_agent],
        tasks=[async_task],
        verbose=True
    )
    
    # Start async execution
    result = await agents.astart()
    print(result)

# Run the async main function
if __name__ == "__main__":
    asyncio.run(main())

​
Key Features:

  • Full async/await support
  • Parallel task execution
  • Async tool integration
  • Async callback support
  • Mixed sync/async operations

​
Next Steps

Create Your First Agent

Follow our quickstart guide to create your first agent

API Reference

Explore the complete Agent API documentation