PraisonAI

https://docs.praison.ai
Admin
PraisonAI is a production-ready, low-code framework for building and managing self-reflecting...
Tokens:3,662,151
Snippets:46,596
Trust Score:6.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Quick Start Example

Source: https://docs.praison.ai/docs/features/file-snapshot

A basic example demonstrating how to initialize FileSnapshot, track changes, get diffs, and restore files.

```APIDOC
from praisonaiagents.snapshot import FileSnapshot

# Initialize for a project directory
snapshot = FileSnapshot("/path/to/project")

# Track current state
info = snapshot.track(message="Initial state")
print(f"Snapshot: {info.commit_hash[:8]}")

# Make changes to files...

# Get diff from snapshot
diffs = snapshot.diff(info.commit_hash)
for d in diffs:
    print(f"{d.status}: {d.path}")

# Restore to snapshot
snapshot.restore(info.commit_hash)
```

--------------------------------

### Default Secure Setup Example

Source: https://docs.praison.ai/docs/features/api-server-auth

This command starts the API server with default secure settings, including authentication enabled.

```bash
# Default secure setup
praisonai deploy run --type api

```

--------------------------------

### Quick Start Examples

Source: https://docs.praison.ai/docs/cli/serve

Examples demonstrating how to start the agents server and the unified server, including legacy syntax.

```APIDOC
```
# Agents server
praisonai serve agents --file agents.yaml --port 8000

# Unified server (all providers)
praisonai serve unified --port 8765

# Legacy syntax (still supported)
praisonai serve agents.yaml

```
```

--------------------------------

### Quick Start Training Example

Source: https://docs.praison.ai/docs/sdk/praisonai/train

A concise example demonstrating how to initialize the Trainer with a model and training data, then start the fine-tuning process.

```python
from praisonai.train import Trainer

# Create trainer
trainer = Trainer(
    model="gpt-4o-mini",
    training_data="training_data.jsonl"
)

# Start training
result = trainer.train()
print(f"Fine-tuned model: {result.model_id}")
```

--------------------------------

### CLI Quickstart

Source: https://docs.praison.ai/docs/examples/agent-recipes/documents/ai-meeting-summarizer

Install the praisonai library and run the ai-meeting-summarizer recipe using the CLI. Examples include basic usage, using an input file, and specifying an output directory.

```APIDOC
## CLI Quickstart

```bash
# Install
pip install praisonai praisonai-tools

# Run the tool
praisonai recipe run ai-meeting-summarizer \
  --input '{"input": "your-input-here"}' \
  --json

# With output directory
praisonai recipe run ai-meeting-summarizer \
  --input-file config.json \
  --out-dir ./output
```

**Output:**
```json
{
  "ok": true,
  "run_id": "run_abc123",
  "recipe": "ai-meeting-summarizer",
  "output": {},
  "artifacts": [],
  "warnings": [],
  "error": null
}
```
```

--------------------------------

### AgentTeam Initialization and Quick Start

Source: https://docs.praison.ai/docs/sdk/praisonaiagents/agents/agents

Demonstrates how to initialize an AgentTeam with agents and start the execution. This is a basic example to get started with multi-agent systems.

```APIDOC
## AgentTeam Initialization

### Description
Initialize an AgentTeam with a list of agents and optional tasks. The `start()` method initiates the agent execution.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from praisonaiagents import Agent, AgentTeam

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

agents = AgentTeam(agents=[researcher, writer], memory=True)
result = agents.start()
```

### Response
#### Success Response (200)
- **result** (any) - The outcome of the agent team's execution.

#### Response Example
```json
{
  "example": "Execution result"
}
```
```

--------------------------------

### Initialize and Start an Agent

Source: https://docs.praison.ai/api/praisonaiagents/agent/agent

Quick start example demonstrating how to initialize an Agent with instructions and start a conversation.

```python
from praisonaiagents import Agent

agent = Agent(instructions="You are a helpful assistant")
response = agent.start("Hello!")

```

--------------------------------

### Install and Setup

Source: https://docs.praison.ai/docs/features/platform/sdk-client

Instructions on how to install the praisonai-platform SDK and create an instance of the PlatformClient.

```APIDOC
## Install and Setup

Install the platform SDK and create a client instance:

```python
# Install
pip install praisonai-platform

# Create client
import asyncio
from praisonai_platform.client import PlatformClient

client = PlatformClient("http://localhost:8000")
```
```

--------------------------------

### Quick Example: Schedule and Start Deployment

Source: https://docs.praison.ai/docs/sdk/praisonai/scheduler

Instantiate DeploymentScheduler, schedule a deployment every hour, and start the scheduler.

```python
from praisonai.scheduler import DeploymentScheduler

# Create scheduler
scheduler = DeploymentScheduler()

# Schedule deployment every hour
scheduler.schedule(interval_minutes=60)

# Start the scheduler
scheduler.start()
```

--------------------------------

### Install and Start Unified Server (CLI)

Source: https://docs.praison.ai/docs/deploy/servers/unified

Install the necessary PraisonAI package and set your API key. Then, start the unified server on a specified port.

```bash
pip install "praisonai[serve]"
export OPENAI_API_KEY="your-key"

# Start unified server
praisonai serve unified --port 8765

```

--------------------------------

### CLI Quick Start

Source: https://docs.praison.ai/docs/cli/sandbox-execution

Examples of enabling different sandbox modes directly from the CLI.

```APIDOC
## CLI Quick Start

```bash
# Enable basic sandbox
praisonai "Run the tests" --sandbox basic

# Strict sandbox (more restrictions)
praisonai "Build the project" --sandbox strict

# Network isolated
praisonai "Process local files" --sandbox network-isolated
```
```

--------------------------------

### Quick Start Example

Source: https://docs.praison.ai/docs/features/workflow-routing

A practical example demonstrating how to set up a workflow with routing to handle different types of user requests based on keywords.

```APIDOC
## Quick Start
```python
from praisonaiagents import AgentFlow, WorkflowContext, StepResult
from praisonaiagents import route

# Decision maker - determines which route to take
def classify_request(ctx: WorkflowContext) -> StepResult:
    input_lower = ctx.input.lower()
    if "urgent" in input_lower:
        return StepResult(output="priority: high")
    elif "question" in input_lower:
        return StepResult(output="priority: support")
    return StepResult(output="priority: normal")

# Route handlers
def handle_high(ctx: WorkflowContext) -> StepResult:
    return StepResult(output="🚨 Escalating to senior team!")

def handle_support(ctx: WorkflowContext) -> StepResult:
    return StepResult(output="💬 Routing to help desk")

def handle_normal(ctx: WorkflowContext) -> StepResult:
    return StepResult(output="📋 Added to queue")

# Create workflow with routing
workflow = AgentFlow(steps=[
    classify_request,
    route({
        "high": [handle_high],
        "support": [handle_support],
        "normal": [handle_normal],
        "default": [handle_normal]
    })
])

result = workflow.start("This is URGENT!", )
print(result["output"])  # "🚨 Escalating to senior team!"

```
```

--------------------------------

### Quick Start Examples

Source: https://docs.praison.ai/docs/cli/recipe-security

Quick examples for common recipe security operations.

```APIDOC
## Quick Start
```bash
# Generate SBOM
praisonai recipe sbom ./my-recipe -o sbom.json

# Audit dependencies
praisonai recipe audit ./my-recipe

# Sign a bundle
praisonai recipe sign my-recipe.praison --key private.pem

# Verify signature
praisonai recipe verify my-recipe.praison --key public.pem
```
```

--------------------------------

### Install and Start MCP Server

Source: https://docs.praison.ai/docs/deploy/servers/tools-mcp

Install the necessary package and start the MCP server with various configuration options.

```APIDOC
## Install MCP Package
```bash
pip install "praisonaiagents[mcp]"
```

## Start MCP Server
```bash
# Start MCP server with default settings
praisonai serve mcp --transport sse --port 8080

# Start with a specific server name
praisonai serve mcp --name my-server --transport sse --port 8080
```

### Server Options

| Option | Default | Description |
|---|---|---|
| `--host` | `127.0.0.1` | Host to bind to |
| `--port` | `8080` | Server port |
| `--transport` | `stdio` | Transport type: `stdio` or `sse` |
| `--name` | - | Server name from config |
```

--------------------------------

### Quick Start Example

Source: https://docs.praison.ai/features/workflow-routing

A practical example demonstrating how to use the `route` function to classify requests and route them to different handlers.

```APIDOC
```python
from praisonaiagents import AgentFlow, WorkflowContext, StepResult
from praisonaiagents import route

# Decision maker - determines which route to take
def classify_request(ctx: WorkflowContext) -> StepResult:
    input_lower = ctx.input.lower()
    if "urgent" in input_lower:
        return StepResult(output="priority: high")
    elif "question" in input_lower:
        return StepResult(output="priority: support")
    return StepResult(output="priority: normal")

# Route handlers
def handle_high(ctx: WorkflowContext) -> StepResult:
    return StepResult(output="🚨 Escalating to senior team!")

def handle_support(ctx: WorkflowContext) -> StepResult:
    return StepResult(output="💬 Routing to help desk")

def handle_normal(ctx: WorkflowContext) -> StepResult:
    return StepResult(output="📋 Added to queue")

# Create workflow with routing
workflow = AgentFlow(steps=[
    classify_request,
    route({
        "high": [handle_high],
        "support": [handle_support],
        "normal": [handle_normal],
        "default": [handle_normal]
    })
])

result = workflow.start("This is URGENT!", )
print(result["output"])  # "🚨 Escalating to senior team!"

```
```

--------------------------------

### Production Mode Example

Source: https://docs.praison.ai/docs/cli/recipe-serve

Example command for starting the server in production mode with authentication and preloading.

```APIDOC
### Production Mode

```
# Production with auth and preloading
praisonai serve recipe \
  --host 0.0.0.0 \
  --port 8000 \
  --auth api-key \
  --preload
```
```

--------------------------------

### CLI Installation and Server Start

Source: https://docs.praison.ai/docs/deploy/servers/unified

Install the necessary package and start the unified server using the CLI. This command launches a server that aggregates all PraisonAI providers.

```APIDOC
## CLI
```
pip install "praisonai[serve]"
export OPENAI_API_KEY="your-key"

# Start unified server
praisonai serve unified --port 8765

```

**Expected Output:**
```
🚀 Starting Unified PraisonAI Server...
   Host: 127.0.0.1
   Port: 8765
   Providers: agents-api, recipe, mcp, a2a, a2u
📡 Discovery: http://127.0.0.1:8765/__praisonai__/discovery
✅ Server started at http://127.0.0.1:8765

```
```

--------------------------------

### Install and Start AGUI Server via CLI

Source: https://docs.praison.ai/docs/deploy/agui-server

Install the necessary package and start the AGUI/A2U server using the CLI. Ensure your OpenAI API key is exported.

```bash
pip install "praisonaiagents[os]"
export OPENAI_API_KEY="your-key"

# Start AGUI/A2U server
praisonai serve a2u --port 8002

```

--------------------------------

### Quick Start Example

Source: https://docs.praison.ai/features/workflow-repeat

A basic example demonstrating how to use the `repeat` function to generate content iteratively until a condition is met.

```APIDOC
```python
from praisonaiagents import AgentFlow, WorkflowContext, StepResult
from praisonaiagents import repeat

# Generator that improves each iteration
class ContentGenerator:
    def __init__(self):
        self.points = []
    
    def generate(self, ctx: WorkflowContext) -> StepResult:
        self.points.append(f"Point {len(self.points) + 1}")
        return StepResult(
            output=f"Generated {len(self.points)} points",
            variables={"point_count": len(self.points)}
        )

# Condition: stop when we have enough
def has_enough(ctx: WorkflowContext) -> bool:
    return ctx.variables.get("point_count", 0) >= 5

generator = ContentGenerator()

workflow = AgentFlow(steps=[
    repeat(generator.generate, until=has_enough, max_iterations=10)
])

result = workflow.start("Generate content")
```
```

--------------------------------

### Complete Callback System Example

Source: https://docs.praison.ai/docs/features/callbacks

A comprehensive example demonstrating the setup of logging, definition, and registration of interaction, error, and tool call callbacks. It also includes agent and task setup for a complete PraisonAI application.

```python
from praisonaiagents import Agent, Task, AgentTeam, register_display_callback
import logging
from datetime import datetime

# Setup logging
logging.basicConfig(
    filename='ai_interactions.log',
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

# Interaction callback
def interaction_callback(message=None, response=None, markdown=None, generation_time=None):
    logging.info(f"""
    === INTERACTION ===
    Time: {datetime.now()}
    Generation Time: {generation_time}s
    Message: {message}
    Response: {response}
    Markdown: {markdown}
    """)

# Error callback
def error_callback(message=None):
    logging.error(f"""
    === ERROR ===
    Time: {datetime.now()}
    Message: {message}
    """)

# Tool call callback
def tool_call_callback(message=None):
    logging.info(f"""
    === TOOL CALL ===
    Time: {datetime.now()}
    Message: {message}
    """)

# Register callbacks
register_display_callback('interaction', interaction_callback)
register_display_callback('error', error_callback)
register_display_callback('tool_call', tool_call_callback)

agent = Agent(
    name="CallbackAgent",
    role="Assistant",
    goal="Demonstrate callbacks",
    backstory="I am a helpful assistant",
    
)

task = Task(
    name="callback_task",
    description="Show how callbacks work",
    agent=agent,
    expected_output="Demonstration complete"
)

agents = AgentTeam(
    agents=[agent],
    tasks=[task],
    
)

agents.start()
```

--------------------------------

### Install Praison AI with pip

Source: https://docs.praison.ai/docs/index

Install the Praison AI package with all extras using pip. After installation, run the onboard command to start the guided setup.

```bash
pip install "praisonai[all]"
praisonai onboard
```

--------------------------------

### Quick Start Example

Source: https://docs.praison.ai/docs/features/dynamic-context-discovery

Demonstrates how to set up dynamic context and use it with an Agent to handle large tool outputs.

```APIDOC
## Quick Start
```python
from praisonaiagents import Agent
from praisonai.context import setup_dynamic_context

ctx = setup_dynamic_context()

agent = Agent(
    instructions="You are a data analyst.",
    tools=ctx.get_tools(),
    hooks=[ctx.get_middleware()],
)

response = agent.chat("Fetch and analyze the large dataset")
```

**What happens:**
  * Large tool outputs (>32KB) are automatically saved as artifacts
  * Agent receives compact references instead of flooding context
  * Agent can use `artifact_tail`, `artifact_grep` to explore data on-demand
```

--------------------------------

### Quick Start: Initialize AgentTeam

Source: https://docs.praison.ai/docs/sdk/praisonaiagents/agents/agents

Initialize an AgentTeam with a list of agents and enable memory. This is a basic setup to get started with agent orchestration.

```python
from praisonaiagents import Agent, AgentTeam

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

agents = AgentTeam(agents=[researcher, writer], memory=True)
result = agents.start()

```

--------------------------------

### Quick Start: Create Plan and Todo List

Source: https://docs.praison.ai/docs/sdk/typescript/planning

Demonstrates the basic usage of creating a plan with steps and a todo list with items. Ensure 'praisonai' is installed.

```typescript
import { createPlan, createTodoList, TodoItem } from 'praisonai';

// Create a plan
const plan = createPlan({
  name: 'My Project',
  description: 'Build an AI application'
});

// Add steps
plan.addStep({ description: 'Design architecture' });
plan.addStep({ description: 'Implement core features' });
plan.addStep({ description: 'Write tests' });

// Create todo list
const todos = createTodoList('Tasks');
todos.add(new TodoItem({ content: 'Complete documentation' }));
todos.add(new TodoItem({ content: 'Review code', priority: 'high' }));

```

--------------------------------

### TelegramBot Implementation Example

Source: https://docs.praison.ai/docs/sdk/reference/praisonaiagents/classes/BotProtocol

Example of how to implement and start a Telegram bot using the BotProtocol. Ensure you have the praisonai library installed and replace '...' with your actual bot token.

```python
from praisonai.bots import TelegramBot
bot = TelegramBot(token="…", agent=my_agent)
await bot.start()
```

--------------------------------

### Setup Platform Agent Workflow

Source: https://docs.praison.ai/docs/features/platform/sdk-client

This example demonstrates registering a user, creating a workspace and project, and then setting up a platform agent. It shows how to integrate the PlatformClient with the Agent class.

```python
from praisonaiagents import Agent
from praisonai_platform.client import PlatformClient

async def setup_platform_agent():
    # Initialize platform client
    client = PlatformClient("http://localhost:8000")
    
    # Register and authenticate
    await client.register("agent@company.com", "password", "Platform Agent")
    
    # Create workspace and project
    ws = await client.create_workspace("AI Team")
    project = await client.create_project(ws["id"], "Backend Tasks")
    
    # Register agent
    agent_info = await client.create_agent(
        ws["id"], "CodeBot",
        runtime_mode="local",
        instructions="Handle platform issues automatically"
    )
    
    # Create agent instance that uses platform client
    agent = Agent(
        name="PlatformAgent",
        instructions="Monitor and handle platform issues",
        platform_client=client,
        workspace_id=ws["id"]
    )
    
    return agent, client, ws["id"]

asyncio.run(setup_platform_agent())

```

--------------------------------

### Quick Start Embedding Generation

Source: https://docs.praison.ai/docs/capabilities/embeddings

A simple example to get started with generating embeddings for a single piece of text. It shows how to import the function and print the dimensions of the resulting embedding vector.

```python
from praisonaiagents import embedding

result = embedding("Hello, world!")
print(f"Dimensions: {len(result.embeddings[0])}")  # 1536

```

--------------------------------

### Basic YAML Processing Agent Setup

Source: https://docs.praison.ai/docs/tools/yaml_tools

A complete example demonstrating the setup and execution of a single YAML processing agent and task.

```python
from praisonaiagents import Agent, Task, AgentTeam
from praisonai_tools import read_yaml, write_yaml, validate_yaml, merge_yaml, convert_yaml

# Create YAML agent
yaml_agent = Agent(
    name="YAMLExpert",
    role="YAML Processing Specialist",
    goal="Process YAML files efficiently and accurately.",
    backstory="Expert in YAML file handling and validation.",
    tools=[read_yaml, write_yaml, validate_yaml, merge_yaml, convert_yaml],
    reflection=False
)

# Define YAML task
yaml_task = Task(
    description="Parse and validate configuration files.",
    expected_output="Processed and validated YAML data.",
    agent=yaml_agent,
    name="config_processing"
)

# Run agent
agents = AgentTeam(
    agents=[yaml_agent],
    tasks=[yaml_task],
    process="sequential"
)
agents.start()

```

--------------------------------

### ngrok Tunnel Setup

Source: https://docs.praison.ai/docs/cli/n8n

Instructions for installing and starting an ngrok tunnel to expose a local PraisonAI API for quick testing.

```bash
# Install
brew install ngrok

# Auth (one-time)
ngrok config add-authtoken <YOUR_TOKEN>

# Start tunnel
ngrok http 8005
# Output: https://abc123.ngrok-free.app
```

```bash
praisonai agents.yaml --n8n --api-url https://abc123.ngrok-free.app
```

--------------------------------

### Initialize Agent with Helicone LLM

Source: https://docs.praison.ai/docs/js/providers/helicone-code

Quick start example demonstrating how to initialize an Agent with the Helicone provider for LLM integration. Ensure the 'praisonai' package is installed.

```javascript
import { Agent } from 'praisonai';

const agent = new Agent({
  name: 'HeliconeAgent',
  instructions: 'You are a helpful assistant.',
  llm: 'helicone/openai/gpt-4o'
});

```

--------------------------------

### AgentOS Quick Start

Source: https://docs.praison.ai/docs/concepts/agentos

Install AgentOS and run a basic application with a single agent.

```APIDOC
## Installation
```
pip install praisonai[os]
```

## Python Code
```python
from praisonai import AgentOS
from praisonaiagents import Agent

app = AgentOS(agents=[
    Agent(instructions="You are a helpful assistant")
])
app.serve(port=8080)
```

## CLI
```bash
praisonai app --port 8080
```
```

--------------------------------

### Basic Process Setup and Sequential Execution

Source: https://docs.praison.ai/api/praisonaiagents/process/process

Demonstrates the creation of agents, tasks, and a process, followed by sequential execution. This is the foundational example for setting up and running tasks in order.

```python
from praisonaiagents import Agent, Task, Process

# Create agents
researcher = Agent(role="Researcher", goal="Find information")
writer = Agent(role="Writer", goal="Create content")

# Create tasks
task1 = Task(description="Research topic", agent=researcher)
task2 = Task(description="Write article", agent=writer, context=[task1])

# Create and run process
process = Process(
    tasks={"research": task1, "write": task2},
    agents=[researcher, writer]
)

# Execute sequentially
process.sequential()

```

--------------------------------

### Quick Start: Initialize Agent with OpenRouter

Source: https://docs.praison.ai/docs/js/providers/openrouter-code

Initialize an agent using the OpenRouter provider and specify a model. This example demonstrates basic setup for chat interactions.

```javascript
import { Agent } from 'praisonai';

const agent = new Agent({
  name: 'RouterAgent',
  instructions: 'You are a helpful assistant.',
  llm: 'openrouter/anthropic/claude-3-sonnet'
});

const response = await agent.chat('Hello!');

```

--------------------------------

### Quick Start: Initialize Weave Observability and Agent

Source: https://docs.praison.ai/docs/js/observability/weave-code

This example demonstrates how to initialize the Weave observability adapter and set it for the Praison AI agent. Ensure you have the 'praisonai' package installed.

```javascript
import { Agent, setObservabilityAdapter } from 'praisonai';
import { createObservabilityAdapter } from 'praisonai/observability';

const obs = await createObservabilityAdapter('weave');
setObservabilityAdapter(obs);

const agent = new Agent({
  name: 'TracedAgent',
  instructions: 'You are helpful.',
  llm: 'openai/gpt-4o-mini'
});

await agent.chat('Hello!');
await obs.flush();

```

--------------------------------

### Initialize HackerNewsTool and Get Top Stories

Source: https://docs.praison.ai/docs/tools/external/hackernews

Quick start example demonstrating how to initialize the HackerNewsTool and fetch the top stories. The `limit` parameter controls the number of stories returned.

```python
from praisonai_tools import HackerNewsTool

# Initialize
hn = HackerNewsTool()

# Get top stories
stories = hn.get_top_stories(limit=5)
print(stories)
```

--------------------------------

### Quick Start: File Snapshot Operations

Source: https://docs.praison.ai/docs/features/file-snapshot

Initialize FileSnapshot, track the initial state, get diffs, and restore to a snapshot. Assumes Praison AI Agents library is installed.

```python
from praisonaiagents.snapshot import FileSnapshot

# Initialize for a project directory
snapshot = FileSnapshot("/path/to/project")

# Track current state
info = snapshot.track(message="Initial state")
print(f"Snapshot: {info.commit_hash[:8]}")

# Make changes to files...

# Get diff from snapshot
diffs = snapshot.diff(info.commit_hash)
for d in diffs:
    print(f"{d.status}: {d.path}")

# Restore to snapshot
snapshot.restore(info.commit_hash)

```

--------------------------------

### start()

Source: https://docs.praison.ai/docs/sdk/reference/praisonaiagents/classes/SandboxProtocol

Initializes and starts the sandbox environment.

```APIDOC
## start()

### Description
Starts or initializes the sandbox environment.

### Method
(Implicitly a method call on a SandboxProtocol instance)

### Parameters
None

### Response
None (or potentially a status indicator).
```

--------------------------------

### Quick Start: Initialize and Chat with Letta Agent

Source: https://docs.praison.ai/docs/js/providers/letta-code

This example demonstrates how to initialize an agent using the Letta LLM and send a chat message. Ensure the 'praisonai' SDK is installed and imported.

```javascript
import { Agent } from 'praisonai';

const agent = new Agent({
  name: 'LettaAgent',
  instructions: 'You are a helpful assistant.',
  llm: 'letta/model'
});

const response = await agent.chat('Hello!');

```

--------------------------------

### Set Up PostgreSQL for Production

Source: https://docs.praison.ai/docs/features/platform/data-model

Install the `asyncpg` driver, set the `DATABASE_URL` environment variable, and initialize the database tables. This prepares the platform for production use with PostgreSQL.

```bash
# 1. Install driver
pip install asyncpg

# 2. Set database URL
export DATABASE_URL="postgresql+asyncpg://user:password@localhost/platform"

# 3. Initialize tables
python -c "import asyncio; from praisonai_platform.db import init_db; asyncio.run(init_db())"

# 4. Start platform server
python -m praisonai_platform
```

--------------------------------

### Quick Start with Valyu Tools

Source: https://docs.praison.ai/docs/js/tools/valyu

Initialize an Agent with Valyu finance and SEC search tools to analyze financial data. This example demonstrates basic agent setup and tool integration.

```javascript
import { Agent } from 'praisonai';
import { valyuFinanceSearch, valyuSecSearch } from 'praisonai/tools';

const agent = new Agent({
  name: 'FinanceAnalyst',
  instructions: 'You analyze financial data and SEC filings.',
  tools: [valyuFinanceSearch(), valyuSecSearch()],
});

const result = await agent.run('What is Apple\'s latest quarterly revenue?');
console.log(result.text);

```

--------------------------------

### Quick Start: Create and Use a Router

Source: https://docs.praison.ai/docs/sdk/typescript/router-agent

Demonstrates the basic setup for creating a router with multiple routes and conditions, and then using it to route a request.

```typescript
import { RouterAgent, createRouter } from 'praisonai';

const router = createRouter({
  routes: [
    { agent: codeAgent, condition: (input) => input.includes('code') },
    { agent: mathAgent, condition: (input) => input.includes('calculate') },
    { agent: generalAgent, condition: () => true }
  ]
});

const result = await router.route('Help me debug this code');

```

--------------------------------

### Quick Start Agent with Airweave Search

Source: https://docs.praison.ai/docs/js/tools/airweave

Initialize an agent with the airweaveSearch tool to enable searching across connected data sources. This example demonstrates a basic setup for finding documents.

```javascript
import { Agent } from 'praisonai';
import { airweaveSearch } from 'praisonai/tools';

const agent = new Agent({
  name: 'DataSearcher',
  instructions: 'Search across connected data sources.',
  tools: [airweaveSearch()],
});

const result = await agent.run('Find documents about Q4 planning');
console.log(result.text);

```

--------------------------------

### Quickstart: Create a Simple Agent

Source: https://docs.praison.ai/docs/js/agent

Initialize a basic agent with instructions and send a message.

```typescript
import { Agent } from 'praisonai';

// 3 lines - Hello Agent
const agent = new Agent({ instructions: "You are a helpful assistant" });
const response = await agent.chat("Hello!");
console.log(response);

```

--------------------------------

### Install and Start Windows Service

Source: https://docs.praison.ai/docs/guides/deployment/production-minimal

Commands to install, start, check the status, and configure the PraisonAI Windows service to start automatically.

```bash
# Install service (run as Administrator)
python C:\PraisonAI\praisonai_service.py install

# Start service
python C:\PraisonAI\praisonai_service.py start

# Check status
sc query PraisonAI

# Set to start automatically
sc config PraisonAI start=auto
```

--------------------------------

### Enable AutoMemory Extraction

Source: https://docs.praison.ai/docs/features/advanced-memory

Quick start for enabling AutoMemory, which automatically extracts structured information from conversations based on configurable patterns. This example shows basic agent setup with auto-memory enabled.

```python
from praisonaiagents import Agent, MemoryConfig

# Enable auto-memory extraction
agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant.",
    memory=MemoryConfig(auto_memory=True, user_id="user123")
)

# Patterns are extracted automatically from conversation
agent.start("I prefer Python for data science and I'm based in London")
# AutoMemory stores: preference="Python for data science", location="London"
```

--------------------------------

### Quick Example: Create and Use ContextAgent

Source: https://docs.praison.ai/docs/sdk/praisonaiagents/agent/context_agent

Demonstrates how to create a ContextAgent instance, analyze a codebase, and generate a Product Requirements Prompt (PRP) for a new feature.

```python
from praisonaiagents import create_context_agent

# Create context agent
agent = create_context_agent(
    llm="gpt-4o-mini",
    name="Context Engineer"
)

# Analyze a codebase
analysis = agent.analyze_codebase_with_gitingest("/path/to/project")

# Generate PRP for a feature
prp = agent.generate_comprehensive_prp(
    feature_request="Add user authentication with OAuth2",
    context_analysis=analysis
)

print(prp)
```

--------------------------------

### Run All Examples

Source: https://docs.praison.ai/docs/cli/examples

Execute all Python examples in the default 'examples/' directory.

```bash
praisonai examples run
```

--------------------------------

### Complete Workflow Example

Source: https://docs.praison.ai/docs/sdk/praisonai/cli/scheduler-cli

Demonstrates starting a scheduler for a recipe with specified interval and cost limit as part of a complete workflow.

```bash
# 1. Start a recipe scheduler
praisonai schedule start news-monitor \
    --recipe news-analyzer \
    --interval hourly \
    --max-cost 0.50

```

--------------------------------

### List Examples with Metadata

Source: https://docs.praison.ai/docs/cli/examples

Discover and list examples, including their parsed metadata such as timeout and required environment variables.

```bash
praisonai examples list --metadata
```

--------------------------------

### Exa Search Quick Start with Praison AI Agent

Source: https://docs.praison.ai/docs/js/tools/exa

Integrate the Exa search tool into a Praison AI agent for web research. This example demonstrates a basic agent setup for finding information on the web.

```javascript
import { Agent } from 'praisonai';
import { exaSearch } from 'praisonai/tools';

const agent = new Agent({
  name: 'WebResearcher',
  instructions: 'You are a research assistant that searches the web for information.',
  tools: [exaSearch()],
});

const result = await agent.run('Find the latest AI developments in Europe');
console.log(result.text);

```

--------------------------------

### Quick Start Arize Observability

Source: https://docs.praison.ai/docs/js/observability/arize-code

Integrate Arize observability into your Praison AI agent. Ensure you have the 'praisonai' package installed. This example shows how to create an adapter, set it for observability, and trace an agent's chat interaction.

```javascript
import { Agent, setObservabilityAdapter } from 'praisonai';
import { createObservabilityAdapter } from 'praisonai/observability';

const obs = await createObservabilityAdapter('arize');
setObservabilityAdapter(obs);

const agent = new Agent({
  name: 'TracedAgent',
  instructions: 'You are helpful.',
  llm: 'openai/gpt-4o-mini'
});

await agent.chat('Hello!');
await obs.flush();

```

--------------------------------

### start()

Source: https://docs.praison.ai/docs/sdk/reference/praisonai/classes/DeploymentScheduler

Initiates the scheduled deployment process.

```APIDOC
## start()

### Description

Start scheduled deployment.

### Method

`start()`
```

--------------------------------

### Quick Start Agent Initialization and Usage

Source: https://docs.praison.ai/api/praisonaiagents/index

Initialize an Agent with instructions and start an interaction. This is the recommended way to begin using the SDK.

```python
from praisonaiagents import Agent

agent = Agent(instructions="You are a helpful assistant")
response = agent.start("Hello!")
print(response)
```

--------------------------------

### Gateway Daemon Not Installed Status Output

Source: https://docs.praison.ai/docs/features/gateway-cli

Example output when the Gateway daemon service is not installed on the system. This example specifically queries for daemon status.

```bash
$ praisonai gateway status --daemon-only
Daemon service: Not installed (systemd)


```

--------------------------------

### AgentAppProtocol::start

Source: https://docs.praison.ai/llms.txt

Starts the application.

```APIDOC
## AgentAppProtocol::start

### Description
Start the application.

### Method
(Not specified)

### Parameters
(No parameters specified)

### Response
(Not specified)
```

--------------------------------

### AgentServer Quick Start

Source: https://docs.praison.ai/docs/features/agent-server

Demonstrates how to initialize, start, broadcast messages, and stop the AgentServer.

```APIDOC
## AgentServer Quick Start

```python
from praisonaiagents.server import AgentServer, ServerConfig

# Create server with custom config
config = ServerConfig(
    host="0.0.0.0",
    port=8080,
    cors_origins=["http://localhost:3000"]
)

server = AgentServer(config=config)

# Start server (non-blocking)
server.start()

# Broadcast events to connected clients
server.broadcast("message", {"text": "Hello clients!"})

# Stop server
server.stop()
```
```

--------------------------------

### GatewayProtocol.start

Source: https://docs.praison.ai/llms.txt

Starts the gateway server.

```APIDOC
## start

### Description
Start the gateway server.

### Method
Function

### Endpoint
N/A (SDK function)

### Parameters
None explicitly documented.

### Request Example
```python
gateway.start()
```

### Response
None explicitly documented.
```

--------------------------------

### Start Scheduler

Source: https://docs.praison.ai/llms.txt

Starts the scheduled deployment.

```APIDOC
## Start Scheduler

### Description
Start scheduled deployment.

### Method
POST

### Endpoint
/scheduler/start
```

--------------------------------

### Install PraisonAI and Start Unified Server

Source: https://docs.praison.ai/docs/deploy/api

Install PraisonAI with serving dependencies and start the unified server. Ensure your API key is set as an environment variable.

```bash
# Install with serve dependencies
pip install "praisonai[serve]"

# Set your API key
export OPENAI_API_KEY="your-key"

# Start the unified server
praisonai serve unified --host 127.0.0.1 --port 8765

```

--------------------------------

### start()

Source: https://docs.praison.ai/docs/sdk/reference/praisonaiagents/classes/AutoAgents

Creates tasks based on the instructions, then starts execution.

```APIDOC
## start()

### Description

Creates tasks based on the instructions, then starts execution.

### Method

`start()`
```

--------------------------------

### GatewayProtocol::start

Source: https://docs.praison.ai/llms.txt

Starts the gateway server.

```APIDOC
## start

### Description
Start the gateway server.

### Method
Not specified (SDK function)

### Endpoint
Not specified (SDK function)

### Parameters
None explicitly documented.

### Request Example
None provided.

### Response
None explicitly documented.
```

--------------------------------

### Quick Start: Simple Import and Client Initialization

Source: https://docs.praison.ai/docs/features/platform-python-sdk

Import necessary components and initialize the PlatformClient for basic API interaction. Use an async context manager for proper client cleanup.

```python
from praisonai_platform import PlatformClient, create_app

# Create FastAPI app
app = create_app()

# Use HTTP client
async with PlatformClient("http://localhost:8000") as client:
    await client.register("user@example.com", "password")

```

--------------------------------

### Example: Show Project Overview Doc

Source: https://docs.praison.ai/docs/cli/docs

An example of showing the 'project-overview' documentation entry.

```bash
praisonai docs show project-overview
```

--------------------------------

### Install and Start A2A Server via CLI

Source: https://docs.praison.ai/docs/deploy/a2a-server

Install the necessary package and start the A2A server using the CLI. Ensure your OpenAI API key is exported.

```bash
pip install "praisonaiagents[os]"
export OPENAI_API_KEY="your-key"

# Start A2A server
praisonai serve a2a --port 8001

```

--------------------------------

### AgentOSProtocol Serve

Source: https://docs.praison.ai/llms.txt

Starts the AgentApp server.

```APIDOC
## AgentOSProtocol serve

### Description
Start the AgentApp server.

### Method
Not specified (assumed SDK method call)

### Endpoint
Not applicable (SDK function)

### Parameters
None specified.
```

--------------------------------

### Agent Initialization Example

Source: https://docs.praison.ai/docs/guides/recipes/personas/recipe-author

Demonstrates how to initialize an Agent instance with core parameters like name, role, goal, LLM, and tools.

```python
from praisonaiagents import Agent

Agent(
    name="Agent Name",
    role="Role Description",
    goal="What agent aims to do",
    instructions="...",
    llm="gpt-4o-mini",
    tools=[],
                       # Enable verbose output
    reflection=False,
    max_iterations=3,
    min_iterations=1,
)
```

--------------------------------

### Agent Start

Source: https://docs.praison.ai/llms.txt

Starts the agent interactively with verbose output.

```APIDOC
## Agent start

### Description
Start the agent interactively with verbose output.

### Method
Not specified (assumed SDK method call)

### Endpoint
Not applicable (SDK function)

### Parameters
None specified.
```

--------------------------------

### Quick Example: Load, Store, and Retrieve Documents

Source: https://docs.praison.ai/docs/sdk/praisonai/adapters

A quick example demonstrating the basic workflow: loading documents using AutoReader, storing them in ChromaVectorStore with embeddings, and setting up a BasicRetriever for querying.

```python
from praisonai.adapters import AutoReader, ChromaVectorStore, BasicRetriever

# Load documents
reader = AutoReader()
docs = reader.load("./documents/")

# Store in vector database
store = ChromaVectorStore(namespace="my_docs")
store.add(
    texts=[d.content for d in docs],
    embeddings=get_embeddings([d.content for d in docs]),
    metadatas=[d.metadata for d in docs]
)

# Retrieve
retriever = BasicRetriever(
    vector_store=store,
    embedding_fn=get_embedding
)
results = retriever.retrieve("search query", top_k=5)

```

--------------------------------

### Example Configuration File

Source: https://docs.praison.ai/docs/cli/config

An example of the `config.yaml` file structure, showing various settings.

```yaml
model: gpt-4o-mini
verbose: false
memory: false	aulemetry: false

```

--------------------------------

### Tracer::start_trace

Source: https://docs.praison.ai/llms.txt

Starts a new trace.

```APIDOC
## Tracer::start_trace

### Description
Start a new trace.

### Method
(Not specified, likely a method call on a Tracer instance)

### Response
- (TraceId) - The ID of the newly created trace.
```

--------------------------------

### Install PraisonAI and Start A2U Server

Source: https://docs.praison.ai/docs/deploy/servers/a2u

Install the necessary PraisonAI package with serving capabilities and set the OPENAI_API_KEY environment variable. Then, start the A2U server using the CLI, specifying the port.

```bash
pip install "praisonai[serve]"
export OPENAI_API_KEY="your-key"

# Start A2U server
praisonai serve a2u --port 8083

```

--------------------------------

### Authentication Workflow CLI Example

Source: https://docs.praison.ai/docs/cli/endpoints

Shows how to start a server with authentication and invoke an endpoint using an API key, either directly or via an environment variable.

```bash
# Start server with auth
praisonai serve recipe --auth api-key --api-key my-secret-key

# Invoke with API key
praisonai endpoints invoke my-recipe \
  --input-json '{"query": "Hello"}' \
  --api-key my-secret-key

# Or use environment variable
export PRAISONAI_ENDPOINTS_API_KEY=my-secret-key
praisonai endpoints invoke my-recipe --input-json '{"query": "Hello"}'
```

--------------------------------

### Install Package JSON Output

Source: https://docs.praison.ai/docs/cli/package-manager

Example JSON output when a package is successfully installed. It confirms the action and lists the installed package with its version.

```json
{
  "ok": true,
  "packages": ["requests"],
  "message": "Successfully installed requests-2.31.0"
}
```

--------------------------------

### VideoAgent.start

Source: https://docs.praison.ai/llms.txt

Starts a video agent process.

```APIDOC
## start

### Description
Start the video agent process.

### Method
(Not specified, likely a method call on a VideoAgent object)

### Request Example
```python
process_id = video_agent.start()
```

### Response
- **process_id** (str) - The ID of the started video agent process.
```

--------------------------------

### Agent.astart

Source: https://docs.praison.ai/llms.txt

Async version of start() - interactive, streaming-aware.

```APIDOC
## Agent.astart

### Description
Asynchronous version of the `start()` method. This method is designed for interactive use and is aware of streaming output.

### Method
Asynchronous function call

### Parameters
None explicitly documented.

### Request Example
```python
# Example usage (conceptual)
await agent.astart()
```

### Response
None explicitly documented. Likely initiates an interactive session.
```

--------------------------------

### File Backend Quick Start

Source: https://docs.praison.ai/docs/storage/backends

Demonstrates initializing and using the default FileBackend for basic JSON storage operations.

```python
from praisonaiagents.storage import FileBackend, BaseJSONStore

# File-based storage (default, zero config)
backend = FileBackend(storage_dir="~/.praisonai/data")
store = BaseJSONStore("session.json", backend=backend)

store.save({"messages": ["Hello", "World"]})
data = store.load()

```

--------------------------------

### Install PraisonAI on Windows

Source: https://docs.praison.ai/docs/install/quickstart

Use this command to install PraisonAI on Windows systems. It performs similar automatic setup steps as the macOS/Linux installer.

```powershell
iwr -useb https://praison.ai/install.ps1 | iex
```

--------------------------------

### AutoAgents.astart

Source: https://docs.praison.ai/llms.txt

Asynchronous version of the start() method for AutoAgents.

```APIDOC
## AutoAgents.astart

### Description
Async version of start() method.

### Method
(Not specified, likely a function call in an SDK)

### Parameters
(No parameters specified in the source)

### Request Example
(No request example provided)

### Response
(No response details provided)
```

--------------------------------

### Using with Docker Example

Source: https://docs.praison.ai/docs/cli/recipe-serve

Example Dockerfile for setting up the PraisonAI recipe server in a Docker container.

```APIDOC
### Using with Docker

```dockerfile
FROM python:3.11-slim
RUN pip install praisonai[serve]
COPY serve.yaml /app/
WORKDIR /app
CMD ["praisonai", "recipe", "serve", "--config", "serve.yaml"]
```
```

--------------------------------

### Event-Driven Recipe Integration Usage Example

Source: https://docs.praison.ai/docs/guides/recipes/integration-models/event-driven

Example demonstrating how to start the worker or submit a job and retrieve its result. This script can be run with 'worker' argument to start the worker, or without arguments to submit a job.

```python
if __name__ == "__main__":
    import sys
    
    if len(sys.argv) > 1 and sys.argv[1] == "worker":
        # Start worker
        worker = RecipeJobWorker()
        worker.run()
    else:
        # Submit job
        producer = RecipeJobProducer()
        
        job_id = producer.submit(
            "support-reply-drafter",
            {"ticket_id": "T-123", "message": "I need help"},
            callback_url="https://myapp.com/webhook/result"
        )
        
        print(f"Submitted job: {job_id}")
        
        # Wait for result
        result = producer.get_result(job_id, timeout=60)
        print(f"Result: {result}")
```

--------------------------------

### Database Adapters List Example Output

Source: https://docs.praison.ai/docs/js/database-cli

Human-readable list of supported database adapters and their descriptions.

```bash
Database Adapters

  ✓ sqlite          SQLite database
  ✓ postgres        PostgreSQL (Neon)
  ✓ redis           Redis (Upstash)
```

--------------------------------

### Install Cursor Shell Integration

Source: https://docs.praison.ai/docs/cli/cursor-cli

Install shell integration for easier access to Cursor commands directly in your terminal. This example shows installation to ~/.zshrc.

```bash
cursor-agent install-shell-integration
```

--------------------------------

### AutoAgents.start

Source: https://docs.praison.ai/llms.txt

Creates tasks based on instructions and then starts execution.

```APIDOC
## AutoAgents.start

### Description
Creates tasks based on the instructions, then starts execution.

### Method
(Not specified, likely a function call in an SDK)

### Parameters
(No parameters specified in the source)

### Request Example
(No request example provided)

### Response
(No response details provided)
```

--------------------------------

### Quick Start: Load Skills and Initialize Agent

Source: https://docs.praison.ai/docs/sdk/praisonaiagents/skills/skills

Load skills from a specified directory and initialize an Agent with these skills. Ensure the 'skills' directory exists and contains skill definitions.

```python
from praisonaiagents import Agent, SkillManager

# Load skills from directory
manager = SkillManager(skills_dir="./skills")
skills = manager.load_all()

agent = Agent(
    name="Assistant",
    tools=skills
)

```

--------------------------------

### get_config

Source: https://docs.praison.ai/llms.txt

Get the global configuration.

```APIDOC
## get_config

### Description
Get the global configuration.

### Method
Not specified (SDK function)

### Endpoint
Not applicable (SDK function)

### Parameters
Not specified

### Request Example
Not specified

### Response
Not specified
```

--------------------------------

### Python Usage Example

Source: https://docs.praison.ai/docs/features/bot-commands

Example of starting bots programmatically in Python, where built-in commands are automatically available.

```APIDOC
## Python Usage
Start bots programmatically — built-in commands are always available:
```python
from praisonai.bots import TelegramBot
from praisonaiagents import Agent

agent = Agent(name="assistant", instructions="Be helpful")
bot = TelegramBot(token="YOUR_TOKEN", agent=agent)

import asyncio
asyncio.run(bot.start())
# /status, /new, /help available automatically
```
```

--------------------------------

### Quick Knowledge Base Example

Source: https://docs.praison.ai/docs/sdk/praisonai/knowledge

A concise example demonstrating how to load documents, store them in a ChromaVectorStore with embeddings, and retrieve relevant information using FusionRetriever.

```python
from praisonai.adapters import AutoReader, ChromaVectorStore, FusionRetriever

# 1. Load documents
reader = AutoReader()
docs = reader.load("./documents/")

# 2. Store in vector database
store = ChromaVectorStore(namespace="knowledge")
store.add(
    texts=[d.content for d in docs],
    embeddings=get_embeddings([d.content for d in docs])
)

# 3. Retrieve relevant documents
retriever = FusionRetriever(
    vector_store=store,
    embedding_fn=get_embedding,
    num_queries=3
)
results = retriever.retrieve("What is Python?", top_k=5)

```

--------------------------------

### AgentTeam.start

Source: https://docs.praison.ai/llms.txt

Starts agent execution with verbose output, designed to be beginner-friendly.

```APIDOC
## AgentTeam.start

### Description
Start agent execution with verbose output (beginner-friendly).

### Method
(Not specified, likely a function call in an SDK)

### Parameters
(No parameters specified in the source)

### Request Example
(No request example provided)

### Response
(No response details provided)
```

--------------------------------

### Development Mode Example

Source: https://docs.praison.ai/docs/cli/recipe-serve

Example command for starting the server in development mode with hot reload enabled.

```APIDOC
### Development Mode

```
# Start with hot reload for development
praisonai serve recipe --reload
```
```
Tokens:
Raw