Merge pull request #558 from MervinPraison/develop

Develop

docker/.env.template

@@ -0,0 +1,53 @@
+# PraisonAI Docker Environment Configuration
+# Copy this file to .env and update with your values
+
+# Required: OpenAI API Key
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Required: Chainlit Authentication Secret (generate a random string)
+CHAINLIT_AUTH_SECRET=your_chainlit_secret_here
+
+# Optional: Additional API Keys
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+GOOGLE_API_KEY=your_google_api_key_here
+GROQ_API_KEY=your_groq_api_key_here
+COHERE_API_KEY=your_cohere_api_key_here
+
+# Optional: Service Configuration
+FLASK_ENV=development
+CHAINLIT_HOST=0.0.0.0
+
+# Optional: Port Configuration (modify if you have conflicts)
+UI_PORT=8082
+CHAT_PORT=8083
+API_PORT=8080
+
+# Optional: Database Configuration
+DATABASE_URL=sqlite:///root/.praison/database.sqlite
+
+# Optional: Logging Configuration
+LOG_LEVEL=INFO
+PYTHONPATH=/app
+
+# Optional: Development Settings
+DEV_MODE=false
+DEBUG=false
+
+# Optional: Model Configuration
+DEFAULT_MODEL=gpt-4
+DEFAULT_TEMPERATURE=0.7
+MAX_TOKENS=4000
+
+# Optional: Security Settings
+CORS_ORIGINS=http://localhost:3000,http://localhost:8082,http://localhost:8083
+RATE_LIMIT=100
+
+# Optional: Feature Flags
+ENABLE_CHAT=true
+ENABLE_UI=true
+ENABLE_API=true
+ENABLE_REALTIME=true
+
+# Optional: Volume Paths (for custom mounting)
+PRAISON_DATA_PATH=~/.praison
+EXAMPLES_PATH=./examples

docker/Dockerfile

@@ -1,6 +1,45 @@
 FROM python:3.11-slim
+
 WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    python3-dev \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create praison config directory
+RUN mkdir -p /root/.praison
+
+# Install Python packages (using latest versions)
+RUN pip install --no-cache-dir \
+    flask \
+    "praisonai>=2.2.22" \
+    "praisonai[api]" \
+    gunicorn \
+    markdown
+
+# Copy application code
 COPY . .
-RUN pip install flask praisonai==2.2.19 gunicorn markdown
+
+# Set environment variables for directory management
+ENV PRAISON_CONFIG_DIR=/root/.praison
+ENV DOCKER_CONTAINER=true
+
+# Create health check API if api.py doesn't exist
+RUN if [ ! -f api.py ]; then \
+    echo "from flask import Flask\n\
+app = Flask(__name__)\n\
+\n\
+@app.route('/health')\n\
+def health():\n\
+    return {'status': 'healthy'}, 200\n\
+\n\
+if __name__ == '__main__':\n\
+    app.run()" > api.py; \
+fi
+
 EXPOSE 8080
 CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]

docker/Dockerfile.chat

@@ -7,18 +7,27 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     gcc \
     python3-dev \
     curl \
+    git \
     && rm -rf /var/lib/apt/lists/*
 
-# Install Python packages
+# Create praison config directory
+RUN mkdir -p /root/.praison
+
+# Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
-    praisonaiagents>=0.0.4 \
     praisonai_tools \
-    "praisonai==2.2.19" \
+    "praisonai>=2.2.22" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 
 # Copy application code
 COPY . .
 
+# Set environment variables for directory management
+ENV PRAISON_CONFIG_DIR=/root/.praison
+ENV CHAINLIT_CONFIG_DIR=/root/.praison
+ENV CHAINLIT_DB_DIR=/root/.praison
+ENV DOCKER_CONTAINER=true
+
 # Default command (will be overridden by docker-compose)
 CMD ["praisonai", "chat"]

docker/Dockerfile.dev

@@ -9,20 +9,39 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     portaudio19-dev \
     python3-pyaudio \
     curl \
+    git \
+    vim \
+    nano \
     && rm -rf /var/lib/apt/lists/*
 
-# Install Python packages
+# Create praison config directory
+RUN mkdir -p /root/.praison
+
+# Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
-    praisonaiagents>=0.0.4 \
     praisonai_tools \
-    "praisonai==2.2.19" \
+    "praisonai>=2.2.22" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \
-    "embedchain[github,youtube]"
+    "praisonai[code]" \
+    "embedchain[github,youtube]" \
+    jupyter \
+    jupyterlab \
+    notebook \
+    pytest \
+    pytest-asyncio \
+    mkdocs \
+    mkdocs-material
 
 # Copy application code
 COPY . .
 
+# Set environment variables for directory management
+ENV PRAISON_CONFIG_DIR=/root/.praison
+ENV CHAINLIT_CONFIG_DIR=/root/.praison
+ENV CHAINLIT_DB_DIR=/root/.praison
+ENV DOCKER_CONTAINER=true
+
 # Default command (will be overridden by docker-compose)
 CMD ["praisonai", "ui"]

docker/Dockerfile.praisonaiagents

@@ -0,0 +1,32 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    python3-dev \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create praison config directory
+RUN mkdir -p /root/.praison
+
+# Copy praisonaiagents source
+COPY src/praisonai-agents/ /app/praisonaiagents/
+WORKDIR /app/praisonaiagents
+
+# Install praisonaiagents with all features (non-editable for production)
+RUN pip install --no-cache-dir ".[all]"
+
+# Set environment variables for directory management
+ENV PRAISON_CONFIG_DIR=/root/.praison
+ENV CHAINLIT_CONFIG_DIR=/root/.praison
+ENV CHAINLIT_DB_DIR=/root/.praison
+ENV DOCKER_CONTAINER=true
+
+WORKDIR /app
+
+# Default command
+CMD ["python", "-c", "import praisonaiagents; print('PraisonAI Agents installed successfully')"]

docker/Dockerfile.ui

@@ -7,18 +7,27 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     gcc \
     python3-dev \
     curl \
+    git \
     && rm -rf /var/lib/apt/lists/*
 
-# Install Python packages
+# Create praison config directory
+RUN mkdir -p /root/.praison
+
+# Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
-    praisonaiagents>=0.0.4 \
     praisonai_tools \
-    "praisonai==2.2.19" \
+    "praisonai>=2.2.22" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 
 # Copy application code
 COPY . .
 
+# Set environment variables for directory management
+ENV PRAISON_CONFIG_DIR=/root/.praison
+ENV CHAINLIT_CONFIG_DIR=/root/.praison
+ENV CHAINLIT_DB_DIR=/root/.praison
+ENV DOCKER_CONTAINER=true
+
 # Default command (will be overridden by docker-compose)
 CMD ["praisonai", "ui"]

docker/README.md

@@ -0,0 +1,265 @@
+# PraisonAI Docker Setup
+
+This directory contains Docker configurations for running PraisonAI services in containerized environments. The setup addresses directory management issues and provides comprehensive multi-service deployment options.
+
+## 🐳 Available Services
+
+### Core Services
+- **UI Service** (`port 8082`) - Chainlit-based web interface
+- **Chat Service** (`port 8083`) - Dedicated chat interface  
+- **API Service** (`port 8080`) - REST API endpoint
+- **Agents Service** - Standalone PraisonAI Agents runtime
+
+### Docker Files
+- `Dockerfile` - Basic API service
+- `Dockerfile.ui` - UI service with web interface
+- `Dockerfile.chat` - Chat-focused service
+- `Dockerfile.dev` - Development environment with tools
+- `Dockerfile.praisonaiagents` - Standalone agents framework
+- `docker-compose.yml` - Multi-service orchestration
+
+## 🚀 Quick Start
+
+### Single Service
+```bash
+# Run UI service
+docker run -p 8082:8082 -e OPENAI_API_KEY=your_key ghcr.io/mervinpraison/praisonai:ui
+
+# Run Chat service  
+docker run -p 8083:8083 -e OPENAI_API_KEY=your_key ghcr.io/mervinpraison/praisonai:chat
+
+# Run API service
+docker run -p 8080:8080 -e OPENAI_API_KEY=your_key ghcr.io/mervinpraison/praisonai:api
+```
+
+### Multi-Service with Docker Compose
+```bash
+# Create environment file
+cat > .env << EOF
+OPENAI_API_KEY=your_openai_api_key_here
+CHAINLIT_AUTH_SECRET=your_secret_here
+EOF
+
+# Start all services
+docker-compose up -d
+
+# View logs
+docker-compose logs -f
+
+# Stop services
+docker-compose down
+```
+
+## 📁 Directory Management
+
+### Problem Solved
+The original issue was that files like `chainlit.md`, `.chainlit` directory, and `public` folder were cluttering the root directory.
+
+### Solution Implemented
+All PraisonAI configuration and runtime files are now stored in `~/.praison/`:
+
+```bash
+~/.praison/
+├── database.sqlite      # Chainlit database
+├── chainlit.md         # Chainlit configuration 
+├── .chainlit/          # Chainlit runtime files
+└── config/             # PraisonAI configuration
+```
+
+### Environment Variables
+```bash
+PRAISON_CONFIG_DIR=/root/.praison      # Main config directory
+CHAINLIT_CONFIG_DIR=/root/.praison     # Chainlit config location
+CHAINLIT_DB_DIR=/root/.praison         # Database location
+```
+
+## 🔧 Service Configuration
+
+### UI Service (Port 8082)
+```yaml
+environment:
+  - CHAINLIT_PORT=8082
+  - CHAINLIT_HOST=0.0.0.0
+  - OPENAI_API_KEY=${OPENAI_API_KEY}
+  - CHAINLIT_AUTH_SECRET=${CHAINLIT_AUTH_SECRET}
+```
+
+### Chat Service (Port 8083)  
+```yaml
+environment:
+  - CHAINLIT_PORT=8083
+  - CHAINLIT_HOST=0.0.0.0
+  - OPENAI_API_KEY=${OPENAI_API_KEY}
+```
+
+### API Service (Port 8080)
+```yaml
+environment:
+  - OPENAI_API_KEY=${OPENAI_API_KEY}
+```
+
+## 🎯 Service Endpoints
+
+| Service | Port | Endpoint | Description |
+|---------|------|----------|-------------|
+| UI | 8082 | http://localhost:8082 | Web interface |
+| Chat | 8083 | http://localhost:8083 | Chat interface |
+| API | 8080 | http://localhost:8080 | REST API |
+| API Health | 8080 | http://localhost:8080/health | Health check |
+
+## 🔍 Health Checks
+
+All services include health checks:
+```yaml
+healthcheck:
+  test: ["CMD", "curl", "-f", "http://localhost:PORT"]
+  interval: 10s
+  timeout: 5s
+  retries: 3
+```
+
+## 📦 Package Versions
+
+All Docker images use consistent, up-to-date versions:
+- PraisonAI: `>=2.2.22`
+- PraisonAI Agents: `>=0.0.92`
+- Python: `3.11-slim`
+
+## 🔒 Security Features
+
+- Non-root user execution where possible
+- Minimal base image (python:3.11-slim)
+- No unnecessary packages installed
+- Environment variable-based configuration
+- Volume mounting for persistent data
+
+## 🛠 Development
+
+### Development Environment
+```bash
+# Use development Dockerfile with additional tools
+docker build -f Dockerfile.dev -t praisonai:dev .
+docker run -it -v $(pwd):/app praisonai:dev bash
+```
+
+### Custom Configuration
+```bash
+# Mount custom config directory
+docker run -v ~/.praison:/root/.praison praisonai:ui
+```
+
+## 📊 Monitoring
+
+### Docker Compose Monitoring
+```bash
+# View service status
+docker-compose ps
+
+# View resource usage
+docker-compose top
+
+# View logs for specific service
+docker-compose logs ui
+docker-compose logs chat
+docker-compose logs api
+```
+
+## 🚨 Troubleshooting
+
+### Common Issues
+
+1. **Port conflicts**
+   ```bash
+   # Check port usage
+   netstat -tlnp | grep :8082
+   
+   # Use different ports
+   docker run -p 9082:8082 praisonai:ui
+   ```
+
+2. **Environment variables not loading**
+   ```bash
+   # Verify .env file
+   cat .env
+   
+   # Set variables directly
+   docker run -e OPENAI_API_KEY=your_key praisonai:ui
+   ```
+
+3. **Permission issues**
+   ```bash
+   # Check volume permissions
+   ls -la ~/.praison/
+   
+   # Fix permissions
+   sudo chown -R $(id -u):$(id -g) ~/.praison/
+   ```
+
+4. **Service won't start**
+   ```bash
+   # Check logs
+   docker-compose logs service_name
+   
+   # Restart service
+   docker-compose restart service_name
+   ```
+
+## 🔄 Updates
+
+### Pulling Latest Images
+```bash
+# Pull latest images
+docker-compose pull
+
+# Restart with new images
+docker-compose up -d
+```
+
+### Version Pinning
+To use specific versions, update the Dockerfile:
+```dockerfile
+RUN pip install "praisonai==2.2.22" "praisonaiagents==0.0.92"
+```
+
+## 🌐 Production Deployment
+
+### Recommended Production Setup
+```yaml
+# docker-compose.prod.yml
+version: '3.8'
+services:
+  ui:
+    image: ghcr.io/mervinpraison/praisonai:ui
+    restart: unless-stopped
+    environment:
+      - CHAINLIT_HOST=0.0.0.0
+      - CHAINLIT_PORT=8082
+    volumes:
+      - praison_data:/root/.praison
+    networks:
+      - praison_network
+    deploy:
+      resources:
+        limits:
+          memory: 1G
+        reservations:
+          memory: 512M
+```
+
+### Load Balancer Configuration
+For production environments, consider using nginx or similar:
+```nginx
+upstream praisonai {
+    server localhost:8082;
+    server localhost:8083;
+}
+
+server {
+    listen 80;
+    location / {
+        proxy_pass http://praisonai;
+    }
+}
+```
+
+This Docker setup provides a clean, organized, and scalable way to deploy PraisonAI services while solving the directory management issues mentioned in the original request.

docker/docker-compose.dev.yml

@@ -0,0 +1,184 @@
+version: '3.8'
+
+# Development Docker Compose Configuration
+# Extends the main docker-compose.yml with development-specific settings
+
+services:
+  # Development UI Service with hot reload
+  ui-dev:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile.dev
+    volumes:
+      - praison_data:/root/.praison
+      - ../src:/app/src:rw
+      - ../examples:/app/examples:rw
+      - ../docs:/app/docs:ro
+    ports:
+      - "${UI_PORT:-8082}:8082"
+    environment:
+      FLASK_ENV: development
+      CHAINLIT_PORT: "8082"
+      CHAINLIT_HOST: "0.0.0.0"
+      OPENAI_API_KEY: ${OPENAI_API_KEY}
+      CHAINLIT_AUTH_SECRET: ${CHAINLIT_AUTH_SECRET}
+      PRAISON_CONFIG_DIR: /root/.praison
+      CHAINLIT_CONFIG_DIR: /root/.praison
+      CHAINLIT_DB_DIR: /root/.praison
+      DEBUG: "true"
+      DEV_MODE: "true"
+      PYTHONPATH: /app/src
+    command: praisonai ui --host 0.0.0.0 --reload
+    networks:
+      - praison_network
+    depends_on:
+      - database
+
+  # Development Chat Service
+  chat-dev:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile.dev
+    volumes:
+      - praison_data:/root/.praison
+      - ../src:/app/src:rw
+      - ../examples:/app/examples:rw
+    ports:
+      - "${CHAT_PORT:-8083}:8083"
+    environment:
+      CHAINLIT_PORT: "8083"
+      CHAINLIT_HOST: "0.0.0.0"
+      OPENAI_API_KEY: ${OPENAI_API_KEY}
+      CHAINLIT_AUTH_SECRET: ${CHAINLIT_AUTH_SECRET}
+      PRAISON_CONFIG_DIR: /root/.praison
+      CHAINLIT_CONFIG_DIR: /root/.praison
+      CHAINLIT_DB_DIR: /root/.praison
+      DEBUG: "true"
+      DEV_MODE: "true"
+      PYTHONPATH: /app/src
+    command: praisonai chat --host 0.0.0.0 --port 8083 --reload
+    networks:
+      - praison_network
+    depends_on:
+      - database
+
+  # Development API Service with hot reload
+  api-dev:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile.dev
+    volumes:
+      - praison_data:/root/.praison
+      - ../src:/app/src:rw
+      - ../examples:/app/examples:rw
+    ports:
+      - "${API_PORT:-8080}:8080"
+    environment:
+      OPENAI_API_KEY: ${OPENAI_API_KEY}
+      PRAISON_CONFIG_DIR: /root/.praison
+      FLASK_ENV: development
+      DEBUG: "true"
+      DEV_MODE: "true"
+      PYTHONPATH: /app/src
+    command: python -m flask --app api run --host 0.0.0.0 --port 8080 --debug
+    networks:
+      - praison_network
+    depends_on:
+      - database
+
+  # Development Jupyter Notebook Service
+  jupyter:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile.dev
+    volumes:
+      - praison_data:/root/.praison
+      - ../src:/app/src:rw
+      - ../examples:/app/examples:rw
+      - ../docs:/app/docs:rw
+    ports:
+      - "8888:8888"
+    environment:
+      OPENAI_API_KEY: ${OPENAI_API_KEY}
+      PRAISON_CONFIG_DIR: /root/.praison
+      JUPYTER_ENABLE_LAB: "yes"
+      PYTHONPATH: /app/src
+    command: jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root --LabApp.token='' --LabApp.password=''
+    networks:
+      - praison_network
+
+  # Development Testing Service
+  test:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile.dev
+    volumes:
+      - ../src:/app/src:rw
+      - ../tests:/app/tests:rw
+      - praison_data:/root/.praison
+    environment:
+      OPENAI_API_KEY: ${OPENAI_API_KEY}
+      PRAISON_CONFIG_DIR: /root/.praison
+      PYTHONPATH: /app/src
+      PYTEST_CURRENT_TEST: "true"
+    command: python -m pytest tests/ -v
+    networks:
+      - praison_network
+    profiles:
+      - test
+
+  # Standalone database for development
+  database:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_DB: praisonai_dev
+      POSTGRES_USER: praisonai
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-praisonai_dev_pass}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+    networks:
+      - praison_network
+    profiles:
+      - database
+
+  # Redis for caching and session management
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    networks:
+      - praison_network
+    profiles:
+      - cache
+
+  # Development documentation server
+  docs:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile.dev
+    volumes:
+      - ../docs:/app/docs:rw
+      - ../README.md:/app/README.md:ro
+    ports:
+      - "8000:8000"
+    command: sh -c "cd docs && mkdocs serve --dev-addr 0.0.0.0:8000"
+    networks:
+      - praison_network
+    profiles:
+      - docs
+
+volumes:
+  praison_data:
+    driver: local
+  postgres_data:
+    driver: local
+  redis_data:
+    driver: local
+
+networks:
+  praison_network:
+    driver: bridge

docker/docker-compose.yml

@@ -1,9 +1,13 @@
+version: '3.8'
+
 services:
+  # PraisonAI UI Service
   ui:
     build:
-      context: .
-      dockerfile: Dockerfile.ui
+      context: ..
+      dockerfile: docker/Dockerfile.ui
     volumes:
+      - praison_data:/root/.praison
       - .:/app
     ports:
       - "8082:8082"
@@ -13,9 +17,83 @@ services:
       CHAINLIT_HOST: "0.0.0.0"
       OPENAI_API_KEY: ${OPENAI_API_KEY}
       CHAINLIT_AUTH_SECRET: ${CHAINLIT_AUTH_SECRET}
+      PRAISON_CONFIG_DIR: /root/.praison
+      CHAINLIT_CONFIG_DIR: /root/.praison
+      CHAINLIT_DB_DIR: /root/.praison
     command: praisonai ui --host 0.0.0.0
     healthcheck:
       test: ["CMD", "curl", "-f", "http://localhost:8082"]
       interval: 10s
       timeout: 5s
-      retries: 3
+      retries: 3
+    networks:
+      - praison_network
+
+  # PraisonAI Chat Service
+  chat:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile.chat
+    volumes:
+      - praison_data:/root/.praison
+      - .:/app
+    ports:
+      - "8083:8083"
+    environment:
+      CHAINLIT_PORT: "8083"
+      CHAINLIT_HOST: "0.0.0.0"
+      OPENAI_API_KEY: ${OPENAI_API_KEY}
+      CHAINLIT_AUTH_SECRET: ${CHAINLIT_AUTH_SECRET}
+      PRAISON_CONFIG_DIR: /root/.praison
+      CHAINLIT_CONFIG_DIR: /root/.praison
+      CHAINLIT_DB_DIR: /root/.praison
+    command: praisonai chat --host 0.0.0.0 --port 8083
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8083"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    networks:
+      - praison_network
+
+  # PraisonAI API Service
+  api:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile
+    volumes:
+      - praison_data:/root/.praison
+    ports:
+      - "8080:8080"
+    environment:
+      OPENAI_API_KEY: ${OPENAI_API_KEY}
+      PRAISON_CONFIG_DIR: /root/.praison
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    networks:
+      - praison_network
+
+  # PraisonAI Agents Service (standalone)
+  agents:
+    build:
+      context: ..
+      dockerfile: docker/Dockerfile.praisonaiagents
+    volumes:
+      - praison_data:/root/.praison
+      - ./examples:/app/examples
+    environment:
+      OPENAI_API_KEY: ${OPENAI_API_KEY}
+      PRAISON_CONFIG_DIR: /root/.praison
+    networks:
+      - praison_network
+
+volumes:
+  praison_data:
+    driver: local
+
+networks:
+  praison_network:
+    driver: bridge

docker/quick-start.sh

@@ -0,0 +1,289 @@
+#!/bin/bash
+
+# PraisonAI Docker Quick Start Script
+# This script helps users quickly get started with PraisonAI using Docker
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Function to print colored output
+print_status() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Check if Docker is installed
+check_docker() {
+    if ! command -v docker &> /dev/null; then
+        print_error "Docker is not installed. Please install Docker first:"
+        echo "  - Visit: https://docs.docker.com/get-docker/"
+        exit 1
+    fi
+    
+    if ! command -v docker-compose &> /dev/null && ! docker compose version &> /dev/null; then
+        print_error "Docker Compose is not available. Please install Docker Compose:"
+        echo "  - Visit: https://docs.docker.com/compose/install/"
+        exit 1
+    fi
+    
+    print_success "Docker and Docker Compose are available"
+}
+
+# Check if .env file exists, create from template if not
+setup_environment() {
+    if [ ! -f ".env" ]; then
+        print_status "Creating .env file from template..."
+        if [ -f ".env.template" ]; then
+            cp .env.template .env
+        else
+            cat > .env << EOF
+# PraisonAI Docker Environment Configuration
+OPENAI_API_KEY=your_openai_api_key_here
+CHAINLIT_AUTH_SECRET=$(openssl rand -hex 32 2>/dev/null || echo "your_chainlit_secret_here")
+FLASK_ENV=development
+CHAINLIT_HOST=0.0.0.0
+UI_PORT=8082
+CHAT_PORT=8083
+API_PORT=8080
+EOF
+        fi
+        print_warning "Please edit .env file and add your API keys before continuing"
+        print_status "Required: OPENAI_API_KEY"
+        read -p "Press Enter to continue after updating .env file..."
+    else
+        print_success ".env file already exists"
+    fi
+}
+
+# Function to show menu
+show_menu() {
+    echo ""
+    echo "=== PraisonAI Docker Quick Start ==="
+    echo ""
+    echo "1) Start UI Service (Web Interface) - Port 8082"
+    echo "2) Start Chat Service - Port 8083"
+    echo "3) Start API Service - Port 8080"
+    echo "4) Start All Services (Recommended)"
+    echo "5) Start Development Environment"
+    echo "6) View Service Status"
+    echo "7) View Logs"
+    echo "8) Stop All Services"
+    echo "9) Pull Latest Images"
+    echo "10) Clean Up (Remove containers and volumes)"
+    echo "11) Show Service URLs"
+    echo "0) Exit"
+    echo ""
+}
+
+# Start specific service
+start_service() {
+    local service=$1
+    print_status "Starting $service service..."
+    docker-compose up -d $service
+    print_success "$service service started"
+}
+
+# Start all services
+start_all_services() {
+    print_status "Starting all PraisonAI services..."
+    docker-compose up -d
+    print_success "All services started"
+    show_service_urls
+}
+
+# Start development environment
+start_dev_environment() {
+    print_status "Starting development environment..."
+    if [ -f "docker-compose.dev.yml" ]; then
+        docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d ui-dev chat-dev api-dev
+        print_success "Development environment started"
+        echo ""
+        echo "Development services available:"
+        echo "  - UI (with hot reload): http://localhost:${UI_PORT:-8082}"
+        echo "  - Chat (with hot reload): http://localhost:${CHAT_PORT:-8083}"
+        echo "  - API (with hot reload): http://localhost:${API_PORT:-8080}"
+        echo "  - Jupyter Lab: http://localhost:8888"
+        echo ""
+    else
+        print_warning "Development configuration not found, starting regular services"
+        start_all_services
+    fi
+}
+
+# Show service status
+show_status() {
+    print_status "Service Status:"
+    docker-compose ps
+}
+
+# Show logs
+show_logs() {
+    echo ""
+    echo "Which service logs would you like to view?"
+    echo "1) All services"
+    echo "2) UI service"
+    echo "3) Chat service"
+    echo "4) API service"
+    echo "5) Agents service"
+    read -p "Enter choice (1-5): " log_choice
+    
+    case $log_choice in
+        1) docker-compose logs -f ;;
+        2) docker-compose logs -f ui ;;
+        3) docker-compose logs -f chat ;;
+        4) docker-compose logs -f api ;;
+        5) docker-compose logs -f agents ;;
+        *) print_error "Invalid choice" ;;
+    esac
+}
+
+# Stop all services
+stop_services() {
+    print_status "Stopping all services..."
+    docker-compose down
+    print_success "All services stopped"
+}
+
+# Pull latest images
+pull_images() {
+    print_status "Pulling latest images..."
+    docker-compose pull
+    print_success "Images updated"
+}
+
+# Clean up
+cleanup() {
+    print_warning "This will remove all containers, networks, and volumes"
+    read -p "Are you sure? (y/N): " confirm
+    if [[ $confirm == [yY] || $confirm == [yY][eE][sS] ]]; then
+        print_status "Cleaning up..."
+        docker-compose down -v --remove-orphans
+        docker system prune -f
+        print_success "Cleanup completed"
+    fi
+}
+
+# Show service URLs
+show_service_urls() {
+    local ui_port=${UI_PORT:-8082}
+    local chat_port=${CHAT_PORT:-8083}
+    local api_port=${API_PORT:-8080}
+    
+    echo ""
+    echo "=== Service URLs ==="
+    echo "UI Service: http://localhost:$ui_port"
+    echo "Chat Service: http://localhost:$chat_port"
+    echo "API Service: http://localhost:$api_port"
+    echo "API Health: http://localhost:$api_port/health"
+    echo ""
+}
+
+# Check system requirements
+check_requirements() {
+    print_status "Checking system requirements..."
+    
+    # Check available memory
+    if command -v free &> /dev/null; then
+        available_ram=$(free -m | awk 'NR==2{printf "%.1f", $7/1024}')
+        print_status "Available RAM: ${available_ram}GB"
+        if (( $(echo "$available_ram < 2.0" | bc -l 2>/dev/null || echo "1") )); then
+            print_warning "Low available memory. Recommended: 2GB+ available RAM"
+        fi
+    fi
+    
+    # Check disk space
+    if command -v df &> /dev/null; then
+        available_space=$(df -BG . | awk 'NR==2{print $4}' | sed 's/G//')
+        print_status "Available disk space: ${available_space}GB"
+        if [ "$available_space" -lt 5 ]; then
+            print_warning "Low disk space. Recommended: 5GB+ available space"
+        fi
+    fi
+}
+
+# Main function
+main() {
+    clear
+    echo "🤖 Welcome to PraisonAI Docker Setup!"
+    echo ""
+    
+    # Check prerequisites
+    check_docker
+    check_requirements
+    setup_environment
+    
+    # Main loop
+    while true; do
+        show_menu
+        read -p "Enter your choice (0-11): " choice
+        
+        case $choice in
+            1)
+                start_service "ui"
+                echo "UI Service: http://localhost:${UI_PORT:-8082}"
+                ;;
+            2)
+                start_service "chat"
+                echo "Chat Service: http://localhost:${CHAT_PORT:-8083}"
+                ;;
+            3)
+                start_service "api"
+                echo "API Service: http://localhost:${API_PORT:-8080}"
+                ;;
+            4)
+                start_all_services
+                ;;
+            5)
+                start_dev_environment
+                ;;
+            6)
+                show_status
+                ;;
+            7)
+                show_logs
+                ;;
+            8)
+                stop_services
+                ;;
+            9)
+                pull_images
+                ;;
+            10)
+                cleanup
+                ;;
+            11)
+                show_service_urls
+                ;;
+            0)
+                print_success "Thank you for using PraisonAI!"
+                exit 0
+                ;;
+            *)
+                print_error "Invalid choice. Please try again."
+                ;;
+        esac
+        
+        echo ""
+        read -p "Press Enter to continue..."
+    done
+}
+
+# Run main function
+main

docs/api/praisonai/deploy.html

@@ -110,7 +110,7 @@ Loads environment variables from .env file or system and sets them.</p>
             file.write(&#34;FROM python:3.11-slim\n&#34;)
             file.write(&#34;WORKDIR /app\n&#34;)
             file.write(&#34;COPY . .\n&#34;)
-            file.write(&#34;RUN pip install flask praisonai==2.2.19 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.2.22 gunicorn markdown\n&#34;)
             file.write(&#34;EXPOSE 8080\n&#34;)
             file.write(&#39;CMD [&#34;gunicorn&#34;, &#34;-b&#34;, &#34;0.0.0.0:8080&#34;, &#34;api:app&#34;]\n&#39;)
             

docs/developers/local-development.mdx

@@ -27,7 +27,7 @@ WORKDIR /app
 
 COPY . .
 
-RUN pip install flask praisonai==2.2.19 watchdog
+RUN pip install flask praisonai==2.2.22 watchdog
 
 EXPOSE 5555
 

docs/features/camera-integration.mdx

@@ -0,0 +1,423 @@
+---
+title: Camera Integration
+description: How to integrate camera feeds with PraisonAI multimodal agents for real-time visual analysis
+---
+
+# Camera Integration
+
+PraisonAI supports camera integration for real-time visual analysis through multimodal agents. While there's no built-in camera capture, you can easily integrate camera feeds by capturing frames or videos and passing them to vision agents.
+
+## Overview
+
+Camera integration works by:
+1. **Capturing frames/videos** from camera using OpenCV
+2. **Saving temporarily** to disk
+3. **Passing file paths** to agents via the `images` parameter
+4. **Cleaning up** temporary files after analysis
+
+## Quick Start
+
+### Prerequisites
+
+```bash
+pip install praisonaiagents opencv-python
+export OPENAI_API_KEY=your_openai_api_key
+```
+
+### Basic Camera Capture
+
+```python
+import cv2
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+def capture_and_analyze():
+    # Create vision agent
+    vision_agent = Agent(
+        name="CameraAnalyst",
+        role="Camera Feed Analyzer",
+        goal="Analyze camera captures in real-time",
+        backstory="Expert in real-time visual analysis",
+        llm="gpt-4o-mini"
+    )
+    
+    # Capture from camera
+    cap = cv2.VideoCapture(0)  # 0 for default camera
+    ret, frame = cap.read()
+    
+    if ret:
+        # Save frame temporarily
+        cv2.imwrite("temp_capture.jpg", frame)
+        cap.release()
+        
+        # Create analysis task
+        task = Task(
+            description="Analyze what you see in this camera feed",
+            expected_output="Detailed analysis of camera content",
+            agent=vision_agent,
+            images=["temp_capture.jpg"]
+        )
+        
+        # Run analysis
+        agents = PraisonAIAgents(
+            agents=[vision_agent],
+            tasks=[task]
+        )
+        
+        return agents.start()
+
+# Run analysis
+result = capture_and_analyze()
+```
+
+## Integration Patterns
+
+### 1. Single Frame Analysis
+
+Perfect for quick snapshots and one-time analysis:
+
+```python
+def single_frame_analysis():
+    cap = cv2.VideoCapture(0)
+    ret, frame = cap.read()
+    
+    if ret:
+        image_path = "snapshot.jpg"
+        cv2.imwrite(image_path, frame)
+        
+        # Analyze with your agent
+        # ... (agent setup and task creation)
+        
+    cap.release()
+```
+
+### 2. Continuous Monitoring
+
+Ideal for security systems and real-time monitoring:
+
+```python
+def continuous_monitoring(interval=10):
+    vision_agent = Agent(
+        name="SecurityMonitor",
+        role="Security Camera Analyst",
+        goal="Monitor for security events",
+        backstory="Expert security analyst",
+        llm="gpt-4o-mini"
+    )
+    
+    cap = cv2.VideoCapture(0)
+    
+    while True:
+        ret, frame = cap.read()
+        if ret:
+            timestamp = int(time.time())
+            filename = f"capture_{timestamp}.jpg"
+            cv2.imwrite(filename, frame)
+            
+            # Analyze frame
+            task = Task(
+                description="Monitor for unusual activities",
+                agent=vision_agent,
+                images=[filename]
+            )
+            
+            agents = PraisonAIAgents(
+                agents=[vision_agent],
+                tasks=[task]
+            )
+            
+            result = agents.start()
+            print(f"Analysis: {result}")
+            
+        time.sleep(interval)
+```
+
+### 3. Multi-Agent Analysis
+
+Use multiple specialized agents for comprehensive analysis:
+
+```python
+def multi_agent_camera_analysis():
+    # Create specialized agents
+    security_agent = Agent(
+        name="SecurityExpert",
+        role="Security Specialist",
+        goal="Identify security threats",
+        backstory="Expert in surveillance and threat detection",
+        llm="gpt-4o-mini"
+    )
+    
+    object_detector = Agent(
+        name="ObjectDetector",
+        role="Object Recognition Specialist",
+        goal="Identify and catalog objects",
+        backstory="Computer vision expert",
+        llm="gpt-4o-mini"
+    )
+    
+    scene_analyst = Agent(
+        name="SceneAnalyst",
+        role="Scene Understanding Expert",
+        goal="Provide comprehensive scene analysis",
+        backstory="Environmental analysis expert",
+        llm="gpt-4o-mini"
+    )
+    
+    # Capture frame
+    cap = cv2.VideoCapture(0)
+    ret, frame = cap.read()
+    cap.release()
+    
+    if ret:
+        cv2.imwrite("analysis_frame.jpg", frame)
+        
+        # Create specialized tasks
+        security_task = Task(
+            description="Analyze for security threats",
+            agent=security_agent,
+            images=["analysis_frame.jpg"]
+        )
+        
+        object_task = Task(
+            description="Identify all objects in scene",
+            agent=object_detector,
+            images=["analysis_frame.jpg"]
+        )
+        
+        scene_task = Task(
+            description="Provide comprehensive scene analysis",
+            agent=scene_analyst,
+            images=["analysis_frame.jpg"]
+        )
+        
+        # Run parallel analysis
+        agents = PraisonAIAgents(
+            agents=[security_agent, object_detector, scene_analyst],
+            tasks=[security_task, object_task, scene_task],
+            process="parallel"
+        )
+        
+        return agents.start()
+```
+
+### 4. Video Recording & Analysis
+
+Analyze temporal events and activities:
+
+```python
+def record_and_analyze_video(duration=10):
+    cap = cv2.VideoCapture(0)
+    
+    # Setup video writer
+    fps = int(cap.get(cv2.CAP_PROP_FPS)) or 30
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter('recording.mp4', fourcc, fps, (width, height))
+    
+    # Record video
+    start_time = time.time()
+    while (time.time() - start_time) < duration:
+        ret, frame = cap.read()
+        if ret:
+            out.write(frame)
+    
+    cap.release()
+    out.release()
+    
+    # Analyze video
+    video_agent = Agent(
+        name="VideoAnalyst",
+        role="Video Content Analyzer",
+        goal="Analyze video content for activities",
+        backstory="Expert in video analysis",
+        llm="gpt-4o-mini"
+    )
+    
+    task = Task(
+        description="Analyze this video for activities and events",
+        agent=video_agent,
+        images=["recording.mp4"]  # Video files work too!
+    )
+    
+    agents = PraisonAIAgents(
+        agents=[video_agent],
+        tasks=[task]
+    )
+    
+    return agents.start()
+```
+
+## Supported Input Types
+
+PraisonAI accepts various visual input formats:
+
+- ✅ **Local Images**: `"camera_shot.jpg"`, `"webcam_capture.png"`
+- ✅ **Local Videos**: `"security_feed.mp4"`, `"recording.avi"`
+- ✅ **Image URLs**: `"https://example.com/live_feed.jpg"`
+- ✅ **Multiple Sources**: `["cam1.jpg", "cam2.jpg", "video.mp4"]`
+
+## Configuration Options
+
+### Camera Selection
+
+```python
+# Different camera sources
+camera_id = 0    # Default camera
+camera_id = 1    # External USB camera
+camera_id = "rtsp://camera-ip/stream"  # IP camera
+```
+
+### Analysis Intervals
+
+```python
+# For continuous monitoring
+analysis_interval = 5   # Every 5 seconds (high frequency)
+analysis_interval = 30  # Every 30 seconds (moderate)
+analysis_interval = 300 # Every 5 minutes (low frequency)
+```
+
+### Video Recording
+
+```python
+# Recording duration
+duration = 10    # 10 seconds
+duration = 60    # 1 minute
+duration = 300   # 5 minutes
+```
+
+## Use Cases
+
+### Security Monitoring
+- Real-time threat detection
+- Unauthorized access alerts
+- Suspicious activity identification
+- Perimeter monitoring
+
+### Retail Analytics
+- Customer behavior analysis
+- Inventory monitoring
+- Queue management
+- Theft prevention
+
+### Industrial Automation
+- Quality control inspection
+- Safety compliance monitoring
+- Equipment status verification
+- Process optimization
+
+### Smart Home
+- Activity recognition
+- Elderly care monitoring
+- Pet monitoring
+- Energy usage optimization
+
+## Best Practices
+
+### Performance Optimization
+
+1. **Frame Rate Management**
+   ```python
+   # Reduce analysis frequency for better performance
+   time.sleep(5)  # Analyze every 5 seconds instead of continuously
+   ```
+
+2. **Image Size Optimization**
+   ```python
+   # Resize frames for faster processing
+   frame = cv2.resize(frame, (640, 480))
+   ```
+
+3. **Parallel Processing**
+   ```python
+   # Use parallel process for multiple agents
+   process="parallel"
+   ```
+
+### Memory Management
+
+1. **Clean Up Temporary Files**
+   ```python
+   import os
+   if os.path.exists(image_path):
+       os.remove(image_path)
+   ```
+
+2. **Limit Video Duration**
+   ```python
+   # Keep recordings short to avoid large files
+   max_duration = 30  # seconds
+   ```
+
+### Security Considerations
+
+1. **Camera Permissions**
+   - Ensure application has camera access
+   - Handle permission errors gracefully
+
+2. **Privacy Protection**
+   - Implement data retention policies
+   - Secure transmission of camera data
+   - User consent for recording
+
+3. **Access Control**
+   - Authenticate camera access
+   - Implement role-based permissions
+
+## Troubleshooting
+
+### Camera Not Found
+
+```python
+# Check available cameras
+for i in range(4):
+    cap = cv2.VideoCapture(i)
+    if cap.isOpened():
+        print(f"Camera {i} is available")
+        cap.release()
+    else:
+        print(f"Camera {i} not available")
+```
+
+### Permission Issues
+
+**Linux:**
+```bash
+# Add user to video group
+sudo usermod -a -G video $USER
+```
+
+**macOS:**
+- Grant camera permissions in System Preferences > Security & Privacy
+
+**Windows:**
+- Check camera privacy settings in Windows Settings
+
+### Performance Issues
+
+```python
+# Reduce frame size
+frame = cv2.resize(frame, (320, 240))
+
+# Lower analysis frequency
+time.sleep(10)  # Analyze every 10 seconds
+
+# Use threading for non-blocking capture
+import threading
+```
+
+## Examples
+
+Complete working examples are available in the repository:
+
+- [`camera-basic.py`](../../examples/python/camera/camera-basic.py) - Basic single frame capture
+- [`camera-continuous.py`](../../examples/python/camera/camera-continuous.py) - Continuous monitoring
+- [`camera-multi-agent.py`](../../examples/python/camera/camera-multi-agent.py) - Multi-agent analysis
+- [`camera-video-analysis.py`](../../examples/python/camera/camera-video-analysis.py) - Video recording & analysis
+
+## Related Features
+
+- [Multimodal Agents](./multimodal) - Core multimodal capabilities
+- [Image Generation](./image-generation) - Creating images with AI
+- [Agent Memory](../concepts/memory) - Persistent agent memory
+- [Task Management](../concepts/tasks) - Task configuration and execution

docs/mcp/playwright.mdx

@@ -0,0 +1,54 @@
+---
+title: 'Playwright'
+description: 'Using Playwright MCP with PraisonAI'
+---
+
+# Playwright MCP
+
+[Playwright](https://playwright.dev/) is a powerful browser automation tool that can be used with the Model Context Protocol (MCP) to enable agents to interact with web browsers.
+
+## Installation
+
+To use Playwright with MCP, you'll need to install the Playwright MCP package:
+
+```bash
+npm install @playwright/mcp
+```
+
+## Running the Playwright MCP Server
+
+You need to run the Playwright MCP server in a separate terminal before your agent can use it:
+
+```bash
+npx @playwright/mcp@latest --port 8931
+```
+
+This will start a Playwright MCP server on port 8931 that your agent can connect to.
+
+## Using Playwright MCP with PraisonAI
+
+Once the Playwright MCP server is running, you can create an agent that uses it as a tool:
+
+```python
+from praisonaiagents import Agent, MCP
+
+search_agent = Agent(
+    instructions="""You help search the web.""",
+    llm="gpt-4o-mini",
+    tools=MCP("http://localhost:8931/sse")
+)
+
+search_agent.start("Find about Praison AI")
+```
+
+The agent will be able to use Playwright to automate browser interactions and search the web.
+
+## Advanced Configuration
+
+You can customize the Playwright MCP server by passing additional options:
+
+```bash
+npx @playwright/mcp@latest --port 8931 --browser chromium
+```
+
+For more information on available options, refer to the [Playwright MCP documentation](https://github.com/microsoft/playwright/tree/main/packages/mcp).

docs/mint.json

@@ -143,7 +143,8 @@
         "features/mathagent",
         "features/structured",
         "features/callbacks",
-        "features/chat-with-pdf"
+        "features/chat-with-pdf",
+        "features/camera-integration"
       ]
     },
     {
@@ -250,6 +251,7 @@
         "mcp/anthropic",
         "mcp/gemini",
         "mcp/mistral",
+        "mcp/playwright",
         "mcp/whatsapp",
         "mcp/perplexity",
         "mcp/ollama-python",

docs/tools/crawl4ai.mdx

@@ -31,7 +31,7 @@ export OPENAI_API_KEY=xxxxxxxxx
 
 ```python
 import os
-from crawl4ai import WebCrawler
+from crawl4ai import AsyncWebCrawler
 from crawl4ai.extraction_strategy import LLMExtractionStrategy
 from pydantic import BaseModel, Field
 
@@ -41,7 +41,7 @@ class OpenAIModelFee(BaseModel):
     output_fee: str = Field(..., description="Fee for output token ßfor the OpenAI model.")
 
 url = 'https://openai.com/api/pricing/'
-crawler = WebCrawler()
+crawler = AsyncWebCrawler()
 crawler.warmup()
 
 result = crawler.run(

docs/tools/spider_tools.mdx

@@ -120,7 +120,7 @@ from praisonaiagents.tools import scrape_page, extract_links, crawl, extract_tex
 
 # Create search agent
 agent = Agent(
-    name="WebCrawler",
+    name="AsyncWebCrawler",
     role="Web Scraping Specialist",
     goal="Extract and analyze web content efficiently.",
     backstory="Expert in web scraping and content extraction.",

docs/ui/chat.mdx

@@ -155,7 +155,7 @@ To facilitate local development with live reload, you can use Docker. Follow the
 
     COPY . .
 
-    RUN pip install flask praisonai==2.2.19 watchdog
+    RUN pip install flask praisonai==2.2.22 watchdog
 
     EXPOSE 5555
 

docs/ui/code.mdx

@@ -208,7 +208,7 @@ To facilitate local development with live reload, you can use Docker. Follow the
 
     COPY . .
 
-    RUN pip install flask praisonai==2.2.19 watchdog
+    RUN pip install flask praisonai==2.2.22 watchdog
 
     EXPOSE 5555
 

examples/cookbooks/LangChain_PraisonAI_Agent_Notebook.ipynb

@@ -0,0 +1,373 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "M_G-1ig6-__z"
+      },
+      "source": [
+        "# LangChain Agent with PraisonAI\n",
+        "This notebook demonstrates how to use LangChain-compatible tools and PraisonAI agents to research AI-related topics using Wikipedia and YouTube.\n",
+        "\n",
+        "---"
+      ],
+      "id": "M_G-1ig6-__z"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ZVBvL3zK-__3"
+      },
+      "source": [
+        "##  Dependencies"
+      ],
+      "id": "ZVBvL3zK-__3"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "d7aUlkgM-__5"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install praisonaiagents langchain-community wikipedia youtube-search"
+      ],
+      "id": "d7aUlkgM-__5"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "sHNzy00Q-__6"
+      },
+      "source": [
+        "##  Set API Keys"
+      ],
+      "id": "sHNzy00Q-__6"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xCQvYxjK-__6"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "os.environ['OPENAI_API_KEY'] = 'your_api_key_here'"
+      ],
+      "id": "xCQvYxjK-__6"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1CDN1gXJ-__7"
+      },
+      "source": [
+        "##  Tools and Agents Setup"
+      ],
+      "id": "1CDN1gXJ-__7"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "pj6Djfhd-__7"
+      },
+      "outputs": [],
+      "source": [
+        "from praisonaiagents import Agent, Task, PraisonAIAgents\n",
+        "from langchain_community.utilities import WikipediaAPIWrapper\n",
+        "from langchain_community.tools import YouTubeSearchTool\n",
+        "\n",
+        "wiki_agent = Agent(\n",
+        "    name=\"WikiAgent\",\n",
+        "    role=\"Research Assistant\",\n",
+        "    goal=\"Search Wikipedia for accurate information\",\n",
+        "    backstory=\"I am an AI assistant specialized in Wikipedia research\",\n",
+        "    tools=[WikipediaAPIWrapper],\n",
+        "    self_reflect=False\n",
+        ")\n",
+        "\n",
+        "youtube_agent = Agent(\n",
+        "    name=\"SearchAgent\",\n",
+        "    role=\"Research Assistant\",\n",
+        "    goal=\"Search for information from YouTube\",\n",
+        "    backstory=\"I am an AI assistant that can search YouTube for relevant videos.\",\n",
+        "    tools=[YouTubeSearchTool],\n",
+        "    self_reflect=False\n",
+        ")"
+      ],
+      "id": "pj6Djfhd-__7"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "X5YJSOPO-__8"
+      },
+      "source": [
+        "##  Prompt and Tasks"
+      ],
+      "id": "X5YJSOPO-__8"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "dC2fi8ZF-__9"
+      },
+      "outputs": [],
+      "source": [
+        "task1 = Task(\n",
+        "    name=\"wiki_task\",\n",
+        "    description=\"Research 'Artificial Intelligence' on Wikipedia\",\n",
+        "    expected_output=\"Comprehensive information from Wikipedia articles\",\n",
+        "    agent=wiki_agent\n",
+        ")\n",
+        "\n",
+        "task2 = Task(\n",
+        "    name=\"search_task\",\n",
+        "    description=\"Search for information about 'AI advancements' on YouTube\",\n",
+        "    expected_output=\"Relevant information from YouTube videos\",\n",
+        "    agent=youtube_agent\n",
+        ")"
+      ],
+      "id": "dC2fi8ZF-__9"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YMFbVVTF-__-"
+      },
+      "source": [
+        "##  Main Agent Execution"
+      ],
+      "id": "YMFbVVTF-__-"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "80jMkenz-__-"
+      },
+      "outputs": [],
+      "source": [
+        "agents = PraisonAIAgents(\n",
+        "    agents=[wiki_agent, youtube_agent],\n",
+        "    tasks=[task1, task2],\n",
+        "    verbose=True\n",
+        ")\n",
+        "agents.start()"
+      ],
+      "id": "80jMkenz-__-"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "O13iiPNE-__-"
+      },
+      "source": [
+        "#  LangChain Agent Outputs"
+      ],
+      "id": "O13iiPNE-__-"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6bL4CxKD-___"
+      },
+      "source": [
+        "## 1. Wikipedia Agent Output\n",
+        "\n",
+        "### Artificial Intelligence (AI)\n",
+        "\n",
+        "Artificial intelligence (AI) refers to the capability of computational systems to perform tasks typically associated with human intelligence, such as learning, reasoning, problem-solving, perception, and decision-making. It is a field of research in computer science focused on developing methods and software that enable machines to perceive their environment and use learning and intelligence to take actions that maximize their chances of achieving defined goals.\n",
+        "\n",
+        "**Applications of AI:**\n",
+        "- Advanced web search engines (e.g., Google Search)\n",
+        "- Recommendation systems (e.g., YouTube, Amazon, Netflix)\n",
+        "- Virtual assistants (e.g., Google Assistant, Siri, Alexa)\n",
+        "- Autonomous vehicles (e.g., Waymo)\n",
+        "- Generative and creative tools (e.g., ChatGPT, AI art)\n",
+        "- Superhuman play and analysis in strategy games (e.g., chess, Go)\n",
+        "\n",
+        "**Subfields and Techniques:**\n",
+        "AI research is centered around goals such as learning, reasoning, knowledge representation, planning, natural language processing, perception, and robotics support. Techniques include search and mathematical optimization, formal logic, artificial neural networks, and methods based on statistics, operations research, and economics. AI also draws from psychology, linguistics, philosophy, neuroscience, and other fields.\n",
+        "\n",
+        "**History and Development:**\n",
+        "AI was founded as an academic discipline in 1956. The field has experienced cycles of optimism and disappointment, known as AI winters. Interest and funding increased significantly after 2012 with the use of graphics processing units to accelerate neural networks and the success of deep learning. The AI boom in the 2020s was marked by advanced generative AI, raising ethical concerns and discussions about regulatory policies.\n",
+        "\n",
+        "**Artificial General Intelligence (AGI):**\n",
+        "AGI, or human-level intelligence AI, would match or surpass human capabilities across virtually all cognitive tasks. Some researchers believe that current large language models show early signs of AGI-level capability, while others argue that genuine AGI has not yet been achieved. AGI is distinct from artificial superintelligence (ASI), which would outperform human abilities across every domain. Unlike artificial narrow intelligence (ANI), AGI can generalize knowledge, transfer skills between domains, and solve novel problems without task-specific reprogramming.\n",
+        "\n",
+        "Creating AGI is a major goal for companies like OpenAI, Google DeepMind, and Meta, aiming to develop AI that can complete virtually any cognitive task as well as a human."
+      ],
+      "id": "6bL4CxKD-___"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lS0gvGjK-___"
+      },
+      "source": [
+        "## 2. Web Search Agent Output\n",
+        "\n",
+        "### Latest AI Developments\n",
+        "\n",
+        "New Technologies in AI: Chatbots and Virtual Assistants are personalizing user experiences by analyzing user data and behavior, recommending products, content, and services, which increases engagement and sales."
+      ],
+      "id": "lS0gvGjK-___"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "yJqv-2Vf-___"
+      },
+      "source": [
+        "## 3. Agent Interaction Details\n",
+        "\n",
+        "**Wikipedia Agent Info:**  \n",
+        "👤 Agent: WikiAgent  \n",
+        "Role: Research Assistant  \n",
+        "Tools: WikipediaAPIWrapper\n",
+        "\n",
+        "**Web Search Agent Info:**  \n",
+        "👤 Agent: SearchAgent  \n",
+        "Role: Research Assistant  \n",
+        "Tools: YouTubeSearchTool\n",
+        "\n",
+        "**Performance Metrics:**\n",
+        "- Wikipedia Agent Response Time: 15.4 seconds\n",
+        "- Web Search Agent Response Time: 5.7 seconds"
+      ],
+      "id": "yJqv-2Vf-___"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Yv5abx7e-___"
+      },
+      "source": [
+        "##  LangChain Tools with Wrappers"
+      ],
+      "id": "Yv5abx7e-___"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3UywakPF-___"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install langchain-community google-search-results"
+      ],
+      "id": "3UywakPF-___"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "otWS3SV0_AAA"
+      },
+      "outputs": [],
+      "source": [
+        "os.environ['SERPAPI_API_KEY'] = 'your_serpapi_key_here'"
+      ],
+      "id": "otWS3SV0_AAA"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "TE46xk8A_AAB"
+      },
+      "outputs": [],
+      "source": [
+        "from langchain_community.utilities import SerpAPIWrapper\n",
+        "\n",
+        "data_agent = Agent(\n",
+        "    instructions=\"Search about AI job trends in 2025\",\n",
+        "    tools=[SerpAPIWrapper]\n",
+        ")\n",
+        "editor_agent = Agent(instructions=\"Write a blog article\")\n",
+        "\n",
+        "agents = PraisonAIAgents(agents=[data_agent, editor_agent])\n",
+        "agents.start()"
+      ],
+      "id": "TE46xk8A_AAB"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "2BqJBqaU_AAB"
+      },
+      "source": [
+        "##  Example Without Wrapper (Brave Search)"
+      ],
+      "id": "2BqJBqaU_AAB"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "MxGyDSqY_AAC"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install langchain-community"
+      ],
+      "id": "MxGyDSqY_AAC"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ZoD_erO__AAC"
+      },
+      "outputs": [],
+      "source": [
+        "os.environ['BRAVE_SEARCH_API'] = 'your_brave_api_key_here'"
+      ],
+      "id": "ZoD_erO__AAC"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "-TQfJWzw_AAC"
+      },
+      "outputs": [],
+      "source": [
+        "from langchain_community.tools import BraveSearch\n",
+        "\n",
+        "def search_brave(query: str):\n",
+        "    api_key = os.environ['BRAVE_SEARCH_API']\n",
+        "    tool = BraveSearch.from_api_key(api_key=api_key, search_kwargs={\"count\": 3})\n",
+        "    return tool.run(query)\n",
+        "\n",
+        "data_agent = Agent(instructions=\"Search about AI job trends in 2025\", tools=[search_brave])\n",
+        "editor_agent = Agent(instructions=\"Write a blog article\")\n",
+        "\n",
+        "agents = PraisonAIAgents(agents=[data_agent, editor_agent])\n",
+        "agents.start()"
+      ],
+      "id": "-TQfJWzw_AAC"
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

examples/cookbooks/yaml/article_generation_agents.ipynb

@@ -7,7 +7,7 @@
       },
       "source": [
         "# Article Generation Agents\n",
-        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MervinPraison/PraisonAI/blob/main/cookbooks/notebooks/article_generation_agents.ipynb)"
+        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MervinPraison/PraisonAI/blob/main/examples/cookbooks/yaml/article_generation_agents.ipynb)"
       ]
     },
     {
@@ -609,4 +609,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 0
-}
+}

examples/cookbooks/yaml/model_fee_retreival_agents.ipynb

@@ -51,7 +51,7 @@
    },
    "outputs": [],
    "source": [
-    "from crawl4ai import WebCrawler\n",
+    "from crawl4ai import AsyncWebCrawler\n",
     "from crawl4ai.extraction_strategy import LLMExtractionStrategy\n",
     "from pydantic import BaseModel, Field\n",
     "from praisonai_tools import BaseTool\n",
@@ -66,7 +66,7 @@
     "    description: str = \"Extracts model fees for input and output tokens from the given pricing page.\"\n",
     "\n",
     "    def _run(self, url: str):\n",
-    "        crawler = WebCrawler()\n",
+    "        crawler = AsyncWebCrawler()\n",
     "        crawler.warmup()\n",
     "\n",
     "        result = crawler.run(\n",
@@ -196,8 +196,8 @@
      "output_type": "stream",
      "text": [
       "[LOG] 🚀 Initializing LocalSeleniumCrawlerStrategy\n",
-      "[LOG] 🌤️  Warming up the WebCrawler\n",
-      "[LOG] 🌞 WebCrawler is ready to crawl\n",
+      "[LOG] 🌤️  Warming up the AsyncWebCrawler\n",
+      "[LOG] 🌞 AsyncWebCrawler is ready to crawl\n",
       "[LOG] 🚀 Crawling done for https://openai.com/api/pricing/, success: True, time taken: 0.86 seconds\n",
       "[LOG] 🚀 Content extracted for https://openai.com/api/pricing/, success: True, time taken: 0.01 seconds\n",
       "[LOG] 🔥 Extracting semantic blocks for https://openai.com/api/pricing/, Strategy: LLMExtractionStrategy\n",
@@ -245,8 +245,8 @@
      "output_type": "stream",
      "text": [
       "[LOG] 🚀 Initializing LocalSeleniumCrawlerStrategy\n",
-      "[LOG] 🌤️  Warming up the WebCrawler\n",
-      "[LOG] 🌞 WebCrawler is ready to crawl\n",
+      "[LOG] 🌤️  Warming up the AsyncWebCrawler\n",
+      "[LOG] 🌞 AsyncWebCrawler is ready to crawl\n",
       "[LOG] 🚀 Crawling done for https://www.anthropic.com/pricing, success: True, time taken: 2.93 seconds\n",
       "[LOG] 🚀 Content extracted for https://www.anthropic.com/pricing, success: True, time taken: 0.06 seconds\n",
       "[LOG] 🔥 Extracting semantic blocks for https://www.anthropic.com/pricing, Strategy: LLMExtractionStrategy\n",
@@ -323,8 +323,8 @@
      "output_type": "stream",
      "text": [
       "[LOG] 🚀 Initializing LocalSeleniumCrawlerStrategy\n",
-      "[LOG] 🌤️  Warming up the WebCrawler\n",
-      "[LOG] 🌞 WebCrawler is ready to crawl\n",
+      "[LOG] 🌤️  Warming up the AsyncWebCrawler\n",
+      "[LOG] 🌞 AsyncWebCrawler is ready to crawl\n",
       "[LOG] 🚀 Crawling done for https://cohere.com/pricing, success: True, time taken: 6.34 seconds\n",
       "[LOG] 🚀 Content extracted for https://cohere.com/pricing, success: True, time taken: 0.14 seconds\n",
       "[LOG] 🔥 Extracting semantic blocks for https://cohere.com/pricing, Strategy: LLMExtractionStrategy\n",

examples/cookbooks/yaml/secondary_market_research_agents.ipynb

@@ -0,0 +1,640 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1",
+   "metadata": {},
+   "source": [
+    "# Secondary Market Research Agents\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/MervinPraison/PraisonAI/blob/main/cookbooks/notebooks/secondary_market_research_agents.ipynb)\n",
+    "\n",
+    "This notebook demonstrates how to create a comprehensive secondary market research system using PraisonAI agents. The system generates detailed reports with customizable parameters for company, geography, and industry analysis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2", 
+   "metadata": {},
+   "source": [
+    "## Features\n",
+    "\n",
+    "- **Multi-agent Research System**: Specialized agents for different research areas\n",
+    "- **Customizable Parameters**: Company, geography, industry, and research sections\n",
+    "- **Comprehensive Reports**: Market overview, competitive analysis, financial performance, growth opportunities, and risk assessment\n",
+    "- **FastAPI Integration**: Ready for production deployment\n",
+    "- **Structured Output**: Professional report format suitable for business decision-making"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3",
+   "metadata": {},
+   "source": [
+    "## Installation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install required dependencies\n",
+    "%pip install praisonai[crewai] > /dev/null\n",
+    "%pip install fastapi uvicorn > /dev/null\n",
+    "%pip install requests > /dev/null"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5",
+   "metadata": {},
+   "source": [
+    "## Setup API Key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from google.colab import userdata\n",
+    "\n",
+    "# Set up OpenAI API key (add to Google Colab secrets)\n",
+    "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY') or \"ENTER OPENAI_API_KEY HERE\"\n",
+    "os.environ[\"OPENAI_MODEL_NAME\"] = \"gpt-4o-mini\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7",
+   "metadata": {},
+   "source": [
+    "## Method 1: Using YAML Configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# YAML configuration for market research agents\n",
+    "agent_yaml = \"\"\"\n",
+    "framework: \"crewai\"\n",
+    "topic: \"Secondary Market Research Analysis\"\n",
+    "\n",
+    "# Configuration variables\n",
+    "variables:\n",
+    "  company: \"Tesla\"\n",
+    "  geography: \"North America\" \n",
+    "  industry: \"Electric Vehicles\"\n",
+    "\n",
+    "roles:\n",
+    "  market_overview_specialist:\n",
+    "    role: \"Market Overview Specialist\" \n",
+    "    backstory: |\n",
+    "      You are a seasoned market research analyst with 10+ years of experience \n",
+    "      in analyzing market dynamics, trends, and growth patterns.\n",
+    "    goal: |\n",
+    "      Analyze the {industry} market in {geography} to provide comprehensive \n",
+    "      market overview including size, trends, and growth drivers.\n",
+    "    verbose: true\n",
+    "    allow_delegation: false\n",
+    "    tools:\n",
+    "      - \"InternetSearchTool\"\n",
+    "    tasks:\n",
+    "      market_overview_research:\n",
+    "        description: |\n",
+    "          Conduct comprehensive market overview research for {industry} in {geography}:\n",
+    "          1. Market size and valuation analysis\n",
+    "          2. Key growth trends and patterns\n",
+    "          3. Primary market drivers\n",
+    "          4. Market segmentation\n",
+    "        expected_output: |\n",
+    "          A comprehensive market overview report with quantitative data and insights.\n",
+    "\n",
+    "  competitive_intelligence_analyst:\n",
+    "    role: \"Competitive Intelligence Analyst\"\n",
+    "    backstory: |\n",
+    "      You are a competitive intelligence expert specializing in analyzing \n",
+    "      competitive landscapes and market positioning.\n",
+    "    goal: |\n",
+    "      Analyze {company}'s competitive landscape in the {industry} market.\n",
+    "    verbose: true\n",
+    "    allow_delegation: false\n",
+    "    tools:\n",
+    "      - \"InternetSearchTool\"\n",
+    "    tasks:\n",
+    "      competitive_analysis:\n",
+    "        description: |\n",
+    "          Conduct detailed competitive analysis for {company}:\n",
+    "          1. Identify top 5-7 competitors\n",
+    "          2. Market share analysis\n",
+    "          3. Competitive positioning\n",
+    "          4. Strengths and weaknesses\n",
+    "        expected_output: |\n",
+    "          A comprehensive competitive intelligence report.\n",
+    "\n",
+    "  financial_performance_analyst:\n",
+    "    role: \"Financial Performance Analyst\"\n",
+    "    backstory: |\n",
+    "      You are a financial analyst with expertise in corporate finance \n",
+    "      and industry benchmarking.\n",
+    "    goal: |\n",
+    "      Analyze {company}'s financial performance and industry benchmarks.\n",
+    "    verbose: true\n",
+    "    allow_delegation: false\n",
+    "    tools:\n",
+    "      - \"InternetSearchTool\"\n",
+    "    tasks:\n",
+    "      financial_analysis:\n",
+    "        description: |\n",
+    "          Conduct financial performance analysis for {company}:\n",
+    "          1. Revenue trends and growth\n",
+    "          2. Profitability metrics\n",
+    "          3. Financial ratios\n",
+    "          4. Industry benchmarking\n",
+    "        expected_output: |\n",
+    "          A detailed financial performance analysis report.\n",
+    "\n",
+    "  research_report_synthesizer:\n",
+    "    role: \"Research Report Synthesizer\"\n",
+    "    backstory: |\n",
+    "      You are an expert business report writer specializing in \n",
+    "      synthesizing complex research into actionable insights.\n",
+    "    goal: |\n",
+    "      Create a comprehensive secondary market research report for {company}.\n",
+    "    verbose: true\n",
+    "    allow_delegation: false\n",
+    "    tasks:\n",
+    "      report_synthesis:\n",
+    "        description: |\n",
+    "          Synthesize all research findings into a comprehensive report:\n",
+    "          1. Executive Summary\n",
+    "          2. Market Overview\n",
+    "          3. Competitive Analysis\n",
+    "          4. Financial Performance\n",
+    "          5. Conclusions and Recommendations\n",
+    "        expected_output: |\n",
+    "          A complete, professionally formatted secondary market research report.\n",
+    "        context:\n",
+    "          - \"market_overview_research\"\n",
+    "          - \"competitive_analysis\" \n",
+    "          - \"financial_analysis\"\n",
+    "\n",
+    "dependencies:\n",
+    "  - market_overview_specialist\n",
+    "  - competitive_intelligence_analyst\n",
+    "  - financial_performance_analyst\n",
+    "  - research_report_synthesizer\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import required libraries\n",
+    "from praisonai import PraisonAI\n",
+    "from praisonai_tools import BaseTool\n",
+    "from duckduckgo_search import DDGS\n",
+    "import requests\n",
+    "from bs4 import BeautifulSoup\n",
+    "\n",
+    "# Create internet search tool\n",
+    "class InternetSearchTool(BaseTool):\n",
+    "    name: str = \"InternetSearchTool\"\n",
+    "    description: str = \"Search Internet for relevant information\"\n",
+    "\n",
+    "    def _run(self, query: str):\n",
+    "        ddgs = DDGS()\n",
+    "        results = ddgs.text(keywords=query, region='wt-wt', safesearch='moderate', max_results=5)\n",
+    "        return results\n",
+    "\n",
+    "# Create PraisonAI instance\n",
+    "praisonai = PraisonAI(agent_yaml=agent_yaml, tools=[InternetSearchTool])\n",
+    "\n",
+    "# Run the market research\n",
+    "print(\"🔍 Starting Secondary Market Research for Tesla...\")\n",
+    "result = praisonai.run()\n",
+    "\n",
+    "print(\"\\n📋 Market Research Complete!\")\n",
+    "print(\"=\" * 60)\n",
+    "print(result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10",
+   "metadata": {},
+   "source": [
+    "## Method 2: Using Python API with Custom Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import the market research system\n",
+    "from praisonaiagents import Agent, Task, PraisonAIAgents, Tools\n",
+    "from typing import Dict, List, Any\n",
+    "import asyncio\n",
+    "from datetime import datetime\n",
+    "\n",
+    "class MarketResearchConfig:\n",
+    "    \"\"\"Configuration for market research parameters\"\"\"\n",
+    "    \n",
+    "    def __init__(self, company: str, geography: str, industry: str, sections: List[str]):\n",
+    "        self.company = company\n",
+    "        self.geography = geography\n",
+    "        self.industry = industry\n",
+    "        self.sections = sections\n",
+    "        self.timestamp = datetime.now().isoformat()\n",
+    "\n",
+    "def create_market_research_agents(config: MarketResearchConfig):\n",
+    "    \"\"\"Create specialized market research agents\"\"\"\n",
+    "    \n",
+    "    agents = {}\n",
+    "    \n",
+    "    if \"market_overview\" in config.sections:\n",
+    "        agents[\"market_overview\"] = Agent(\n",
+    "            name=\"Market Overview Specialist\",\n",
+    "            role=\"Market Analysis Expert\",\n",
+    "            goal=f\"Analyze the {config.industry} market in {config.geography}\",\n",
+    "            instructions=f\"\"\"\n",
+    "            Analyze market size, trends, growth drivers for {config.industry} in {config.geography}.\n",
+    "            Provide quantitative data and cite reliable sources.\n",
+    "            \"\"\",\n",
+    "            tools=[Tools.internet_search],\n",
+    "            verbose=True\n",
+    "        )\n",
+    "    \n",
+    "    if \"competitive_analysis\" in config.sections:\n",
+    "        agents[\"competitive\"] = Agent(\n",
+    "            name=\"Competitive Intelligence Analyst\",\n",
+    "            role=\"Competition Research Expert\", \n",
+    "            goal=f\"Analyze {config.company}'s competitive landscape\",\n",
+    "            instructions=f\"\"\"\n",
+    "            Analyze {config.company}'s competitive position in {config.industry}.\n",
+    "            Identify key competitors, market share, and competitive advantages.\n",
+    "            \"\"\",\n",
+    "            tools=[Tools.internet_search],\n",
+    "            verbose=True\n",
+    "        )\n",
+    "    \n",
+    "    if \"financial_performance\" in config.sections:\n",
+    "        agents[\"financial\"] = Agent(\n",
+    "            name=\"Financial Performance Analyst\", \n",
+    "            role=\"Financial Research Expert\",\n",
+    "            goal=f\"Analyze {config.company}'s financial performance\",\n",
+    "            instructions=f\"\"\"\n",
+    "            Research {config.company}'s financial performance, revenue trends,\n",
+    "            profitability, and compare with industry benchmarks.\n",
+    "            \"\"\",\n",
+    "            tools=[Tools.internet_search],\n",
+    "            verbose=True\n",
+    "        )\n",
+    "    \n",
+    "    if \"growth_opportunities\" in config.sections:\n",
+    "        agents[\"growth\"] = Agent(\n",
+    "            name=\"Growth Opportunities Researcher\",\n",
+    "            role=\"Strategic Growth Expert\",\n",
+    "            goal=f\"Identify growth opportunities for {config.company}\",\n",
+    "            instructions=f\"\"\"\n",
+    "            Identify emerging opportunities, market gaps, expansion possibilities\n",
+    "            for {config.company} in {config.industry}.\n",
+    "            \"\"\",\n",
+    "            tools=[Tools.internet_search],\n",
+    "            verbose=True\n",
+    "        )\n",
+    "    \n",
+    "    # Always include synthesizer\n",
+    "    agents[\"synthesizer\"] = Agent(\n",
+    "        name=\"Research Report Synthesizer\",\n",
+    "        role=\"Report Writing Expert\",\n",
+    "        goal=\"Synthesize research into comprehensive report\",\n",
+    "        instructions=f\"\"\"\n",
+    "        Create a professional secondary market research report for {config.company} \n",
+    "        in {config.industry} with clear structure and actionable recommendations.\n",
+    "        \"\"\",\n",
+    "        verbose=True\n",
+    "    )\n",
+    "    \n",
+    "    return agents\n",
+    "\n",
+    "def create_research_tasks(agents: Dict[str, Agent], config: MarketResearchConfig):\n",
+    "    \"\"\"Create research tasks for the agents\"\"\"\n",
+    "    \n",
+    "    tasks = []\n",
+    "    \n",
+    "    if \"market_overview\" in config.sections and \"market_overview\" in agents:\n",
+    "        market_task = Task(\n",
+    "            name=\"market_overview_research\",\n",
+    "            description=f\"Research {config.industry} market overview in {config.geography}\",\n",
+    "            expected_output=\"Market overview analysis with key metrics and trends\",\n",
+    "            agent=agents[\"market_overview\"]\n",
+    "        )\n",
+    "        tasks.append(market_task)\n",
+    "    \n",
+    "    if \"competitive_analysis\" in config.sections and \"competitive\" in agents:\n",
+    "        competitive_task = Task(\n",
+    "            name=\"competitive_analysis\",\n",
+    "            description=f\"Analyze competitive landscape for {config.company}\",\n",
+    "            expected_output=\"Competitive analysis with key competitors and positioning\",\n",
+    "            agent=agents[\"competitive\"]\n",
+    "        )\n",
+    "        tasks.append(competitive_task)\n",
+    "    \n",
+    "    if \"financial_performance\" in config.sections and \"financial\" in agents:\n",
+    "        financial_task = Task(\n",
+    "            name=\"financial_analysis\",\n",
+    "            description=f\"Analyze {config.company}'s financial performance\",\n",
+    "            expected_output=\"Financial performance analysis with key metrics\",\n",
+    "            agent=agents[\"financial\"]\n",
+    "        )\n",
+    "        tasks.append(financial_task)\n",
+    "    \n",
+    "    if \"growth_opportunities\" in config.sections and \"growth\" in agents:\n",
+    "        growth_task = Task(\n",
+    "            name=\"growth_opportunities\",\n",
+    "            description=f\"Identify growth opportunities for {config.company}\",\n",
+    "            expected_output=\"Growth opportunities with strategic recommendations\",\n",
+    "            agent=agents[\"growth\"]\n",
+    "        )\n",
+    "        tasks.append(growth_task)\n",
+    "    \n",
+    "    # Synthesis task\n",
+    "    synthesis_task = Task(\n",
+    "        name=\"synthesis\",\n",
+    "        description=\"Synthesize all findings into comprehensive report\",\n",
+    "        expected_output=\"Complete secondary market research report\",\n",
+    "        agent=agents[\"synthesizer\"],\n",
+    "        context=tasks\n",
+    "    )\n",
+    "    tasks.append(synthesis_task)\n",
+    "    \n",
+    "    return tasks\n",
+    "\n",
+    "async def run_market_research(config: MarketResearchConfig):\n",
+    "    \"\"\"Run the complete market research workflow\"\"\"\n",
+    "    \n",
+    "    print(f\"🔍 Starting Market Research for {config.company}\")\n",
+    "    print(f\"📍 Geography: {config.geography}\")\n",
+    "    print(f\"🏭 Industry: {config.industry}\")\n",
+    "    print(f\"📊 Sections: {', '.join(config.sections)}\")\n",
+    "    print(\"=\" * 60)\n",
+    "    \n",
+    "    # Create agents and tasks\n",
+    "    agents = create_market_research_agents(config)\n",
+    "    tasks = create_research_tasks(agents, config)\n",
+    "    \n",
+    "    # Create workflow\n",
+    "    workflow = PraisonAIAgents(\n",
+    "        agents=list(agents.values()),\n",
+    "        tasks=tasks,\n",
+    "        process=\"workflow\",\n",
+    "        verbose=True\n",
+    "    )\n",
+    "    \n",
+    "    # Execute research\n",
+    "    results = await workflow.astart()\n",
+    "    \n",
+    "    return results\n",
+    "\n",
+    "# Example with custom parameters\n",
+    "custom_config = MarketResearchConfig(\n",
+    "    company=\"Apple\",\n",
+    "    geography=\"Global\", \n",
+    "    industry=\"Consumer Electronics\",\n",
+    "    sections=[\"market_overview\", \"competitive_analysis\", \"financial_performance\"]\n",
+    ")\n",
+    "\n",
+    "# Run the research\n",
+    "print(\"🚀 Running Custom Market Research...\")\n",
+    "custom_results = await run_market_research(custom_config)\n",
+    "\n",
+    "print(\"\\n📋 Research Complete!\")\n",
+    "print(\"=\" * 60)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12",
+   "metadata": {},
+   "source": [
+    "## Method 3: FastAPI Integration Example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example of using the FastAPI endpoint\n",
+    "import requests\n",
+    "import json\n",
+    "import time\n",
+    "\n",
+    "# Note: This requires the FastAPI server to be running\n",
+    "# Run: uvicorn secondary-market-research-api:app --reload --port 8000\n",
+    "\n",
+    "API_BASE_URL = \"http://localhost:8000\"  # Change if running elsewhere\n",
+    "\n",
+    "def generate_report_via_api(company, geography, industry, sections):\n",
+    "    \"\"\"Generate market research report via API\"\"\"\n",
+    "    \n",
+    "    # Prepare request\n",
+    "    request_data = {\n",
+    "        \"company\": company,\n",
+    "        \"geography\": geography,\n",
+    "        \"industry\": industry,\n",
+    "        \"sections\": sections,\n",
+    "        \"format\": \"json\"\n",
+    "    }\n",
+    "    \n",
+    "    print(f\"📤 Submitting research request for {company}...\")\n",
+    "    \n",
+    "    # Submit research request\n",
+    "    response = requests.post(f\"{API_BASE_URL}/research/generate\", json=request_data)\n",
+    "    \n",
+    "    if response.status_code == 200:\n",
+    "        job_data = response.json()\n",
+    "        job_id = job_data[\"job_id\"]\n",
+    "        print(f\"✅ Job submitted successfully. Job ID: {job_id}\")\n",
+    "        \n",
+    "        # Poll for completion\n",
+    "        print(\"⏳ Waiting for completion...\")\n",
+    "        while True:\n",
+    "            status_response = requests.get(f\"{API_BASE_URL}/research/status/{job_id}\")\n",
+    "            if status_response.status_code == 200:\n",
+    "                status_data = status_response.json()\n",
+    "                print(f\"📊 Progress: {status_data['progress']}% - {status_data['message']}\")\n",
+    "                \n",
+    "                if status_data[\"status\"] == \"completed\":\n",
+    "                    print(\"🎉 Research completed!\")\n",
+    "                    \n",
+    "                    # Download report\n",
+    "                    report_response = requests.get(f\"{API_BASE_URL}/research/reports/{job_id}\")\n",
+    "                    if report_response.status_code == 200:\n",
+    "                        return report_response.json()\n",
+    "                    else:\n",
+    "                        print(\"❌ Failed to download report\")\n",
+    "                        return None\n",
+    "                        \n",
+    "                elif status_data[\"status\"] == \"failed\":\n",
+    "                    print(f\"❌ Research failed: {status_data.get('error', 'Unknown error')}\")\n",
+    "                    return None\n",
+    "                    \n",
+    "                time.sleep(5)  # Wait 5 seconds before checking again\n",
+    "            else:\n",
+    "                print(\"❌ Failed to check status\")\n",
+    "                return None\n",
+    "    else:\n",
+    "        print(f\"❌ Failed to submit request: {response.status_code}\")\n",
+    "        return None\n",
+    "\n",
+    "# Example API usage (uncomment to run with API server)\n",
+    "# report = generate_report_via_api(\n",
+    "#     company=\"Microsoft\",\n",
+    "#     geography=\"Global\",\n",
+    "#     industry=\"Cloud Computing\",\n",
+    "#     sections=[\"market_overview\", \"competitive_analysis\"]\n",
+    "# )\n",
+    "# \n",
+    "# if report:\n",
+    "#     print(\"\\n📋 Generated Report:\")\n",
+    "#     print(json.dumps(report, indent=2)[:1000] + \"...\")\n",
+    "\n",
+    "print(\"💡 API integration example ready. Start the FastAPI server to test.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "14",
+   "metadata": {},
+   "source": [
+    "## Customization Examples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example configurations for different industries and regions\n",
+    "\n",
+    "research_examples = {\n",
+    "    \"tech_startup\": {\n",
+    "        \"company\": \"OpenAI\",\n",
+    "        \"geography\": \"United States\",\n",
+    "        \"industry\": \"Artificial Intelligence\",\n",
+    "        \"sections\": [\"market_overview\", \"competitive_analysis\", \"growth_opportunities\"]\n",
+    "    },\n",
+    "    \"automotive\": {\n",
+    "        \"company\": \"BMW\",\n",
+    "        \"geography\": \"Europe\",\n",
+    "        \"industry\": \"Luxury Automobiles\",\n",
+    "        \"sections\": [\"market_overview\", \"competitive_analysis\", \"financial_performance\", \"risk_assessment\"]\n",
+    "    },\n",
+    "    \"healthcare\": {\n",
+    "        \"company\": \"Pfizer\",\n",
+    "        \"geography\": \"Global\",\n",
+    "        \"industry\": \"Pharmaceuticals\",\n",
+    "        \"sections\": [\"market_overview\", \"competitive_analysis\", \"growth_opportunities\", \"risk_assessment\"]\n",
+    "    },\n",
+    "    \"fintech\": {\n",
+    "        \"company\": \"Square\",\n",
+    "        \"geography\": \"North America\",\n",
+    "        \"industry\": \"Financial Technology\",\n",
+    "        \"sections\": [\"market_overview\", \"competitive_analysis\", \"financial_performance\", \"growth_opportunities\"]\n",
+    "    },\n",
+    "    \"retail\": {\n",
+    "        \"company\": \"Alibaba\",\n",
+    "        \"geography\": \"Asia Pacific\",\n",
+    "        \"industry\": \"E-commerce\",\n",
+    "        \"sections\": [\"market_overview\", \"competitive_analysis\", \"financial_performance\", \"growth_opportunities\", \"risk_assessment\"]\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "print(\"📚 Research Configuration Examples:\")\n",
+    "print(\"=\" * 50)\n",
+    "\n",
+    "for example_name, config in research_examples.items():\n",
+    "    print(f\"\\n🔍 {example_name.upper()}:\")\n",
+    "    print(f\"   Company: {config['company']}\")\n",
+    "    print(f\"   Geography: {config['geography']}\")\n",
+    "    print(f\"   Industry: {config['industry']}\")\n",
+    "    print(f\"   Sections: {', '.join(config['sections'])}\")\n",
+    "\n",
+    "print(\"\\n💡 Use any of these configurations as templates for your research!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "This notebook demonstrates three different ways to use the Secondary Market Research Agent system:\n",
+    "\n",
+    "1. **YAML Configuration**: Easy to customize and modify research parameters\n",
+    "2. **Python API**: Programmatic control with custom configurations\n",
+    "3. **FastAPI Integration**: Production-ready REST API for web applications\n",
+    "\n",
+    "### Key Features:\n",
+    "- **Customizable Research Sections**: Choose from market overview, competitive analysis, financial performance, growth opportunities, and risk assessment\n",
+    "- **Geographic Flexibility**: Research any geographic region\n",
+    "- **Industry Agnostic**: Works across different industries and sectors\n",
+    "- **Professional Reports**: Generate business-ready research reports\n",
+    "- **Scalable Architecture**: Multi-agent system that can be extended\n",
+    "\n",
+    "### Use Cases:\n",
+    "- Market entry analysis\n",
+    "- Competitive intelligence\n",
+    "- Investment research\n",
+    "- Strategic planning\n",
+    "- Due diligence\n",
+    "\n",
+    "The system provides a comprehensive foundation for secondary market research that can be customized and extended based on specific business needs."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

examples/cookbooks/yaml/secondary_market_research_agents.yaml

@@ -0,0 +1,369 @@
+framework: "crewai"
+topic: "Secondary Market Research Analysis with Customizable Parameters"
+
+# Configuration variables for customization
+variables:
+  company: "Tesla"
+  geography: "North America" 
+  industry: "Electric Vehicles"
+  research_focus: "comprehensive market analysis"
+
+roles:
+  market_overview_specialist:
+    role: "Market Overview Specialist" 
+    backstory: |
+      You are a seasoned market research analyst with 10+ years of experience 
+      in analyzing market dynamics, trends, and growth patterns across various 
+      industries. You excel at synthesizing complex market data into clear, 
+      actionable insights for business decision-makers.
+    goal: |
+      Analyze the {industry} market in {geography} to provide comprehensive 
+      market overview including size, trends, growth drivers, and future projections.
+    verbose: true
+    allow_delegation: false
+    llm:
+      model: "gpt-4o-mini"
+      temperature: 0.3
+    tools:
+      - "InternetSearchTool"
+    tasks:
+      market_overview_research:
+        description: |
+          Conduct comprehensive market overview research for {industry} in {geography}:
+          
+          1. Market Size & Valuation:
+             - Current market size and historical growth
+             - Market valuation and revenue projections
+             - Geographic market distribution
+          
+          2. Market Trends:
+             - Key growth trends and patterns
+             - Emerging market developments
+             - Technology adoption rates
+          
+          3. Market Drivers:
+             - Primary growth drivers and catalysts
+             - Consumer behavior shifts
+             - Regulatory and policy impacts
+          
+          4. Market Segments:
+             - Key market segments and sub-sectors
+             - Segment performance and potential
+             - Customer demographics and preferences
+          
+          Research should include quantitative data, statistics, and cite reliable sources.
+        expected_output: |
+          A comprehensive market overview report containing:
+          - Executive summary of market status
+          - Detailed market size and growth analysis
+          - Key trends and drivers identification
+          - Market segmentation analysis
+          - Future market projections and opportunities
+          
+          Include relevant charts, statistics, and data sources.
+
+  competitive_intelligence_analyst:
+    role: "Competitive Intelligence Analyst"
+    backstory: |
+      You are a competitive intelligence expert specializing in analyzing 
+      competitive landscapes, market positioning, and strategic intelligence. 
+      You have deep expertise in competitor analysis, market share assessment, 
+      and competitive strategy evaluation.
+    goal: |
+      Analyze {company}'s competitive landscape in the {industry} market 
+      within {geography} to identify key competitors, market positioning, 
+      and competitive dynamics.
+    verbose: true
+    allow_delegation: false
+    llm:
+      model: "gpt-4o-mini" 
+      temperature: 0.3
+    tools:
+      - "InternetSearchTool"
+    tasks:
+      competitive_analysis:
+        description: |
+          Conduct detailed competitive analysis for {company} in {industry}:
+          
+          1. Competitor Identification:
+             - Identify top 5-7 direct competitors
+             - Include emerging and indirect competitors
+             - Analyze competitor profiles and backgrounds
+          
+          2. Market Share Analysis:
+             - Market share distribution among competitors
+             - {company}'s market position and ranking
+             - Market concentration and fragmentation
+          
+          3. Competitive Positioning:
+             - Value proposition comparison
+             - Product/service differentiation
+             - Pricing strategies and positioning
+          
+          4. Competitor Strengths & Weaknesses:
+             - SWOT analysis for key competitors
+             - Competitive advantages and disadvantages
+             - Performance comparison metrics
+          
+          5. Competitive Strategies:
+             - Go-to-market strategies
+             - Innovation and R&D approaches
+             - Partnership and acquisition strategies
+        expected_output: |
+          A comprehensive competitive intelligence report including:
+          - Competitive landscape overview
+          - Detailed competitor profiles (top 5-7)
+          - Market share analysis and positioning
+          - Competitive strengths/weaknesses matrix
+          - Strategic implications and recommendations
+
+  financial_performance_analyst:
+    role: "Financial Performance Analyst"
+    backstory: |
+      You are a financial analyst with expertise in corporate finance, 
+      financial statement analysis, and industry benchmarking. You specialize 
+      in analyzing financial performance metrics, trends, and comparative 
+      analysis within specific industry contexts.
+    goal: |
+      Analyze {company}'s financial performance, key metrics, and compare 
+      with industry benchmarks to assess financial health and performance trends.
+    verbose: true
+    allow_delegation: false
+    llm:
+      model: "gpt-4o-mini"
+      temperature: 0.3
+    tools:
+      - "InternetSearchTool"
+    tasks:
+      financial_analysis:
+        description: |
+          Conduct comprehensive financial performance analysis for {company}:
+          
+          1. Revenue Analysis:
+             - Revenue trends over last 3-5 years
+             - Revenue growth rates and patterns
+             - Revenue by segment/geography
+          
+          2. Profitability Metrics:
+             - Gross, operating, and net profit margins
+             - EBITDA and EBITDA margins
+             - Return on assets (ROA) and equity (ROE)
+          
+          3. Financial Ratios:
+             - Liquidity ratios (current, quick)
+             - Leverage ratios (debt-to-equity, interest coverage)
+             - Efficiency ratios (asset turnover, inventory turnover)
+          
+          4. Industry Benchmarking:
+             - Compare key metrics with industry averages
+             - Position against top competitors
+             - Identify performance gaps and advantages
+          
+          5. Financial Health Assessment:
+             - Cash flow analysis
+             - Debt levels and structure
+             - Financial stability indicators
+        expected_output: |
+          A detailed financial performance report containing:
+          - Financial performance summary and trends
+          - Key financial metrics and ratios analysis
+          - Industry benchmark comparison
+          - Financial strengths and areas for improvement
+          - Financial health assessment and outlook
+
+  growth_opportunities_researcher:
+    role: "Growth Opportunities Researcher"
+    backstory: |
+      You are a strategic business analyst specializing in identifying growth 
+      opportunities, market expansion strategies, and emerging business models. 
+      You excel at spotting trends, gaps, and untapped potential in markets 
+      and industries.
+    goal: |
+      Identify and analyze growth opportunities for {company} in {industry} 
+      within {geography}, including market expansion, innovation, and 
+      strategic development possibilities.
+    verbose: true
+    allow_delegation: false
+    llm:
+      model: "gpt-4o-mini"
+      temperature: 0.4
+    tools:
+      - "InternetSearchTool"
+    tasks:
+      growth_opportunities_analysis:
+        description: |
+          Identify comprehensive growth opportunities for {company}:
+          
+          1. Market Expansion:
+             - Geographic expansion opportunities
+             - New customer segments and demographics
+             - Untapped market niches
+          
+          2. Product/Service Innovation:
+             - New product development opportunities
+             - Service enhancement possibilities
+             - Technology integration opportunities
+          
+          3. Strategic Partnerships:
+             - Potential partnership opportunities
+             - Joint venture possibilities
+             - Acquisition targets and synergies
+          
+          4. Technology Advancement:
+             - Emerging technology adoption
+             - Digital transformation opportunities
+             - Innovation and R&D investments
+          
+          5. Market Trends Alignment:
+             - Emerging industry trends to leverage
+             - Consumer behavior shifts to capitalize on
+             - Regulatory changes creating opportunities
+        expected_output: |
+          A strategic growth opportunities report including:
+          - Prioritized growth opportunity matrix
+          - Market expansion analysis and recommendations
+          - Innovation and development opportunities
+          - Strategic partnership possibilities
+          - Implementation roadmap and timeline
+
+  risk_assessment_specialist:
+    role: "Risk Assessment Specialist"
+    backstory: |
+      You are a risk management expert with extensive experience in identifying, 
+      analyzing, and assessing business risks across various industries. You 
+      specialize in market risks, competitive threats, regulatory challenges, 
+      and operational risk assessment.
+    goal: |
+      Assess and analyze potential risks, challenges, and threats facing 
+      {company} in the {industry} market within {geography}.
+    verbose: true
+    allow_delegation: false
+    llm:
+      model: "gpt-4o-mini"
+      temperature: 0.3
+    tools:
+      - "InternetSearchTool"
+    tasks:
+      risk_assessment_analysis:
+        description: |
+          Conduct comprehensive risk assessment for {company}:
+          
+          1. Competitive Risks:
+             - New entrant threats
+             - Competitor aggressive strategies
+             - Market share erosion risks
+          
+          2. Market Risks:
+             - Market volatility and cyclicality
+             - Demand fluctuation risks
+             - Economic downturn impacts
+          
+          3. Regulatory Risks:
+             - Regulatory changes and compliance
+             - Policy shifts and government intervention
+             - Environmental and safety regulations
+          
+          4. Operational Risks:
+             - Supply chain vulnerabilities
+             - Technology and cybersecurity risks
+             - Talent and human capital risks
+          
+          5. Financial Risks:
+             - Currency and exchange rate risks
+             - Interest rate and inflation impacts
+             - Credit and liquidity risks
+          
+          6. Technology Disruption:
+             - Emerging technology threats
+             - Digital transformation challenges
+             - Innovation obsolescence risks
+        expected_output: |
+          A comprehensive risk assessment report including:
+          - Risk identification and categorization
+          - Risk impact and probability analysis
+          - Risk mitigation strategies and recommendations
+          - Risk monitoring and management framework
+          - Priority risk action plan
+
+  research_report_synthesizer:
+    role: "Research Report Synthesizer"
+    backstory: |
+      You are an expert business report writer and analyst with extensive 
+      experience in synthesizing complex research findings into clear, 
+      actionable business intelligence reports. You excel at creating 
+      comprehensive, well-structured reports for executive decision-making.
+    goal: |
+      Synthesize all research findings into a comprehensive, professional 
+      secondary market research report for {company} in {industry} that 
+      provides actionable insights for business decision-making.
+    verbose: true
+    allow_delegation: false
+    llm:
+      model: "gpt-4o-mini"
+      temperature: 0.3
+    tasks:
+      report_synthesis:
+        description: |
+          Create a comprehensive secondary market research report synthesizing 
+          all research findings:
+          
+          Report Structure:
+          1. Executive Summary
+             - Key findings overview
+             - Critical insights and implications
+             - Primary recommendations
+          
+          2. Market Overview
+             - Market size, trends, and dynamics
+             - Growth drivers and opportunities
+             - Market segmentation analysis
+          
+          3. Competitive Landscape
+             - Competitive positioning analysis
+             - Key competitor profiles
+             - Market share and dynamics
+          
+          4. Financial Performance
+             - Financial health assessment
+             - Performance benchmarking
+             - Financial trends and projections
+          
+          5. Growth Opportunities
+             - Strategic growth vectors
+             - Market expansion possibilities
+             - Innovation and development opportunities
+          
+          6. Risk Assessment
+             - Key risk factors and mitigation
+             - Challenge identification
+             - Risk management recommendations
+          
+          7. Conclusions and Recommendations
+             - Strategic recommendations
+             - Action priorities
+             - Implementation considerations
+          
+          Use professional formatting with clear headings, bullet points, and data visualization suggestions.
+        expected_output: |
+          A complete, professionally formatted secondary market research report containing:
+          - Executive summary with key insights
+          - Detailed analysis across all research areas
+          - Data-driven findings and conclusions
+          - Strategic recommendations and action items
+          - Professional formatting suitable for executive presentation
+          
+          The report should be 8-12 pages in length with clear structure and actionable intelligence.
+        context:
+          - "market_overview_research"
+          - "competitive_analysis" 
+          - "financial_analysis"
+          - "growth_opportunities_analysis"
+          - "risk_assessment_analysis"
+
+dependencies:
+  - market_overview_specialist
+  - competitive_intelligence_analyst
+  - financial_performance_analyst
+  - growth_opportunities_researcher
+  - risk_assessment_specialist
+  - research_report_synthesizer

examples/python/api/secondary-market-research-api.py

@@ -0,0 +1,528 @@
+"""
+Secondary Market Research FastAPI Application
+
+This FastAPI application provides a REST API for generating customized 
+secondary market research reports. Users can specify company, geography, 
+industry, and research sections to generate tailored reports.
+
+Features:
+- RESTful API endpoints for market research
+- Customizable research parameters
+- Async report generation
+- JSON and PDF report formats
+- Real-time progress tracking
+- Report history and caching
+
+Usage:
+    uvicorn secondary-market-research-api:app --reload --port 8000
+    
+    Then visit: http://localhost:8000/docs for API documentation
+"""
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks, Depends
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
+import asyncio
+import json
+import uuid
+from datetime import datetime
+import os
+from pathlib import Path
+
+# Import our market research system
+from praisonaiagents import Agent, Task, PraisonAIAgents, Tools
+
+# Create FastAPI app
+app = FastAPI(
+    title="Secondary Market Research API",
+    description="Generate customized secondary market research reports",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Create directories for storing reports
+REPORTS_DIR = Path("generated_reports")
+REPORTS_DIR.mkdir(exist_ok=True)
+
+# In-memory storage for job status (in production, use Redis or database)
+job_status = {}
+
+# Pydantic models for request/response
+class MarketResearchRequest(BaseModel):
+    """Request model for market research generation"""
+    company: str = Field(..., description="Company name to research", example="Tesla")
+    geography: str = Field(..., description="Geographic region", example="North America")
+    industry: str = Field(..., description="Industry sector", example="Electric Vehicles")
+    sections: Optional[List[str]] = Field(
+        default=["market_overview", "competitive_analysis", "financial_performance", "growth_opportunities", "risk_assessment"],
+        description="Research sections to include",
+        example=["market_overview", "competitive_analysis", "financial_performance"]
+    )
+    format: Optional[str] = Field(default="json", description="Output format: json or pdf", example="json")
+    email: Optional[str] = Field(None, description="Email for notification when complete", example="[email protected]")
+
+class MarketResearchResponse(BaseModel):
+    """Response model for market research request"""
+    job_id: str = Field(..., description="Unique job identifier")
+    status: str = Field(..., description="Job status: pending, running, completed, failed")
+    message: str = Field(..., description="Status message")
+    estimated_completion: Optional[str] = Field(None, description="Estimated completion time")
+
+class JobStatusResponse(BaseModel):
+    """Response model for job status check"""
+    job_id: str
+    status: str
+    progress: int = Field(..., description="Progress percentage (0-100)")
+    message: str
+    created_at: str
+    updated_at: str
+    result_url: Optional[str] = None
+    error: Optional[str] = None
+
+class MarketResearchConfig:
+    """Configuration class for market research parameters"""
+    
+    def __init__(self, company: str, geography: str, industry: str, sections: List[str]):
+        self.company = company
+        self.geography = geography
+        self.industry = industry
+        self.sections = sections
+        self.timestamp = datetime.now().isoformat()
+
+def create_market_research_agents(config: MarketResearchConfig):
+    """Create specialized market research agents"""
+    
+    agents = {}
+    
+    if "market_overview" in config.sections:
+        agents["market_overview"] = Agent(
+            name="Market Overview Specialist",
+            role="Market Analysis Expert",
+            goal=f"Analyze the {config.industry} market in {config.geography}",
+            instructions=f"""
+            Analyze market size, trends, growth drivers, and overall market dynamics for 
+            {config.industry} in {config.geography}. Provide quantitative data and cite sources.
+            """,
+            tools=[Tools.internet_search],
+            verbose=False
+        )
+    
+    if "competitive_analysis" in config.sections:
+        agents["competitive"] = Agent(
+            name="Competitive Intelligence Analyst",
+            role="Competition Research Expert", 
+            goal=f"Analyze {config.company}'s competitive landscape",
+            instructions=f"""
+            Analyze {config.company}'s competitive position in {config.industry} within {config.geography}.
+            Identify key competitors, market share, and competitive advantages.
+            """,
+            tools=[Tools.internet_search],
+            verbose=False
+        )
+    
+    if "financial_performance" in config.sections:
+        agents["financial"] = Agent(
+            name="Financial Performance Analyst", 
+            role="Financial Research Expert",
+            goal=f"Analyze {config.company}'s financial performance",
+            instructions=f"""
+            Research {config.company}'s financial performance, revenue trends, profitability,
+            and compare with industry benchmarks.
+            """,
+            tools=[Tools.internet_search],
+            verbose=False
+        )
+    
+    if "growth_opportunities" in config.sections:
+        agents["growth"] = Agent(
+            name="Growth Opportunities Researcher",
+            role="Strategic Growth Expert",
+            goal=f"Identify growth opportunities for {config.company}",
+            instructions=f"""
+            Identify emerging opportunities, market gaps, expansion possibilities for {config.company}
+            in {config.industry} within {config.geography}.
+            """,
+            tools=[Tools.internet_search],
+            verbose=False
+        )
+    
+    if "risk_assessment" in config.sections:
+        agents["risk"] = Agent(
+            name="Risk Assessment Specialist",
+            role="Risk Analysis Expert", 
+            goal=f"Assess risks for {config.company}",
+            instructions=f"""
+            Identify and analyze potential risks, challenges, and threats facing {config.company}
+            in {config.geography}. Consider regulatory, competitive, and market risks.
+            """,
+            tools=[Tools.internet_search],
+            verbose=False
+        )
+    
+    # Always include synthesizer
+    agents["synthesizer"] = Agent(
+        name="Research Report Synthesizer",
+        role="Report Writing Expert",
+        goal="Synthesize research into comprehensive report",
+        instructions=f"""
+        Create a professional secondary market research report for {config.company} 
+        in {config.industry} with clear structure, insights, and recommendations.
+        """,
+        verbose=False
+    )
+    
+    return agents
+
+def create_research_tasks(agents: Dict[str, Agent], config: MarketResearchConfig):
+    """Create research tasks for the agents"""
+    
+    tasks = []
+    
+    # Create tasks based on available sections
+    if "market_overview" in config.sections and "market_overview" in agents:
+        market_task = Task(
+            name="market_overview_research",
+            description=f"Research {config.industry} market overview in {config.geography}",
+            expected_output="Market overview analysis with key metrics and trends",
+            agent=agents["market_overview"]
+        )
+        tasks.append(market_task)
+    
+    if "competitive_analysis" in config.sections and "competitive" in agents:
+        competitive_task = Task(
+            name="competitive_analysis",
+            description=f"Analyze competitive landscape for {config.company}",
+            expected_output="Competitive analysis with key competitors and positioning",
+            agent=agents["competitive"]
+        )
+        tasks.append(competitive_task)
+    
+    if "financial_performance" in config.sections and "financial" in agents:
+        financial_task = Task(
+            name="financial_analysis",
+            description=f"Analyze {config.company}'s financial performance",
+            expected_output="Financial performance analysis with key metrics",
+            agent=agents["financial"]
+        )
+        tasks.append(financial_task)
+    
+    if "growth_opportunities" in config.sections and "growth" in agents:
+        growth_task = Task(
+            name="growth_opportunities",
+            description=f"Identify growth opportunities for {config.company}",
+            expected_output="Growth opportunities analysis with strategic recommendations",
+            agent=agents["growth"]
+        )
+        tasks.append(growth_task)
+    
+    if "risk_assessment" in config.sections and "risk" in agents:
+        risk_task = Task(
+            name="risk_assessment",
+            description=f"Assess risks for {config.company}",
+            expected_output="Risk assessment with mitigation strategies",
+            agent=agents["risk"]
+        )
+        tasks.append(risk_task)
+    
+    # Synthesis task
+    synthesis_task = Task(
+        name="synthesis",
+        description=f"Synthesize all findings into comprehensive report",
+        expected_output="Complete secondary market research report",
+        agent=agents["synthesizer"],
+        context=tasks
+    )
+    tasks.append(synthesis_task)
+    
+    return tasks
+
+async def generate_market_research_report(job_id: str, config: MarketResearchConfig):
+    """Background task to generate market research report"""
+    
+    try:
+        # Update job status
+        job_status[job_id]["status"] = "running"
+        job_status[job_id]["progress"] = 10
+        job_status[job_id]["message"] = "Creating research agents..."
+        job_status[job_id]["updated_at"] = datetime.now().isoformat()
+        
+        # Create agents and tasks
+        agents = create_market_research_agents(config)
+        tasks = create_research_tasks(agents, config)
+        
+        job_status[job_id]["progress"] = 20
+        job_status[job_id]["message"] = "Setting up research workflow..."
+        
+        # Create workflow
+        workflow = PraisonAIAgents(
+            agents=list(agents.values()),
+            tasks=tasks,
+            process="workflow",
+            verbose=False
+        )
+        
+        job_status[job_id]["progress"] = 30
+        job_status[job_id]["message"] = "Executing research workflow..."
+        
+        # Execute research
+        results = await workflow.astart()
+        
+        job_status[job_id]["progress"] = 90
+        job_status[job_id]["message"] = "Generating final report..."
+        
+        # Prepare final report
+        report_data = {
+            "metadata": {
+                "job_id": job_id,
+                "company": config.company,
+                "geography": config.geography,
+                "industry": config.industry,
+                "sections": config.sections,
+                "generated_at": datetime.now().isoformat()
+            },
+            "executive_summary": "Executive summary would be generated here...",
+            "research_findings": {}
+        }
+        
+        # Extract results from each task
+        if "task_results" in results:
+            for task_name, result in results["task_results"].items():
+                if result:
+                    report_data["research_findings"][task_name] = {
+                        "content": result.raw,
+                        "agent": result.agent if hasattr(result, 'agent') else "Unknown"
+                    }
+        
+        # Save report to file
+        report_filename = f"market_research_{job_id}.json"
+        report_path = REPORTS_DIR / report_filename
+        
+        with open(report_path, "w") as f:
+            json.dump(report_data, f, indent=2, default=str)
+        
+        # Update job status to completed
+        job_status[job_id]["status"] = "completed"
+        job_status[job_id]["progress"] = 100
+        job_status[job_id]["message"] = "Report generation completed successfully"
+        job_status[job_id]["result_url"] = f"/reports/{job_id}"
+        job_status[job_id]["updated_at"] = datetime.now().isoformat()
+        
+    except Exception as e:
+        # Update job status to failed
+        job_status[job_id]["status"] = "failed"
+        job_status[job_id]["error"] = str(e)
+        job_status[job_id]["message"] = f"Report generation failed: {str(e)}"
+        job_status[job_id]["updated_at"] = datetime.now().isoformat()
+
+# API Endpoints
+
+@app.get("/", summary="API Health Check")
+async def root():
+    """Health check endpoint"""
+    return {
+        "service": "Secondary Market Research API",
+        "status": "active",
+        "version": "1.0.0",
+        "timestamp": datetime.now().isoformat()
+    }
+
+@app.post("/research/generate", response_model=MarketResearchResponse, summary="Generate Market Research Report")
+async def generate_research(
+    request: MarketResearchRequest,
+    background_tasks: BackgroundTasks
+):
+    """
+    Generate a secondary market research report with customizable parameters.
+    
+    This endpoint starts an async job to generate a comprehensive market research
+    report based on the provided parameters. The report generation runs in the
+    background and can be tracked using the returned job_id.
+    """
+    
+    # Generate unique job ID
+    job_id = str(uuid.uuid4())
+    
+    # Initialize job status
+    job_status[job_id] = {
+        "job_id": job_id,
+        "status": "pending",
+        "progress": 0,
+        "message": "Report generation queued",
+        "created_at": datetime.now().isoformat(),
+        "updated_at": datetime.now().isoformat(),
+        "config": request.dict()
+    }
+    
+    # Create config object
+    config = MarketResearchConfig(
+        company=request.company,
+        geography=request.geography,
+        industry=request.industry,
+        sections=request.sections
+    )
+    
+    # Start background task
+    background_tasks.add_task(generate_market_research_report, job_id, config)
+    
+    return MarketResearchResponse(
+        job_id=job_id,
+        status="pending",
+        message="Market research report generation started",
+        estimated_completion=datetime.now().isoformat()
+    )
+
+@app.get("/research/status/{job_id}", response_model=JobStatusResponse, summary="Check Job Status")
+async def check_job_status(job_id: str):
+    """
+    Check the status of a market research report generation job.
+    
+    Returns the current status, progress percentage, and any results or errors.
+    """
+    
+    if job_id not in job_status:
+        raise HTTPException(status_code=404, detail="Job ID not found")
+    
+    return JobStatusResponse(**job_status[job_id])
+
+@app.get("/research/reports/{job_id}", summary="Download Research Report")
+async def download_report(job_id: str):
+    """
+    Download the generated market research report.
+    
+    Returns the complete report in JSON format once generation is complete.
+    """
+    
+    if job_id not in job_status:
+        raise HTTPException(status_code=404, detail="Job ID not found")
+    
+    if job_status[job_id]["status"] != "completed":
+        raise HTTPException(status_code=400, detail="Report not ready. Check job status first.")
+    
+    report_path = REPORTS_DIR / f"market_research_{job_id}.json"
+    
+    if not report_path.exists():
+        raise HTTPException(status_code=404, detail="Report file not found")
+    
+    return FileResponse(
+        path=report_path,
+        media_type="application/json",
+        filename=f"market_research_{job_id}.json"
+    )
+
+@app.get("/research/jobs", summary="List All Jobs")
+async def list_jobs():
+    """
+    List all market research jobs and their current status.
+    
+    Useful for monitoring and administrative purposes.
+    """
+    
+    return {
+        "total_jobs": len(job_status),
+        "jobs": [
+            {
+                "job_id": job_id,
+                "status": status["status"],
+                "progress": status["progress"],
+                "created_at": status["created_at"],
+                "company": status["config"]["company"] if "config" in status else "Unknown"
+            }
+            for job_id, status in job_status.items()
+        ]
+    }
+
+@app.delete("/research/jobs/{job_id}", summary="Cancel Job")
+async def cancel_job(job_id: str):
+    """
+    Cancel a pending or running market research job.
+    """
+    
+    if job_id not in job_status:
+        raise HTTPException(status_code=404, detail="Job ID not found")
+    
+    if job_status[job_id]["status"] in ["completed", "failed"]:
+        raise HTTPException(status_code=400, detail="Cannot cancel completed or failed job")
+    
+    job_status[job_id]["status"] = "cancelled"
+    job_status[job_id]["message"] = "Job cancelled by user"
+    job_status[job_id]["updated_at"] = datetime.now().isoformat()
+    
+    return {"message": "Job cancelled successfully", "job_id": job_id}
+
+@app.get("/research/templates", summary="Get Research Templates")
+async def get_research_templates():
+    """
+    Get predefined research templates for common use cases.
+    """
+    
+    templates = {
+        "technology_company": {
+            "sections": ["market_overview", "competitive_analysis", "financial_performance", "growth_opportunities"],
+            "example": {
+                "company": "Tesla",
+                "geography": "North America",
+                "industry": "Electric Vehicles"
+            }
+        },
+        "financial_services": {
+            "sections": ["market_overview", "competitive_analysis", "risk_assessment", "financial_performance"],
+            "example": {
+                "company": "Goldman Sachs",
+                "geography": "Global",
+                "industry": "Investment Banking"
+            }
+        },
+        "healthcare": {
+            "sections": ["market_overview", "competitive_analysis", "growth_opportunities", "risk_assessment"],
+            "example": {
+                "company": "Johnson & Johnson",
+                "geography": "North America",
+                "industry": "Pharmaceuticals"
+            }
+        },
+        "retail": {
+            "sections": ["market_overview", "competitive_analysis", "financial_performance", "growth_opportunities"],
+            "example": {
+                "company": "Amazon",
+                "geography": "Global",
+                "industry": "E-commerce"
+            }
+        }
+    }
+    
+    return {
+        "templates": templates,
+        "available_sections": [
+            "market_overview",
+            "competitive_analysis", 
+            "financial_performance",
+            "growth_opportunities",
+            "risk_assessment"
+        ]
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    print("🚀 Starting Secondary Market Research API...")
+    print("📚 API Documentation: http://localhost:8000/docs")
+    print("🔄 ReDoc Documentation: http://localhost:8000/redoc")
+    
+    uvicorn.run(
+        "secondary-market-research-api:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True
+    )

examples/python/camera/README.md

@@ -0,0 +1,173 @@
+# Camera Integration Examples
+
+This directory contains examples demonstrating how to integrate camera feeds with PraisonAI multimodal agents for real-time visual analysis.
+
+## 📋 Overview
+
+PraisonAI supports visual input through the `images` parameter in Tasks. While there's no built-in camera capture, you can integrate camera feeds by capturing frames/videos and passing them to vision agents.
+
+## 🛠️ Setup
+
+### Requirements
+```bash
+pip install praisonaiagents opencv-python
+```
+
+### Environment Variables
+```bash
+export OPENAI_API_KEY=your_openai_api_key
+```
+
+## 📁 Examples
+
+### 1. `camera-basic.py` - Basic Camera Capture
+- **Purpose**: Capture a single frame and analyze it
+- **Use Case**: Quick analysis, testing camera setup
+- **Features**:
+  - Single frame capture
+  - Basic object and scene analysis
+  - Automatic cleanup
+
+**Usage:**
+```bash
+python camera-basic.py
+```
+
+### 2. `camera-continuous.py` - Continuous Monitoring
+- **Purpose**: Continuous camera monitoring with periodic analysis
+- **Use Case**: Security monitoring, surveillance systems
+- **Features**:
+  - Configurable analysis intervals
+  - Real-time monitoring
+  - Security-focused analysis
+  - Graceful shutdown with Ctrl+C
+
+**Usage:**
+```bash
+python camera-continuous.py
+```
+
+### 3. `camera-multi-agent.py` - Multi-Agent Analysis
+- **Purpose**: Multiple specialized agents analyzing the same camera feed
+- **Use Case**: Comprehensive analysis from different perspectives
+- **Features**:
+  - Security analysis agent
+  - Object detection agent
+  - Scene analysis agent
+  - Parallel processing
+
+**Usage:**
+```bash
+python camera-multi-agent.py
+```
+
+### 4. `camera-video-analysis.py` - Video Recording & Analysis
+- **Purpose**: Record video segments and analyze temporal events
+- **Use Case**: Activity analysis, event detection
+- **Features**:
+  - Video recording with configurable duration
+  - Temporal event analysis
+  - Timeline extraction
+  - Automatic cleanup
+
+**Usage:**
+```bash
+python camera-video-analysis.py
+```
+
+## 🎯 Supported Input Types
+
+- ✅ **Local Images**: `"camera_shot.jpg"`, `"webcam_capture.png"`
+- ✅ **Local Videos**: `"security_feed.mp4"`, `"recording.avi"`
+- ✅ **Image URLs**: `"https://example.com/live_feed.jpg"`
+- ✅ **Multiple Sources**: `["cam1.jpg", "cam2.jpg", "video.mp4"]`
+
+## 🔧 Configuration Options
+
+### Camera Settings
+```python
+camera_id = 0  # Default camera (change to 1, 2, etc. for other cameras)
+```
+
+### Analysis Intervals
+```python
+analysis_interval = 10  # Seconds between analyses for continuous monitoring
+```
+
+### Recording Duration
+```python
+recording_duration = 15  # Seconds for video recording
+```
+
+## 💡 Integration Patterns
+
+### 1. Real-time Processing
+```python
+# Capture frames periodically and process them as separate tasks
+def capture_and_analyze():
+    cap = cv2.VideoCapture(0)
+    ret, frame = cap.read()
+    if ret:
+        cv2.imwrite("temp_capture.jpg", frame)
+        # Process with PraisonAI agent
+    cap.release()
+```
+
+### 2. Batch Analysis
+```python
+# Process multiple camera angles simultaneously
+task = Task(
+    description="Analyze multiple camera feeds",
+    agent=vision_agent,
+    images=["cam1.jpg", "cam2.jpg", "cam3.jpg"]
+)
+```
+
+### 3. Video Analysis
+```python
+# Save video segments and analyze them
+task = Task(
+    description="Analyze this video for activities",
+    agent=vision_agent,
+    images=["security_footage.mp4"]  # Video files work too
+)
+```
+
+## 🔒 Security Considerations
+
+- **Camera Permissions**: Ensure your application has camera access
+- **Privacy**: Be mindful of privacy when recording/analyzing
+- **Storage**: Clean up temporary files to avoid storage issues
+- **Access Control**: Implement proper access controls for camera systems
+
+## 🐛 Troubleshooting
+
+### Camera Not Found
+```python
+# Check available cameras
+for i in range(4):  # Check first 4 camera indices
+    cap = cv2.VideoCapture(i)
+    if cap.isOpened():
+        print(f"Camera {i} is available")
+        cap.release()
+```
+
+### Permission Issues
+- On Linux: Add user to `video` group
+- On macOS: Grant camera permissions in System Preferences
+- On Windows: Check camera privacy settings
+
+### Performance Optimization
+- Reduce frame size for faster processing
+- Adjust analysis intervals based on requirements
+- Use parallel processing for multiple agents
+
+## 📚 Related Documentation
+
+- [Multimodal Features](../../docs/features/multimodal.mdx)
+- [Agent Documentation](../../docs/concepts/agents.mdx)
+- [Task Documentation](../../docs/concepts/tasks.mdx)
+
+## 🤝 Contributing
+
+Feel free to contribute additional camera integration examples or improvements to existing ones!

examples/python/camera/camera-basic.py

@@ -0,0 +1,102 @@
+"""
+Basic Camera Integration Example
+
+This example demonstrates how to capture a single frame from a camera
+and analyze it using a PraisonAI vision agent.
+
+Requirements:
+    pip install praisonaiagents opencv-python
+
+Usage:
+    python camera-basic.py
+
+Environment Variables:
+    OPENAI_API_KEY=your_openai_api_key
+"""
+
+import cv2
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+
+def capture_and_analyze():
+    """Capture a single frame from camera and analyze it"""
+    
+    # Create vision agent
+    vision_agent = Agent(
+        name="CameraAnalyst",
+        role="Camera Feed Analyzer",
+        goal="Analyze camera captures in real-time",
+        backstory="Expert in real-time visual analysis with computer vision skills",
+        llm="gpt-4o-mini"
+    )
+    
+    # Initialize camera (0 for default camera)
+    cap = cv2.VideoCapture(0)
+    
+    if not cap.isOpened():
+        print("Error: Could not open camera")
+        return None
+        
+    try:
+        # Capture frame
+        ret, frame = cap.read()
+        
+        if ret:
+            # Save frame temporarily
+            image_path = "temp_camera_capture.jpg"
+            cv2.imwrite(image_path, frame)
+            print(f"Frame captured and saved as {image_path}")
+            
+            # Create analysis task
+            task = Task(
+                name="analyze_camera_feed",
+                description="Analyze what you see in this camera capture. Identify objects, people, and activities.",
+                expected_output="Detailed analysis of the camera content including objects, people, activities, and overall scene description",
+                agent=vision_agent,
+                images=[image_path]
+            )
+            
+            # Run analysis
+            agents = PraisonAIAgents(
+                agents=[vision_agent],
+                tasks=[task],
+                process="sequential",
+                verbose=1
+            )
+            
+            result = agents.start()
+            
+            # Clean up temporary file
+            if os.path.exists(image_path):
+                os.remove(image_path)
+                
+            return result
+            
+        else:
+            print("Error: Could not capture frame")
+            return None
+            
+    finally:
+        cap.release()
+        cv2.destroyAllWindows()
+
+
+def main():
+    """Main function"""
+    print("📸 Starting basic camera analysis...")
+    print("Make sure your camera is connected and accessible")
+    
+    result = capture_and_analyze()
+    
+    if result:
+        print("\n🔍 Analysis Results:")
+        for task_id, task_result in result["task_results"].items():
+            print(f"\nTask {task_id}:")
+            print(task_result.raw)
+    else:
+        print("❌ Failed to capture and analyze camera feed")
+
+
+if __name__ == "__main__":
+    main()

examples/python/camera/camera-continuous.py

@@ -0,0 +1,142 @@
+"""
+Continuous Camera Monitoring Example
+
+This example demonstrates continuous camera monitoring with periodic analysis
+using PraisonAI vision agents. Perfect for security monitoring or real-time surveillance.
+
+Requirements:
+    pip install praisonaiagents opencv-python
+
+Usage:
+    python camera-continuous.py
+
+Environment Variables:
+    OPENAI_API_KEY=your_openai_api_key
+"""
+
+import cv2
+import time
+import os
+from datetime import datetime
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+
+class ContinuousCameraMonitor:
+    """Continuous camera monitoring system"""
+    
+    def __init__(self, camera_id=0, analysis_interval=10):
+        """
+        Initialize camera monitor
+        
+        Args:
+            camera_id (int): Camera ID (0 for default)
+            analysis_interval (int): Seconds between analyses
+        """
+        self.camera_id = camera_id
+        self.analysis_interval = analysis_interval
+        self.running = False
+        
+        # Create vision agent
+        self.vision_agent = Agent(
+            name="SecurityMonitor",
+            role="Security Camera Analyst",
+            goal="Monitor camera feeds for activities and security events",
+            backstory="Expert security analyst with computer vision skills specialized in real-time monitoring",
+            llm="gpt-4o-mini"
+        )
+    
+    def capture_frame(self, cap):
+        """Capture a single frame from camera"""
+        ret, frame = cap.read()
+        if ret:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"camera_capture_{timestamp}.jpg"
+            cv2.imwrite(filename, frame)
+            return filename
+        return None
+    
+    def analyze_frame(self, image_path):
+        """Analyze captured frame"""
+        task = Task(
+            name="monitor_camera_feed",
+            description="""Monitor this camera feed for:
+            1. Any people or unusual activities
+            2. Objects that seem out of place
+            3. Movement or changes in the scene
+            4. Security-relevant events
+            
+            Provide a brief but detailed security report.""",
+            expected_output="Security analysis report with timestamp and observations",
+            agent=self.vision_agent,
+            images=[image_path]
+        )
+        
+        agents = PraisonAIAgents(
+            agents=[self.vision_agent],
+            tasks=[task],
+            process="sequential",
+            verbose=0  # Reduced verbosity for continuous monitoring
+        )
+        
+        return agents.start()
+    
+    def start_monitoring(self):
+        """Start continuous monitoring"""
+        print(f"🎥 Starting continuous camera monitoring...")
+        print(f"📊 Analysis interval: {self.analysis_interval} seconds")
+        print("🛑 Press Ctrl+C to stop")
+        
+        cap = cv2.VideoCapture(self.camera_id)
+        
+        if not cap.isOpened():
+            print(f"❌ Error: Could not open camera {self.camera_id}")
+            return
+        
+        self.running = True
+        
+        try:
+            while self.running:
+                # Capture frame
+                image_path = self.capture_frame(cap)
+                
+                if image_path:
+                    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                    print(f"\n⏰ {timestamp} - Analyzing camera feed...")
+                    
+                    # Analyze frame
+                    result = self.analyze_frame(image_path)
+                    
+                    # Display results
+                    if result and "task_results" in result:
+                        for task_id, task_result in result["task_results"].items():
+                            print(f"📋 Security Report: {task_result.raw}")
+                    
+                    # Clean up temporary file
+                    if os.path.exists(image_path):
+                        os.remove(image_path)
+                
+                # Wait for next analysis
+                time.sleep(self.analysis_interval)
+                
+        except KeyboardInterrupt:
+            print("\n🛑 Stopping camera monitoring...")
+        finally:
+            self.running = False
+            cap.release()
+            cv2.destroyAllWindows()
+            print("✅ Camera monitoring stopped")
+
+
+def main():
+    """Main function"""
+    # Configuration
+    camera_id = 0  # Default camera
+    analysis_interval = 15  # Analyze every 15 seconds
+    
+    # Create and start monitor
+    monitor = ContinuousCameraMonitor(camera_id, analysis_interval)
+    monitor.start_monitoring()
+
+
+if __name__ == "__main__":
+    main()

examples/python/camera/camera-multi-agent.py

@@ -0,0 +1,164 @@
+"""
+Multi-Agent Camera Analysis Example
+
+This example demonstrates using multiple specialized agents to analyze
+camera feeds from different perspectives (security, object detection, etc.).
+
+Requirements:
+    pip install praisonaiagents opencv-python
+
+Usage:
+    python camera-multi-agent.py
+
+Environment Variables:
+    OPENAI_API_KEY=your_openai_api_key
+"""
+
+import cv2
+import os
+from datetime import datetime
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+
+def capture_camera_frame(camera_id=0):
+    """Capture a frame from camera"""
+    cap = cv2.VideoCapture(camera_id)
+    
+    if not cap.isOpened():
+        print(f"Error: Could not open camera {camera_id}")
+        return None
+        
+    ret, frame = cap.read()
+    cap.release()
+    
+    if ret:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        image_path = f"camera_frame_{timestamp}.jpg"
+        cv2.imwrite(image_path, frame)
+        return image_path
+    
+    return None
+
+
+def analyze_with_multiple_agents():
+    """Analyze camera feed using multiple specialized agents"""
+    
+    # Capture frame
+    image_path = capture_camera_frame()
+    if not image_path:
+        print("Failed to capture camera frame")
+        return None
+    
+    print(f"📸 Captured frame: {image_path}")
+    
+    # Create specialized agents
+    security_agent = Agent(
+        name="SecurityExpert",
+        role="Security Specialist",
+        goal="Identify security threats and suspicious activities",
+        backstory="Expert security analyst with years of experience in surveillance and threat detection",
+        llm="gpt-4o-mini"
+    )
+    
+    object_detector = Agent(
+        name="ObjectDetector",
+        role="Object Recognition Specialist", 
+        goal="Identify and catalog all objects in the scene",
+        backstory="Computer vision expert specializing in object detection and classification",
+        llm="gpt-4o-mini"
+    )
+    
+    scene_analyst = Agent(
+        name="SceneAnalyst",
+        role="Scene Understanding Expert",
+        goal="Provide comprehensive scene analysis and context",
+        backstory="Environmental analyst expert in understanding spatial relationships and scene context",
+        llm="gpt-4o-mini"
+    )
+    
+    # Create specialized tasks
+    security_task = Task(
+        name="security_analysis",
+        description="""Analyze this camera feed for security concerns:
+        1. Identify any people and their activities
+        2. Look for suspicious behavior or unauthorized access
+        3. Check for potential security threats
+        4. Assess overall security status of the area""",
+        expected_output="Detailed security assessment with threat level and recommendations",
+        agent=security_agent,
+        images=[image_path]
+    )
+    
+    object_task = Task(
+        name="object_detection",
+        description="""Identify and catalog all objects in this image:
+        1. List all visible objects with their approximate locations
+        2. Identify any vehicles, electronics, or valuable items
+        3. Note any objects that seem out of place
+        4. Provide a comprehensive inventory""",
+        expected_output="Detailed object inventory with locations and descriptions",
+        agent=object_detector,
+        images=[image_path]
+    )
+    
+    scene_task = Task(
+        name="scene_analysis",
+        description="""Provide comprehensive scene analysis:
+        1. Describe the overall environment and setting
+        2. Analyze lighting conditions and time of day
+        3. Assess the general activity level and atmosphere
+        4. Provide context about what type of location this appears to be""",
+        expected_output="Complete scene description with environmental context",
+        agent=scene_analyst,
+        images=[image_path]
+    )
+    
+    # Run multi-agent analysis
+    agents = PraisonAIAgents(
+        agents=[security_agent, object_detector, scene_analyst],
+        tasks=[security_task, object_task, scene_task],
+        process="parallel",  # Run all analyses in parallel
+        verbose=1
+    )
+    
+    result = agents.start()
+    
+    # Clean up temporary file
+    if os.path.exists(image_path):
+        os.remove(image_path)
+    
+    return result
+
+
+def main():
+    """Main function"""
+    print("🎯 Starting multi-agent camera analysis...")
+    print("📋 This will analyze the camera feed from multiple perspectives")
+    
+    result = analyze_with_multiple_agents()
+    
+    if result:
+        print("\n" + "="*60)
+        print("📊 MULTI-AGENT ANALYSIS RESULTS")
+        print("="*60)
+        
+        # Display results by agent
+        agent_names = {
+            "security_analysis": "🛡️  SECURITY ANALYSIS",
+            "object_detection": "🔍 OBJECT DETECTION", 
+            "scene_analysis": "🌍 SCENE ANALYSIS"
+        }
+        
+        for task_id, task_result in result["task_results"].items():
+            print(f"\n{agent_names.get(task_id, f'Task {task_id}')}:")
+            print("-" * 40)
+            print(task_result.raw)
+            
+        print("\n" + "="*60)
+        print("✅ Multi-agent analysis complete!")
+    else:
+        print("❌ Failed to complete camera analysis")
+
+
+if __name__ == "__main__":
+    main()

examples/python/camera/camera-video-analysis.py

@@ -0,0 +1,206 @@
+"""
+Camera Video Recording and Analysis Example
+
+This example demonstrates recording video segments from camera
+and analyzing them using PraisonAI vision agents.
+
+Requirements:
+    pip install praisonaiagents opencv-python
+
+Usage:
+    python camera-video-analysis.py
+
+Environment Variables:
+    OPENAI_API_KEY=your_openai_api_key
+"""
+
+import cv2
+import os
+import time
+from datetime import datetime
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+
+class CameraVideoAnalyzer:
+    """Camera video recording and analysis system"""
+    
+    def __init__(self, camera_id=0):
+        """
+        Initialize video analyzer
+        
+        Args:
+            camera_id (int): Camera ID (0 for default)
+        """
+        self.camera_id = camera_id
+        
+        # Create video analysis agent
+        self.video_agent = Agent(
+            name="VideoAnalyst",
+            role="Video Content Analyzer",
+            goal="Analyze video content for activities, objects, and events",
+            backstory="Expert in video analysis and temporal event detection with computer vision expertise",
+            llm="gpt-4o-mini"
+        )
+    
+    def record_video_segment(self, duration_seconds=10):
+        """
+        Record a video segment from camera
+        
+        Args:
+            duration_seconds (int): Length of video to record
+            
+        Returns:
+            str: Path to recorded video file or None if failed
+        """
+        cap = cv2.VideoCapture(self.camera_id)
+        
+        if not cap.isOpened():
+            print(f"Error: Could not open camera {self.camera_id}")
+            return None
+        
+        # Get video properties
+        fps = int(cap.get(cv2.CAP_PROP_FPS)) or 30
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        
+        # Setup video writer
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        video_path = f"camera_recording_{timestamp}.mp4"
+        
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(video_path, fourcc, fps, (width, height))
+        
+        print(f"🎬 Recording video for {duration_seconds} seconds...")
+        print(f"📹 Resolution: {width}x{height}, FPS: {fps}")
+        
+        start_time = time.time()
+        frame_count = 0
+        
+        try:
+            while (time.time() - start_time) < duration_seconds:
+                ret, frame = cap.read()
+                
+                if ret:
+                    out.write(frame)
+                    frame_count += 1
+                    
+                    # Show recording indicator
+                    if frame_count % fps == 0:  # Update every second
+                        elapsed = int(time.time() - start_time)
+                        remaining = duration_seconds - elapsed
+                        print(f"⏱️  Recording... {remaining}s remaining")
+                else:
+                    break
+                    
+        finally:
+            cap.release()
+            out.release()
+            cv2.destroyAllWindows()
+        
+        if frame_count > 0:
+            print(f"✅ Video recorded: {video_path} ({frame_count} frames)")
+            return video_path
+        else:
+            print("❌ Failed to record video")
+            if os.path.exists(video_path):
+                os.remove(video_path)
+            return None
+    
+    def analyze_video(self, video_path):
+        """
+        Analyze recorded video
+        
+        Args:
+            video_path (str): Path to video file
+            
+        Returns:
+            dict: Analysis results
+        """
+        task = Task(
+            name="analyze_video_content",
+            description="""Analyze this video recording and provide:
+            1. Summary of main activities and events observed
+            2. Timeline of key moments or changes
+            3. Identification of people, objects, and movements
+            4. Any notable interactions or behaviors
+            5. Overall assessment of what happened in the video
+            
+            Focus on providing a comprehensive temporal analysis.""",
+            expected_output="Detailed video analysis with timeline and event description",
+            agent=self.video_agent,
+            images=[video_path]  # PraisonAI supports video files in images parameter
+        )
+        
+        agents = PraisonAIAgents(
+            agents=[self.video_agent],
+            tasks=[task],
+            process="sequential",
+            verbose=1
+        )
+        
+        return agents.start()
+    
+    def record_and_analyze(self, duration=10):
+        """
+        Record video and analyze it
+        
+        Args:
+            duration (int): Recording duration in seconds
+        """
+        # Record video
+        video_path = self.record_video_segment(duration)
+        
+        if not video_path:
+            return None
+        
+        print(f"\n🔍 Analyzing recorded video...")
+        
+        # Analyze video
+        result = self.analyze_video(video_path)
+        
+        # Clean up video file
+        if os.path.exists(video_path):
+            os.remove(video_path)
+            print(f"🗑️  Cleaned up temporary video file")
+        
+        return result
+
+
+def main():
+    """Main function"""
+    print("🎥 Camera Video Recording and Analysis")
+    print("=" * 50)
+    
+    # Configuration
+    camera_id = 0
+    recording_duration = 15  # seconds
+    
+    print(f"📹 Camera: {camera_id}")
+    print(f"⏱️  Recording Duration: {recording_duration} seconds")
+    print("\nMake sure your camera is connected and accessible")
+    print("The system will record a video segment and then analyze it")
+    
+    input("\nPress Enter to start recording...")
+    
+    # Create analyzer and run
+    analyzer = CameraVideoAnalyzer(camera_id)
+    result = analyzer.record_and_analyze(recording_duration)
+    
+    if result:
+        print("\n" + "="*60)
+        print("📊 VIDEO ANALYSIS RESULTS")
+        print("="*60)
+        
+        for task_id, task_result in result["task_results"].items():
+            print(f"\nTask: {task_id}")
+            print("-" * 40)
+            print(task_result.raw)
+        
+        print("\n" + "="*60)
+        print("✅ Video analysis complete!")
+    else:
+        print("❌ Failed to record and analyze video")
+
+
+if __name__ == "__main__":
+    main()

examples/python/concepts/CSV_PROCESSING_README.md

@@ -0,0 +1,205 @@
+# CSV Processing with PraisonAI Agents
+
+This document answers GitHub Issue #23: "How to pass in a CSV file" and provides multiple solutions for processing CSV files with PraisonAI agents.
+
+## Quick Answer
+
+**Yes, it's absolutely possible!** PraisonAI provides multiple ways to process CSV files with agents working through the list sequentially.
+
+## The Simplest Solution
+
+For the exact use case mentioned in the issue (CSV list of URLs processed sequentially):
+
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents
+
+# Create your agent
+agent = Agent(
+    name="URLProcessor",
+    instructions="Analyze each URL from the CSV file"
+)
+
+# Create a loop task
+task = Task(
+    description="Process each URL from the CSV",
+    agent=agent,
+    task_type="loop",           # Enable CSV loop processing
+    input_file="your_urls.csv"  # Your CSV file
+)
+
+# Run the agents
+agents = PraisonAIAgents(
+    agents=[agent],
+    tasks=[task],
+    process="workflow"
+)
+
+agents.start()
+```
+
+## CSV File Format
+
+Your CSV file should have a simple structure. For URLs:
+
+```csv
+url
+https://example.com
+https://github.com
+https://stackoverflow.com
+```
+
+Or with additional columns:
+
+```csv
+url,description
+https://example.com,Example website
+https://github.com,GitHub platform
+https://stackoverflow.com,Q&A site
+```
+
+## Available Methods
+
+### Method 1: Simple Loop Processing (Recommended)
+- **File**: `simple-csv-url-processor.py`
+- **Best for**: Beginners, simple use cases
+- **How it works**: Uses `task_type="loop"` to automatically process each CSV row
+
+### Method 2: Manual CSV Processing
+- **File**: `csv-processing-agents.py` (Method 2)
+- **Best for**: When you need more control over validation and processing
+- **How it works**: Uses CSV tools (`read_csv`, `write_csv`) for manual processing
+
+### Method 3: URL-Specific Processing
+- **File**: `csv-processing-agents.py` (Method 3)
+- **Best for**: Specifically processing URLs with detailed analysis
+- **How it works**: Combines CSV tools with URL analysis logic
+
+### Method 4: Advanced Processing with Validation
+- **File**: `csv-processing-agents.py` (Method 4)
+- **Best for**: Production use cases requiring data validation
+- **How it works**: Validates data before processing, handles errors gracefully
+
+## Built-in CSV Tools
+
+PraisonAI includes powerful CSV tools:
+
+```python
+from praisonaiagents.tools import read_csv, write_csv, merge_csv
+
+# Read CSV files
+data = read_csv("input.csv")
+
+# Write CSV files  
+write_csv("output.csv", data)
+
+# Merge multiple CSV files
+merge_csv(["file1.csv", "file2.csv"], "merged.csv")
+```
+
+## Examples for Different Use Cases
+
+### Processing URLs from CSV
+```python
+# Your CSV: urls.csv
+# url,priority
+# https://example.com,high
+# https://github.com,medium
+
+agent = Agent(
+    name="URLAnalyzer",
+    tools=[read_csv, write_csv],
+    instructions="Analyze URLs based on priority"
+)
+```
+
+### Processing Any Text File
+```python
+# For text files, you can convert to CSV format first
+# Or process line by line using file tools
+```
+
+### Batch Processing Tasks
+```python
+# Your CSV: tasks.csv  
+# task
+# "Analyze competitor website"
+# "Research market trends"
+# "Generate report summary"
+
+task = Task(
+    description="Complete each task from the CSV",
+    task_type="loop",
+    input_file="tasks.csv"
+)
+```
+
+## Prerequisites
+
+1. **Install PraisonAI Agents**:
+   ```bash
+   pip install praisonaiagents
+   ```
+
+2. **Set API Key**:
+   ```bash
+   export OPENAI_API_KEY=your_api_key_here
+   ```
+
+3. **Install pandas** (for advanced CSV operations):
+   ```bash
+   pip install pandas
+   ```
+
+## Running the Examples
+
+1. **Simple URL Processing**:
+   ```bash
+   python simple-csv-url-processor.py
+   ```
+
+2. **Comprehensive Examples**:
+   ```bash
+   python csv-processing-agents.py
+   ```
+
+## Troubleshooting
+
+### Common Issues:
+
+1. **"CSV file not found"**
+   - Make sure your CSV file is in the same directory as your script
+   - Use absolute paths if needed: `/full/path/to/your/file.csv`
+
+2. **"pandas not available"**
+   - Install pandas: `pip install pandas`
+
+3. **"API key not set"**
+   - Set your OpenAI API key: `export OPENAI_API_KEY=your_key`
+
+4. **Processing stops early**
+   - Increase `max_iter` parameter in PraisonAIAgents
+   - Check for errors in your CSV format
+
+### CSV Format Tips:
+
+- Use UTF-8 encoding
+- Ensure consistent column headers
+- Handle special characters properly
+- Keep URLs properly formatted (http:// or https://)
+
+## Related Documentation
+
+- [CSV Tools Documentation](../../../docs/tools/csv_tools.mdx)
+- [Repetitive Agents](../../../docs/features/repetitive.mdx)  
+- [Agent Examples](../../README.md)
+
+## Support
+
+If you encounter issues:
+1. Check the troubleshooting section above
+2. Review the example files for working implementations
+3. Open an issue on the GitHub repository with your specific use case
+
+---
+
+*This solution was generated in response to GitHub Issue #23*

examples/python/concepts/csv-processing-agents.py

@@ -0,0 +1,369 @@
+"""
+CSV Processing with PraisonAI Agents
+
+This example demonstrates multiple ways to process CSV files with agents:
+1. Simple CSV Loop Processing (easiest)
+2. Manual CSV Processing with read_csv tools
+3. URL Processing from CSV files
+4. Custom CSV Processing with validation
+
+Author: Generated for GitHub Issue #23
+"""
+
+import os
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import read_csv, write_csv
+
+def create_sample_urls_csv():
+    """Create a sample CSV file with URLs for testing"""
+    urls_data = [
+        {"id": 1, "url": "https://example.com", "description": "Example website"},
+        {"id": 2, "url": "https://github.com", "description": "GitHub platform"},
+        {"id": 3, "url": "https://stackoverflow.com", "description": "Stack Overflow Q&A"},
+        {"id": 4, "url": "https://python.org", "description": "Python official site"},
+        {"id": 5, "url": "https://docs.python.org", "description": "Python documentation"}
+    ]
+    
+    # Ensure the CSV file exists
+    write_csv("sample_urls.csv", urls_data)
+    print("✅ Created sample_urls.csv with 5 URLs")
+    return "sample_urls.csv"
+
+def create_sample_tasks_csv():
+    """Create a sample CSV file with tasks for loop processing"""
+    tasks_data = [
+        {"task": "Analyze the homepage of example.com and summarize its content"},
+        {"task": "Check if github.com is accessible and describe its main features"},
+        {"task": "Research what Stack Overflow is used for"},
+        {"task": "Summarize the key features of Python programming language"},
+        {"task": "Describe what you can find in Python documentation"}
+    ]
+    
+    write_csv("sample_tasks.csv", tasks_data)
+    print("✅ Created sample_tasks.csv with 5 tasks")
+    return "sample_tasks.csv"
+
+# ==============================================================================
+# METHOD 1: SIMPLE CSV LOOP PROCESSING (RECOMMENDED FOR BEGINNERS)
+# ==============================================================================
+
+def method_1_simple_loop():
+    """
+    The easiest way to process CSV files with PraisonAI agents.
+    
+    This method automatically loops through each row in your CSV file.
+    Each row becomes input for the agent to process.
+    """
+    print("\n" + "="*60)
+    print("METHOD 1: Simple CSV Loop Processing")
+    print("="*60)
+    
+    # Create sample CSV file
+    csv_file = create_sample_tasks_csv()
+    
+    # Create an agent that will process each row
+    loop_agent = Agent(
+        name="CSVLoopProcessor",
+        role="CSV Task Processor",
+        goal="Process each task from the CSV file efficiently",
+        backstory="Expert at handling repetitive tasks from CSV data",
+        instructions="Process each task thoroughly and provide detailed output",
+        llm="gpt-4o-mini"
+    )
+    
+    # Create a loop task that will automatically process each CSV row
+    loop_task = Task(
+        description="Process each task from the CSV file",
+        expected_output="Completed task with detailed results",
+        agent=loop_agent,
+        task_type="loop",           # This enables CSV loop processing
+        input_file=csv_file         # The CSV file to process
+    )
+    
+    # Initialize the agents system
+    agents = PraisonAIAgents(
+        agents=[loop_agent],
+        tasks=[loop_task],
+        process="workflow",
+        max_iter=10                 # Maximum iterations to prevent infinite loops
+    )
+    
+    print(f"🚀 Starting loop processing of {csv_file}")
+    print("Each row will be processed as a separate task...")
+    
+    # Start processing
+    agents.start()
+
+# ==============================================================================
+# METHOD 2: MANUAL CSV PROCESSING WITH TOOLS
+# ==============================================================================
+
+def method_2_manual_csv():
+    """
+    Manual CSV processing using built-in CSV tools.
+    
+    This gives you more control over how the CSV is processed,
+    including validation, filtering, and custom logic.
+    """
+    print("\n" + "="*60)
+    print("METHOD 2: Manual CSV Processing with Tools")
+    print("="*60)
+    
+    # Create sample CSV file
+    csv_file = create_sample_urls_csv()
+    
+    # Create an agent with CSV tools
+    csv_agent = Agent(
+        name="CSVAnalyzer",
+        role="CSV Data Processor",
+        goal="Read, validate, and process CSV data manually",
+        backstory="Specialist in data validation and processing",
+        tools=[read_csv, write_csv],
+        instructions="""
+        You are an expert at processing CSV files. When given a CSV file:
+        1. Read the CSV file using read_csv tool
+        2. Validate the data structure
+        3. Process each row according to the requirements
+        4. Create a summary of the processing results
+        5. Save results to a new CSV file if needed
+        """,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create a task for manual CSV processing
+    csv_task = Task(
+        description=f"""
+        Process the CSV file '{csv_file}' manually:
+        1. Read the CSV file using the read_csv tool
+        2. Validate that it contains 'url' and 'description' columns
+        3. For each URL, describe what type of website it is
+        4. Create a summary report of all URLs processed
+        5. Save the results to 'processed_urls.csv'
+        """,
+        expected_output="A detailed report of CSV processing with validation results",
+        agent=csv_agent
+    )
+    
+    # Initialize and run
+    agents = PraisonAIAgents(
+        agents=[csv_agent],
+        tasks=[csv_task],
+        process="sequential"
+    )
+    
+    print(f"🚀 Starting manual processing of {csv_file}")
+    agents.start()
+
+# ==============================================================================
+# METHOD 3: URL PROCESSING FROM CSV (SPECIFIC TO ISSUE REQUEST)
+# ==============================================================================
+
+def method_3_url_processing():
+    """
+    Specific example for processing URLs from CSV files.
+    
+    This addresses the original question about processing a CSV list of URLs
+    where agents work through the list sequentially.
+    """
+    print("\n" + "="*60)
+    print("METHOD 3: URL Processing from CSV Files")
+    print("="*60)
+    
+    # Create sample CSV file with URLs
+    csv_file = create_sample_urls_csv()
+    
+    # Create a URL processing agent
+    url_agent = Agent(
+        name="URLProcessor",
+        role="Website Analyzer",
+        goal="Analyze websites from CSV URL list",
+        backstory="Expert web analyst who can evaluate websites",
+        tools=[read_csv, write_csv],
+        instructions="""
+        You are a website analysis expert. When given a CSV with URLs:
+        1. Read the CSV file to get the list of URLs
+        2. For each URL, analyze what kind of website it is
+        3. Determine the purpose and main features of each site
+        4. Create a detailed analysis report
+        5. Save results with analysis data
+        """,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create the URL processing task
+    url_task = Task(
+        description=f"""
+        Process URLs from '{csv_file}':
+        1. Read the CSV file containing URLs and descriptions
+        2. For each URL in the list, provide an analysis of:
+           - What type of website it is
+           - Its main purpose and features
+           - Target audience
+           - Key characteristics
+        3. Work through the URLs sequentially (one by one)
+        4. Create a comprehensive report with all analyses
+        5. Save the results to 'url_analysis_results.csv'
+        
+        Make sure to process each URL individually and thoroughly.
+        """,
+        expected_output="Detailed analysis of each URL with comprehensive results saved to CSV",
+        agent=url_agent
+    )
+    
+    # Initialize and run
+    agents = PraisonAIAgents(
+        agents=[url_agent],
+        tasks=[url_task],
+        process="sequential"
+    )
+    
+    print(f"🚀 Starting URL processing from {csv_file}")
+    print("URLs will be processed sequentially...")
+    agents.start()
+
+# ==============================================================================
+# METHOD 4: ADVANCED CSV PROCESSING WITH VALIDATION
+# ==============================================================================
+
+def method_4_advanced_processing():
+    """
+    Advanced CSV processing with data validation and error handling.
+    
+    This method shows how to handle complex CSV processing scenarios
+    with validation, error handling, and structured outputs.
+    """
+    print("\n" + "="*60)
+    print("METHOD 4: Advanced CSV Processing with Validation")
+    print("="*60)
+    
+    # Create a more complex CSV file
+    complex_data = [
+        {"id": 1, "url": "https://example.com", "priority": "high", "category": "test"},
+        {"id": 2, "url": "https://github.com", "priority": "medium", "category": "development"},
+        {"id": 3, "url": "invalid-url", "priority": "low", "category": "test"},  # Invalid URL for testing
+        {"id": 4, "url": "https://stackoverflow.com", "priority": "high", "category": "development"},
+        {"id": 5, "url": "", "priority": "medium", "category": "empty"}  # Empty URL for testing
+    ]
+    
+    csv_file = "complex_urls.csv"
+    write_csv(csv_file, complex_data)
+    print(f"✅ Created {csv_file} with complex data including invalid entries")
+    
+    # Create a validation agent
+    validator_agent = Agent(
+        name="DataValidator",
+        role="Data Quality Specialist", 
+        goal="Validate and clean CSV data before processing",
+        backstory="Expert in data validation and quality assurance",
+        tools=[read_csv, write_csv],
+        instructions="""
+        You are a data validation expert. Your job is to:
+        1. Read CSV files and validate data quality
+        2. Identify invalid or problematic entries
+        3. Clean and standardize data where possible
+        4. Create separate files for valid and invalid data
+        5. Provide detailed validation reports
+        """,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create a processing agent
+    processor_agent = Agent(
+        name="ValidatedProcessor",
+        role="Validated Data Processor",
+        goal="Process only validated and clean data",
+        backstory="Specialist in processing pre-validated data efficiently",
+        tools=[read_csv, write_csv],
+        instructions="""
+        You process validated data efficiently:
+        1. Read validated CSV data
+        2. Process each valid entry according to requirements
+        3. Generate comprehensive results
+        4. Create detailed output reports
+        """,
+        llm="gpt-4o-mini"
+    )
+    
+    # Create validation task
+    validation_task = Task(
+        description=f"""
+        Validate the data in '{csv_file}':
+        1. Read the CSV file
+        2. Check each row for:
+           - Valid URL format (must start with http:// or https://)
+           - Non-empty required fields
+           - Valid priority values (high, medium, low)
+           - Valid category values
+        3. Separate valid and invalid entries
+        4. Save valid entries to 'valid_urls.csv'
+        5. Save invalid entries to 'invalid_urls.csv' with error descriptions
+        6. Create a validation summary report
+        """,
+        expected_output="Validation complete with separate files for valid/invalid data and summary report",
+        agent=validator_agent
+    )
+    
+    # Create processing task (depends on validation)
+    processing_task = Task(
+        description="""
+        Process the validated data from 'valid_urls.csv':
+        1. Read the validated CSV file
+        2. For each valid URL, provide analysis based on priority and category
+        3. High priority items get detailed analysis
+        4. Medium priority items get standard analysis  
+        5. Low priority items get basic analysis
+        6. Save results to 'final_results.csv'
+        """,
+        expected_output="Processed results for all valid entries saved to final CSV",
+        agent=processor_agent
+    )
+    
+    # Initialize and run with sequential processing
+    agents = PraisonAIAgents(
+        agents=[validator_agent, processor_agent],
+        tasks=[validation_task, processing_task],
+        process="sequential"  # Validation must complete before processing
+    )
+    
+    print(f"🚀 Starting advanced processing with validation")
+    agents.start()
+
+# ==============================================================================
+# MAIN EXECUTION
+# ==============================================================================
+
+if __name__ == "__main__":
+    print("CSV Processing with PraisonAI Agents - Multiple Methods Demo")
+    print("=" * 70)
+    
+    print("\nThis demo shows 4 different ways to process CSV files with agents:")
+    print("1. Simple CSV Loop Processing (easiest)")
+    print("2. Manual CSV Processing with tools") 
+    print("3. URL Processing from CSV (addresses the GitHub issue)")
+    print("4. Advanced processing with validation")
+    
+    # You can run all methods or comment out ones you don't need
+    try:
+        # Method 1: Simple loop processing
+        method_1_simple_loop()
+        
+        # Method 2: Manual CSV processing  
+        method_2_manual_csv()
+        
+        # Method 3: URL processing (specific to the GitHub issue)
+        method_3_url_processing()
+        
+        # Method 4: Advanced processing with validation
+        method_4_advanced_processing()
+        
+        print("\n" + "="*70)
+        print("✅ All CSV processing methods completed!")
+        print("Check the generated CSV files for results.")
+        print("="*70)
+        
+    except Exception as e:
+        print(f"❌ Error during processing: {e}")
+        print("Make sure you have:")
+        print("- OpenAI API key set (export OPENAI_API_KEY=your_key)")
+        print("- praisonaiagents package installed (pip install praisonaiagents)")
+        print("- pandas package installed (pip install pandas)")

examples/python/concepts/simple-csv-url-processor.py

@@ -0,0 +1,77 @@
+"""
+Simple CSV URL Processor
+
+This example directly addresses the GitHub issue #23:
+"Is it possible to pass in a CSV list of URLs and have agents work through the list each in turn?"
+
+This is the simplest possible implementation for processing URLs from a CSV file.
+
+Author: Generated for GitHub Issue #23
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents
+from praisonaiagents.tools import write_csv
+
+def create_url_csv():
+    """Create a CSV file with URLs to process"""
+    # Example URLs - replace with your own
+    urls = [
+        {"url": "https://example.com"},
+        {"url": "https://github.com"},
+        {"url": "https://stackoverflow.com"},
+        {"url": "https://python.org"}
+    ]
+    
+    write_csv("urls_to_process.csv", urls)
+    print("✅ Created urls_to_process.csv")
+    return "urls_to_process.csv"
+
+def main():
+    """
+    Simple CSV URL processing example
+    
+    This shows the easiest way to process a CSV list of URLs
+    where agents work through the list sequentially.
+    """
+    print("Simple CSV URL Processor")
+    print("=" * 40)
+    
+    # Step 1: Create the CSV file (or use your existing one)
+    csv_file = create_url_csv()
+    
+    # Step 2: Create an agent to process URLs
+    url_agent = Agent(
+        name="URLProcessor", 
+        role="URL Analyzer",
+        goal="Analyze each URL from the CSV list",
+        backstory="Expert at analyzing websites and URLs",
+        instructions="Analyze each URL and provide insights about the website",
+        llm="gpt-4o-mini"  # You can change this to any supported model
+    )
+    
+    # Step 3: Create a task that will loop through the CSV
+    url_task = Task(
+        description="Analyze each URL from the CSV file and provide insights",
+        expected_output="Analysis of the website at each URL",
+        agent=url_agent,
+        task_type="loop",        # This tells PraisonAI to loop through CSV rows
+        input_file=csv_file      # Your CSV file with URLs
+    )
+    
+    # Step 4: Run the agents
+    agents = PraisonAIAgents(
+        agents=[url_agent],
+        tasks=[url_task],
+        process="workflow",
+        max_iter=10  # Adjust based on how many URLs you have
+    )
+    
+    print(f"🚀 Processing URLs from {csv_file}")
+    print("The agent will work through each URL in turn...")
+    
+    agents.start()
+    
+    print("✅ Finished processing all URLs!")
+
+if __name__ == "__main__":
+    main()

examples/python/mcp/playwright-mcp.py

@@ -0,0 +1,9 @@
+from praisonaiagents import Agent, MCP
+
+search_agent = Agent(
+    instructions="""You help search the web.""",
+    llm="gpt-4o-mini",
+    tools=MCP("http://localhost:8931/sse")
+)
+
+search_agent.start("Find about Praison AI")

examples/python/usecases/README-secondary-market-research.md

@@ -0,0 +1,234 @@
+# Secondary Market Research Agent System
+
+A comprehensive multi-agent system for generating customized secondary market research reports with FastAPI integration.
+
+## 🎯 Features
+
+- **Multi-Agent Research System**: Specialized agents for different research areas
+- **Customizable Parameters**: Company, geography, industry, and research sections
+- **Comprehensive Reports**: Market overview, competitive analysis, financial performance, growth opportunities, and risk assessment
+- **FastAPI Integration**: Production-ready REST API
+- **Professional Output**: Business-ready reports suitable for decision-making
+
+## 📁 Files
+
+- `secondary-market-research.py` - Main Python implementation
+- `secondary-market-research-api.py` - FastAPI web service
+- `secondary_market_research_agents.yaml` - YAML configuration
+- `secondary_market_research_agents.ipynb` - Jupyter notebook examples
+
+## 🚀 Quick Start
+
+### 1. Python Implementation
+
+```python
+from praisonaiagents import Agent, Task, PraisonAIAgents, Tools
+import asyncio
+
+# Configure research parameters
+config = MarketResearchConfig(
+    company="Tesla",
+    geography="North America", 
+    industry="Electric Vehicles",
+    sections=["market_overview", "competitive_analysis", "financial_performance"]
+)
+
+# Run research
+results = await run_market_research(config)
+```
+
+### 2. FastAPI Web Service
+
+```bash
+# Start the API server
+uvicorn secondary-market-research-api:app --reload --port 8000
+
+# Visit API documentation
+http://localhost:8000/docs
+```
+
+### 3. YAML Configuration
+
+```yaml
+framework: "crewai"
+topic: "Secondary Market Research Analysis"
+
+variables:
+  company: "Tesla"
+  geography: "North America" 
+  industry: "Electric Vehicles"
+
+roles:
+  market_overview_specialist:
+    role: "Market Overview Specialist"
+    # ... configuration details
+```
+
+## 📊 Research Sections
+
+Choose from the following research sections:
+
+- **market_overview**: Market size, trends, and growth drivers
+- **competitive_analysis**: Competitor analysis and market positioning  
+- **financial_performance**: Financial metrics and benchmarking
+- **growth_opportunities**: Strategic growth vectors and opportunities
+- **risk_assessment**: Risk factors and mitigation strategies
+
+## 🌍 Use Cases
+
+### Technology Companies
+```python
+config = MarketResearchConfig(
+    company="OpenAI",
+    geography="United States",
+    industry="Artificial Intelligence",
+    sections=["market_overview", "competitive_analysis", "growth_opportunities"]
+)
+```
+
+### Automotive Industry
+```python
+config = MarketResearchConfig(
+    company="BMW",
+    geography="Europe", 
+    industry="Luxury Automobiles",
+    sections=["market_overview", "competitive_analysis", "financial_performance", "risk_assessment"]
+)
+```
+
+### Healthcare/Pharmaceuticals
+```python
+config = MarketResearchConfig(
+    company="Pfizer",
+    geography="Global",
+    industry="Pharmaceuticals", 
+    sections=["market_overview", "competitive_analysis", "growth_opportunities", "risk_assessment"]
+)
+```
+
+## 🔧 API Endpoints
+
+### Generate Research Report
+```http
+POST /research/generate
+Content-Type: application/json
+
+{
+  "company": "Tesla",
+  "geography": "North America",
+  "industry": "Electric Vehicles", 
+  "sections": ["market_overview", "competitive_analysis"],
+  "format": "json"
+}
+```
+
+### Check Job Status
+```http
+GET /research/status/{job_id}
+```
+
+### Download Report
+```http
+GET /research/reports/{job_id}
+```
+
+### Get Templates
+```http
+GET /research/templates
+```
+
+## 📈 Output Format
+
+The system generates comprehensive reports with the following structure:
+
+```json
+{
+  "metadata": {
+    "job_id": "uuid",
+    "company": "Tesla",
+    "geography": "North America",
+    "industry": "Electric Vehicles",
+    "generated_at": "2024-01-01T00:00:00Z"
+  },
+  "executive_summary": "...",
+  "research_findings": {
+    "market_overview_research": {
+      "content": "Market analysis...",
+      "agent": "Market Overview Specialist"
+    },
+    "competitive_analysis": {
+      "content": "Competitive intelligence...", 
+      "agent": "Competitive Intelligence Analyst"
+    }
+  }
+}
+```
+
+## 🛠️ Installation
+
+```bash
+pip install praisonai[crewai]
+pip install fastapi uvicorn
+```
+
+## ⚙️ Configuration
+
+Set your API keys:
+
+```bash
+export OPENAI_API_KEY="your-api-key"
+export OPENAI_MODEL_NAME="gpt-4o-mini"
+```
+
+## 📝 Customization
+
+### Adding New Research Sections
+
+1. Create a new agent in `create_market_research_agents()`
+2. Add corresponding task in `create_research_tasks()`
+3. Update the sections list in configuration
+
+### Geographic Regions
+
+Supported regions include:
+- North America
+- Europe  
+- Asia Pacific
+- Global
+- Custom regions
+
+### Industries
+
+The system works across industries:
+- Technology
+- Automotive
+- Healthcare/Pharmaceuticals
+- Financial Services
+- Retail/E-commerce
+- Energy
+- Manufacturing
+- And more...
+
+## 🎓 Examples
+
+See the Jupyter notebook `secondary_market_research_agents.ipynb` for detailed examples including:
+
+- YAML-based configuration
+- Python API usage
+- FastAPI integration
+- Multiple industry examples
+- Customization patterns
+
+## 🚀 Production Deployment
+
+For production use:
+
+1. Deploy FastAPI with proper ASGI server (Gunicorn + Uvicorn)
+2. Use Redis or database for job status storage
+3. Implement proper error handling and logging
+4. Add authentication and rate limiting
+5. Set up monitoring and alerting
+
+## 📄 License
+
+This project is part of PraisonAI and follows the same licensing terms.

examples/python/usecases/secondary-market-research.py

@@ -0,0 +1,334 @@
+"""
+Secondary Market Research Agent System
+
+This system creates a comprehensive market research solution with customizable 
+inputs for company, geography, and industry sections. It generates detailed 
+reports suitable for secondary market research.
+
+Features:
+- Multi-agent system with specialized research roles
+- Customizable geography and company focus
+- Structured report generation
+- Market analysis and competitive intelligence
+- FastAPI integration ready
+"""
+
+from praisonaiagents import Agent, Task, PraisonAIAgents, Tools
+from typing import Dict, List, Any, Optional
+import asyncio
+import json
+from datetime import datetime
+
+class MarketResearchConfig:
+    """Configuration class for market research parameters"""
+    
+    def __init__(self, 
+                 company: str = "Tesla", 
+                 geography: str = "North America",
+                 industry: str = "Electric Vehicles",
+                 sections: List[str] = None):
+        self.company = company
+        self.geography = geography
+        self.industry = industry
+        self.sections = sections or [
+            "market_overview",
+            "competitive_analysis", 
+            "financial_performance",
+            "growth_opportunities",
+            "risk_assessment"
+        ]
+        self.timestamp = datetime.now().isoformat()
+
+def create_market_research_agents(config: MarketResearchConfig):
+    """Create specialized market research agents"""
+    
+    # Market Overview Agent
+    market_overview_agent = Agent(
+        name="Market Overview Specialist",
+        role="Market Analysis Expert",
+        goal=f"Analyze the {config.industry} market in {config.geography}",
+        instructions=f"""
+        You are a market research specialist focused on {config.industry} in {config.geography}.
+        Analyze market size, trends, growth drivers, and overall market dynamics.
+        Focus on current market conditions and future projections.
+        Provide quantitative data where possible and cite reliable sources.
+        """,
+        tools=[Tools.internet_search],
+        verbose=True
+    )
+    
+    # Competitive Intelligence Agent  
+    competitive_agent = Agent(
+        name="Competitive Intelligence Analyst",
+        role="Competition Research Expert", 
+        goal=f"Analyze {config.company}'s competitive landscape",
+        instructions=f"""
+        You are a competitive intelligence specialist analyzing {config.company}'s position
+        in the {config.industry} market within {config.geography}.
+        Identify key competitors, market share, competitive advantages, and positioning.
+        Analyze competitor strategies, strengths, weaknesses, and market positioning.
+        """,
+        tools=[Tools.internet_search],
+        verbose=True
+    )
+    
+    # Financial Performance Agent
+    financial_agent = Agent(
+        name="Financial Performance Analyst", 
+        role="Financial Research Expert",
+        goal=f"Analyze {config.company}'s financial performance and metrics",
+        instructions=f"""
+        You are a financial analyst specializing in {config.industry} companies.
+        Research {config.company}'s financial performance, revenue trends, profitability,
+        key financial metrics, and compare with industry benchmarks.
+        Focus on recent financial data and performance indicators.
+        """,
+        tools=[Tools.internet_search],
+        verbose=True
+    )
+    
+    # Growth Opportunities Agent
+    growth_agent = Agent(
+        name="Growth Opportunities Researcher",
+        role="Strategic Growth Expert",
+        goal=f"Identify growth opportunities for {config.company}",
+        instructions=f"""
+        You are a strategic growth analyst focusing on {config.industry} in {config.geography}.
+        Identify emerging opportunities, market gaps, expansion possibilities,
+        new product/service opportunities, and strategic growth vectors for {config.company}.
+        Consider technological trends, regulatory changes, and market evolution.
+        """,
+        tools=[Tools.internet_search],
+        verbose=True
+    )
+    
+    # Risk Assessment Agent
+    risk_agent = Agent(
+        name="Risk Assessment Specialist",
+        role="Risk Analysis Expert", 
+        goal=f"Assess risks and challenges for {config.company}",
+        instructions=f"""
+        You are a risk assessment specialist for {config.industry} companies.
+        Identify and analyze potential risks, challenges, and threats facing {config.company}
+        in {config.geography}. Consider regulatory, competitive, technological, 
+        economic, and operational risks.
+        """,
+        tools=[Tools.internet_search],
+        verbose=True
+    )
+    
+    # Report Synthesizer Agent
+    synthesizer_agent = Agent(
+        name="Research Report Synthesizer",
+        role="Report Writing Expert",
+        goal="Synthesize research into comprehensive market research report",
+        instructions=f"""
+        You are an expert report writer specializing in market research reports.
+        Synthesize all research findings into a comprehensive, well-structured 
+        secondary market research report for {config.company} in {config.industry}.
+        
+        Create a professional report with:
+        - Executive Summary
+        - Market Overview 
+        - Competitive Analysis
+        - Financial Performance Analysis
+        - Growth Opportunities
+        - Risk Assessment
+        - Conclusions and Recommendations
+        
+        Use clear headings, bullet points, and structured formatting.
+        Include key insights and actionable recommendations.
+        """,
+        verbose=True
+    )
+    
+    return {
+        "market_overview": market_overview_agent,
+        "competitive": competitive_agent, 
+        "financial": financial_agent,
+        "growth": growth_agent,
+        "risk": risk_agent,
+        "synthesizer": synthesizer_agent
+    }
+
+def create_research_tasks(agents: Dict[str, Agent], config: MarketResearchConfig):
+    """Create research tasks for the agents"""
+    
+    tasks = []
+    
+    # Market Overview Task
+    if "market_overview" in config.sections:
+        market_task = Task(
+            name="market_overview_research",
+            description=f"""
+            Conduct comprehensive market overview research for {config.industry} 
+            in {config.geography}. Include:
+            - Market size and valuation
+            - Growth trends and projections  
+            - Key market drivers
+            - Market segments
+            - Regulatory environment
+            """,
+            expected_output="Detailed market overview analysis with quantitative data",
+            agent=agents["market_overview"],
+            is_start=True,
+            next_tasks=["competitive_analysis"] if "competitive_analysis" in config.sections else ["synthesis"]
+        )
+        tasks.append(market_task)
+    
+    # Competitive Analysis Task  
+    if "competitive_analysis" in config.sections:
+        competitive_task = Task(
+            name="competitive_analysis",
+            description=f"""
+            Analyze competitive landscape for {config.company} in {config.industry}:
+            - Identify top 5-7 competitors
+            - Market share analysis
+            - Competitive positioning
+            - Competitor strengths and weaknesses
+            - Competitive strategies
+            """,
+            expected_output="Comprehensive competitive intelligence report",
+            agent=agents["competitive"],
+            next_tasks=["financial_analysis"] if "financial_performance" in config.sections else ["synthesis"]
+        )
+        tasks.append(competitive_task)
+    
+    # Financial Performance Task
+    if "financial_performance" in config.sections:
+        financial_task = Task(
+            name="financial_analysis", 
+            description=f"""
+            Analyze {config.company}'s financial performance:
+            - Revenue trends (last 3-5 years)
+            - Profitability metrics
+            - Key financial ratios
+            - Industry benchmark comparison
+            - Financial health assessment
+            """,
+            expected_output="Detailed financial performance analysis",
+            agent=agents["financial"],
+            next_tasks=["growth_opportunities"] if "growth_opportunities" in config.sections else ["synthesis"]
+        )
+        tasks.append(financial_task)
+    
+    # Growth Opportunities Task
+    if "growth_opportunities" in config.sections:
+        growth_task = Task(
+            name="growth_opportunities",
+            description=f"""
+            Identify growth opportunities for {config.company}:
+            - Market expansion opportunities
+            - New product/service opportunities  
+            - Strategic partnerships potential
+            - Technology advancement opportunities
+            - Emerging market trends
+            """,
+            expected_output="Strategic growth opportunities analysis",
+            agent=agents["growth"],
+            next_tasks=["risk_assessment"] if "risk_assessment" in config.sections else ["synthesis"]
+        )
+        tasks.append(growth_task)
+    
+    # Risk Assessment Task
+    if "risk_assessment" in config.sections:
+        risk_task = Task(
+            name="risk_assessment",
+            description=f"""
+            Assess risks and challenges for {config.company}:
+            - Competitive threats
+            - Regulatory risks
+            - Market risks
+            - Operational challenges
+            - Technology disruption risks
+            """,
+            expected_output="Comprehensive risk assessment report",
+            agent=agents["risk"],
+            next_tasks=["synthesis"]
+        )
+        tasks.append(risk_task)
+    
+    # Synthesis Task
+    synthesis_task = Task(
+        name="synthesis",
+        description=f"""
+        Synthesize all research findings into a comprehensive secondary market 
+        research report for {config.company} in {config.industry} ({config.geography}).
+        
+        Create a professional report with clear sections, insights, and recommendations.
+        Focus on actionable intelligence for business decision-making.
+        """,
+        expected_output="Complete secondary market research report",
+        agent=agents["synthesizer"],
+        context=tasks  # Use all previous tasks as context
+    )
+    tasks.append(synthesis_task)
+    
+    return tasks
+
+async def run_market_research(config: MarketResearchConfig) -> Dict[str, Any]:
+    """Run the complete market research workflow"""
+    
+    print(f"\n🔍 Starting Secondary Market Research for {config.company}")
+    print(f"📍 Geography: {config.geography}")
+    print(f"🏭 Industry: {config.industry}")
+    print(f"📊 Sections: {', '.join(config.sections)}")
+    print("=" * 60)
+    
+    # Create agents and tasks
+    agents = create_market_research_agents(config)
+    tasks = create_research_tasks(agents, config)
+    
+    # Create workflow
+    workflow = PraisonAIAgents(
+        agents=list(agents.values()),
+        tasks=tasks,
+        process="workflow",
+        verbose=True
+    )
+    
+    # Execute research
+    results = await workflow.astart()
+    
+    return {
+        "config": config.__dict__,
+        "results": results,
+        "timestamp": datetime.now().isoformat()
+    }
+
+# Example usage
+async def main():
+    """Main function demonstrating the market research system"""
+    
+    # Example 1: Tesla Electric Vehicle Research
+    tesla_config = MarketResearchConfig(
+        company="Tesla",
+        geography="North America", 
+        industry="Electric Vehicles",
+        sections=["market_overview", "competitive_analysis", "financial_performance", "growth_opportunities"]
+    )
+    
+    tesla_results = await run_market_research(tesla_config)
+    
+    print("\n📋 Research Complete!")
+    print("=" * 60)
+    
+    # Display results
+    if "task_results" in tesla_results["results"]:
+        for task_name, result in tesla_results["results"]["task_results"].items():
+            if result:
+                print(f"\n📌 {task_name.upper()}")
+                print("-" * 40) 
+                print(result.raw[:500] + "..." if len(result.raw) > 500 else result.raw)
+    
+    return tesla_results
+
+if __name__ == "__main__":
+    # Run the market research
+    results = asyncio.run(main())
+    
+    # Save results to file
+    with open("market_research_results.json", "w") as f:
+        json.dump(results, f, indent=2, default=str)
+    
+    print(f"\n💾 Results saved to market_research_results.json")

src/praisonai-agents/praisonaiagents/agent/agent.py

@@ -864,7 +864,11 @@ Your Goal: {self.goal}
         if self._using_custom_llm:
             try:
                 # Special handling for MCP tools when using provider/model format
-                tool_param = self.tools if tools is None else tools
+                # Fix: Handle empty tools list properly - use self.tools if tools is None or empty
+                if tools is None or (isinstance(tools, list) and len(tools) == 0):
+                    tool_param = self.tools
+                else:
+                    tool_param = tools
                 
                 # Convert MCP tool objects to OpenAI format if needed
                 if tool_param is not None:

src/praisonai-agents/praisonaiagents/llm/llm.py

@@ -205,6 +205,72 @@ class LLM:
             }
             logging.debug(f"LLM instance initialized with: {json.dumps(debug_info, indent=2, default=str)}")
 
+    def _is_ollama_provider(self) -> bool:
+        """Detect if this is an Ollama provider regardless of naming convention"""
+        if not self.model:
+            return False
+        
+        # Direct ollama/ prefix
+        if self.model.startswith("ollama/"):
+            return True
+            
+        # Check environment variables for Ollama base URL
+        base_url = os.getenv("OPENAI_BASE_URL", "")
+        api_base = os.getenv("OPENAI_API_BASE", "")
+        
+        # Common Ollama endpoints
+        ollama_endpoints = ["localhost:11434", "127.0.0.1:11434", ":11434"]
+        
+        return any(endpoint in base_url or endpoint in api_base for endpoint in ollama_endpoints)
+
+    def _parse_tool_call_arguments(self, tool_call: Dict, is_ollama: bool = False) -> tuple:
+        """
+        Safely parse tool call arguments with proper error handling
+        
+        Returns:
+            tuple: (function_name, arguments, tool_call_id)
+        """
+        try:
+            if is_ollama:
+                # Special handling for Ollama provider which may have different structure
+                if "function" in tool_call and isinstance(tool_call["function"], dict):
+                    function_name = tool_call["function"]["name"]
+                    arguments = json.loads(tool_call["function"]["arguments"])
+                else:
+                    # Try alternative format that Ollama might return
+                    function_name = tool_call.get("name", "unknown_function")
+                    arguments_str = tool_call.get("arguments", "{}")
+                    arguments = json.loads(arguments_str) if arguments_str else {}
+                tool_call_id = tool_call.get("id", f"tool_{id(tool_call)}")
+            else:
+                # Standard format for other providers with error handling
+                function_name = tool_call["function"]["name"]
+                arguments_str = tool_call["function"]["arguments"]
+                arguments = json.loads(arguments_str) if arguments_str else {}
+                tool_call_id = tool_call["id"]
+                
+        except (KeyError, json.JSONDecodeError, TypeError) as e:
+            logging.error(f"Error parsing tool call arguments: {e}")
+            function_name = tool_call.get("name", "unknown_function")
+            arguments = {}
+            tool_call_id = tool_call.get("id", f"tool_{id(tool_call)}")
+            
+        return function_name, arguments, tool_call_id
+
+    def _needs_system_message_skip(self) -> bool:
+        """Check if this model requires skipping system messages"""
+        if not self.model:
+            return False
+        
+        # Only skip for specific legacy o1 models that don't support system messages
+        legacy_o1_models = [
+            "o1-preview",           # 2024-09-12 version
+            "o1-mini",              # 2024-09-12 version  
+            "o1-mini-2024-09-12"    # Explicit dated version
+        ]
+        
+        return self.model in legacy_o1_models
+
     def get_response(
         self,
         prompt: Union[str, List[Dict]],
@@ -320,7 +386,9 @@ class LLM:
                     system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_json.model_json_schema())}"
                 elif output_pydantic:
                     system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_pydantic.model_json_schema())}"
-                messages.append({"role": "system", "content": system_prompt})
+                # Skip system messages for legacy o1 models as they don't support them
+                if not self._needs_system_message_skip():
+                    messages.append({"role": "system", "content": system_prompt})
             
             if chat_history:
                 messages.extend(chat_history)
@@ -470,32 +538,19 @@ class LLM:
                         for tool_call in tool_calls:
                             # Handle both object and dict access patterns
                             if isinstance(tool_call, dict):
-                                # Special handling for Ollama provider which may have a different structure
-                                if self.model and self.model.startswith("ollama/"):
-                                    try:
-                                        # Try standard format first
-                                        if "function" in tool_call and isinstance(tool_call["function"], dict):
-                                            function_name = tool_call["function"]["name"]
-                                            arguments = json.loads(tool_call["function"]["arguments"])
-                                        else:
-                                            # Try alternative format that Ollama might return
-                                            function_name = tool_call.get("name", "unknown_function")
-                                            arguments = json.loads(tool_call.get("arguments", "{}"))
-                                        tool_call_id = tool_call.get("id", f"tool_{id(tool_call)}")
-                                    except Exception as e:
-                                        logging.error(f"Error processing Ollama tool call: {e}")
-                                        function_name = "unknown_function"
-                                        arguments = {}
-                                        tool_call_id = f"tool_{id(tool_call)}"
-                                else:
-                                    # Standard format for other providers
-                                    function_name = tool_call["function"]["name"]
-                                    arguments = json.loads(tool_call["function"]["arguments"])
-                                    tool_call_id = tool_call["id"]
+                                is_ollama = self._is_ollama_provider()
+                                function_name, arguments, tool_call_id = self._parse_tool_call_arguments(tool_call, is_ollama)
                             else:
-                                function_name = tool_call.function.name
-                                arguments = json.loads(tool_call.function.arguments)
-                                tool_call_id = tool_call.id
+                                # Handle object-style tool calls
+                                try:
+                                    function_name = tool_call.function.name
+                                    arguments = json.loads(tool_call.function.arguments) if tool_call.function.arguments else {}
+                                    tool_call_id = tool_call.id
+                                except (json.JSONDecodeError, AttributeError) as e:
+                                    logging.error(f"Error parsing object-style tool call: {e}")
+                                    function_name = "unknown_function"
+                                    arguments = {}
+                                    tool_call_id = f"tool_{id(tool_call)}"
 
                             logging.debug(f"[TOOL_EXEC_DEBUG] About to execute tool {function_name} with args: {arguments}")
                             tool_result = execute_tool_fn(function_name, arguments)
@@ -867,7 +922,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_json.model_json_schema())}"
                 elif output_pydantic:
                     system_prompt += f"\nReturn ONLY a JSON object that matches this Pydantic model: {json.dumps(output_pydantic.model_json_schema())}"
-                messages.append({"role": "system", "content": system_prompt})
+                # Skip system messages for legacy o1 models as they don't support them
+                if not self._needs_system_message_skip():
+                    messages.append({"role": "system", "content": system_prompt})
             
             if chat_history:
                 messages.extend(chat_history)
@@ -1065,32 +1122,19 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     for tool_call in tool_calls:
                         # Handle both object and dict access patterns
                         if isinstance(tool_call, dict):
-                            # Special handling for Ollama provider which may have a different structure
-                            if self.model and self.model.startswith("ollama/"):
-                                try:
-                                    # Try standard format first
-                                    if "function" in tool_call and isinstance(tool_call["function"], dict):
-                                        function_name = tool_call["function"]["name"]
-                                        arguments = json.loads(tool_call["function"]["arguments"])
-                                    else:
-                                        # Try alternative format that Ollama might return
-                                        function_name = tool_call.get("name", "unknown_function")
-                                        arguments = json.loads(tool_call.get("arguments", "{}"))
-                                    tool_call_id = tool_call.get("id", f"tool_{id(tool_call)}")
-                                except Exception as e:
-                                    logging.error(f"Error processing Ollama tool call: {e}")
-                                    function_name = "unknown_function"
-                                    arguments = {}
-                                    tool_call_id = f"tool_{id(tool_call)}"
-                            else:
-                                # Standard format for other providers
-                                function_name = tool_call["function"]["name"]
-                                arguments = json.loads(tool_call["function"]["arguments"])
-                                tool_call_id = tool_call["id"]
+                            is_ollama = self._is_ollama_provider()
+                            function_name, arguments, tool_call_id = self._parse_tool_call_arguments(tool_call, is_ollama)
                         else:
-                            function_name = tool_call.function.name
-                            arguments = json.loads(tool_call.function.arguments)
-                            tool_call_id = tool_call.id
+                            # Handle object-style tool calls
+                            try:
+                                function_name = tool_call.function.name
+                                arguments = json.loads(tool_call.function.arguments) if tool_call.function.arguments else {}
+                                tool_call_id = tool_call.id
+                            except (json.JSONDecodeError, AttributeError) as e:
+                                logging.error(f"Error parsing object-style tool call: {e}")
+                                function_name = "unknown_function"
+                                arguments = {}
+                                tool_call_id = f"tool_{id(tool_call)}"
 
                         tool_result = await execute_tool_fn(function_name, arguments)
 
@@ -1111,7 +1155,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     response_text = ""
                     
                     # Special handling for Ollama models that don't automatically process tool results
-                    if self.model and self.model.startswith("ollama/") and tool_result:
+                    if self._is_ollama_provider() and tool_result:
                         # For Ollama models, we need to explicitly ask the model to process the tool results
                         # First, check if the response is just a JSON tool call
                         try:
@@ -1517,7 +1561,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             # Build messages list
             messages = []
             if system_prompt:
-                messages.append({"role": "system", "content": system_prompt})
+                # Skip system messages for legacy o1 models as they don't support them
+                if not self._needs_system_message_skip():
+                    messages.append({"role": "system", "content": system_prompt})
             
             # Add prompt to messages
             if isinstance(prompt, list):
@@ -1623,7 +1669,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             # Build messages list
             messages = []
             if system_prompt:
-                messages.append({"role": "system", "content": system_prompt})
+                # Skip system messages for legacy o1 models as they don't support them
+                if not self._needs_system_message_skip():
+                    messages.append({"role": "system", "content": system_prompt})
             
             # Add prompt to messages
             if isinstance(prompt, list):

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.92"
+version = "0.0.93"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [

src/praisonai-agents/uv.lock

@@ -2233,7 +2233,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.92"
+version = "0.0.93"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },

src/praisonai/praisonai.rb

@@ -3,8 +3,8 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.19.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.19.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.22.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.2.22.tar.gz | shasum -a 256`.split.first
     license "MIT"
   
     depends_on "[email protected]"

src/praisonai/praisonai/__init__.py

@@ -3,4 +3,4 @@ import os
 os.environ["OTEL_SDK_DISABLED"] = "true"
 os.environ["EC_TELEMETRY"] = "false"
 from .cli import PraisonAI
-from .version import __version__
+from .version import __version__

src/praisonai/praisonai/api/call.py

@@ -39,9 +39,6 @@ LOG_EVENT_TYPES = [
 
 app = FastAPI()
 
-if not OPENAI_API_KEY:
-    raise ValueError('Missing the OpenAI API key. Please set it in the .env file.')
-
 # Set up logging
 logger = logging.getLogger(__name__)
 log_level = os.getenv("LOGLEVEL", "INFO").upper()
@@ -266,6 +263,9 @@ def setup_public_url(port):
 
 def run_server(port: int, use_public: bool = False):
     """Run the FastAPI server using uvicorn."""
+    if not OPENAI_API_KEY:
+        raise ValueError('Missing the OpenAI API key. Please set it in the .env file or configure it through the GUI.')
+    
     if use_public:
         setup_public_url(port)
     else:

src/praisonai/praisonai/cli.py

@@ -54,7 +54,7 @@ except ImportError:
     pass
 
 try:
-    from crewai import Agent, Task, Crew
+    import crewai
     CREWAI_AVAILABLE = True
 except ImportError:
     pass
@@ -147,6 +147,21 @@ class PraisonAI:
         """
         return self.main()
 
+    def read_stdin_if_available(self):
+        """
+        Read from stdin if it's available (when data is piped in).
+        Returns the stdin content or None if no piped input is available.
+        """
+        try:
+            # Check if stdin is not a terminal (i.e., has piped input)
+            if not sys.stdin.isatty():
+                stdin_content = sys.stdin.read().strip()
+                return stdin_content if stdin_content else None
+        except Exception:
+            # If there's any error reading stdin, ignore it
+            pass
+        return None
+
     def main(self):
         """
         The main function of the PraisonAI object. It parses the command-line arguments,
@@ -164,21 +179,41 @@ class PraisonAI:
 
         self.framework = args.framework or self.framework
 
+        # Check for piped input from stdin
+        stdin_input = self.read_stdin_if_available()
+
         if args.command:
             if args.command.startswith("tests.test") or args.command.startswith("tests/test"):  # Argument used for testing purposes
                 print("test")
                 return "test"
             else:
-                self.agent_file = args.command
+                # If stdin input is available, append it to the command
+                if stdin_input:
+                    combined_prompt = f"{args.command} {stdin_input}"
+                    result = self.handle_direct_prompt(combined_prompt)
+                    print(result)
+                    return result
+                else:
+                    self.agent_file = args.command
         elif hasattr(args, 'direct_prompt') and args.direct_prompt:
             # Only handle direct prompt if agent_file wasn't explicitly set in constructor
             if original_agent_file == "agents.yaml":  # Default value, so safe to use direct prompt
-                result = self.handle_direct_prompt(args.direct_prompt)
+                # If stdin input is available, append it to the direct prompt
+                prompt = args.direct_prompt
+                if stdin_input:
+                    prompt = f"{args.direct_prompt} {stdin_input}"
+                result = self.handle_direct_prompt(prompt)
                 print(result)
                 return result
             else:
                 # Agent file was explicitly set, ignore direct prompt and use the file
                 pass
+        elif stdin_input:
+            # If only stdin input is provided (no command), use it as direct prompt
+            if original_agent_file == "agents.yaml":  # Default value, so safe to use stdin as prompt
+                result = self.handle_direct_prompt(stdin_input)
+                print(result)
+                return result
         # If no command or direct_prompt, preserve agent_file from constructor (don't overwrite)
 
         if args.deploy:
@@ -248,17 +283,29 @@ class PraisonAI:
                 print("All packages installed")
                 return
 
+            # Check if conda is available and environment exists
+            conda_available = True
+            conda_env_exists = False
+            
             try:
                 result = subprocess.check_output(['conda', 'env', 'list'])
                 if 'praison_env' in result.decode('utf-8'):
                     print("Conda environment 'praison_env' found.")
+                    conda_env_exists = True
                 else:
-                    raise subprocess.CalledProcessError(1, 'grep')
-            except subprocess.CalledProcessError:
-                print("Conda environment 'praison_env' not found. Setting it up...")
-                from praisonai.setup.setup_conda_env import main as setup_conda_main
-                setup_conda_main()
-                print("All packages installed.")
+                    print("Conda environment 'praison_env' not found. Setting it up...")
+                    from praisonai.setup.setup_conda_env import main as setup_conda_main
+                    setup_conda_main()
+                    print("All packages installed.")
+                    # Check again if environment was created successfully
+                    try:
+                        result = subprocess.check_output(['conda', 'env', 'list'])
+                        conda_env_exists = 'praison_env' in result.decode('utf-8')
+                    except subprocess.CalledProcessError:
+                        conda_env_exists = False
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                print("Conda not available or failed to check environment.")
+                conda_available = False
 
             train_args = sys.argv[2:]  # Get all arguments after 'train'
             
@@ -278,7 +325,18 @@ class PraisonAI:
             env = os.environ.copy()
             env['PYTHONUNBUFFERED'] = '1'
 
-            stream_subprocess(['conda', 'run', '--no-capture-output', '--name', 'praison_env', 'python', '-u', train_script_path, 'train'], env=env)
+            # Try conda run first, fallback to direct Python execution
+            if conda_available and conda_env_exists:
+                try:
+                    print("Attempting to run training using conda environment...")
+                    stream_subprocess(['conda', 'run', '--no-capture-output', '--name', 'praison_env', 'python', '-u', train_script_path, 'train'], env=env)
+                except subprocess.CalledProcessError as e:
+                    print(f"Conda run failed with error: {e}")
+                    print("Falling back to direct Python execution...")
+                    stream_subprocess([sys.executable, '-u', train_script_path, 'train'], env=env)
+            else:
+                print("Conda environment not available, using direct Python execution...")
+                stream_subprocess([sys.executable, '-u', train_script_path, 'train'], env=env)
             return
 
         if args.auto or self.auto:
@@ -500,6 +558,7 @@ class PraisonAI:
             result = agent.start(prompt)
             return result
         elif CREWAI_AVAILABLE:
+            from crewai import Agent, Task, Crew
             agent_config = {
                 "name": "DirectAgent",
                 "role": "Assistant",

src/praisonai/praisonai/deploy.py

@@ -56,7 +56,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.2.19 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.2.22 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

src/praisonai/praisonai/ui/chat.py

@@ -12,7 +12,7 @@ import base64
 from dotenv import load_dotenv
 from PIL import Image
 from tavily import TavilyClient
-from crawl4ai import AsyncWebCrawler
+from crawl4ai import AsyncAsyncWebCrawler
 
 # Local application/library imports
 import chainlit as cl
@@ -72,7 +72,7 @@ async def tavily_web_search(query):
     response = tavily_client.search(query)
     logger.debug(f"Tavily search response: {response}")
 
-    async with AsyncWebCrawler() as crawler:
+    async with AsyncAsyncWebCrawler() as crawler:
         results = []
         for result in response.get('results', []):
             url = result.get('url')

src/praisonai/praisonai/ui/code.py

@@ -12,7 +12,7 @@ from dotenv import load_dotenv
 from PIL import Image
 from context import ContextGatherer
 from tavily import TavilyClient
-from crawl4ai import AsyncWebCrawler
+from crawl4ai import AsyncAsyncWebCrawler
 
 # Local application/library imports
 import chainlit as cl
@@ -153,8 +153,8 @@ async def tavily_web_search(query):
     response = tavily_client.search(query)
     logger.debug(f"Tavily search response: {response}")
 
-    # Create an instance of AsyncWebCrawler
-    async with AsyncWebCrawler() as crawler:
+    # Create an instance of AsyncAsyncWebCrawler
+    async with AsyncAsyncWebCrawler() as crawler:
         # Prepare the results
         results = []
         for result in response.get('results', []):

src/praisonai/praisonai/ui/components/aicoder.py

@@ -7,7 +7,7 @@ from litellm import acompletion
 import json
 import dotenv
 from tavily import TavilyClient
-from crawl4ai import AsyncWebCrawler
+from crawl4ai import AsyncAsyncWebCrawler
 
 dotenv.load_dotenv()
 
@@ -144,7 +144,7 @@ class AICoder:
             })
         response = self.tavily_client.search(query)
         results = []
-        async with AsyncWebCrawler() as crawler:
+        async with AsyncAsyncWebCrawler() as crawler:
             for result in response.get('results', []):
                 url = result.get('url')
                 if url:

src/praisonai/praisonai/ui/realtimeclient/tools.py

@@ -3,7 +3,7 @@ import chainlit as cl
 import plotly
 import json
 from tavily import TavilyClient
-from crawl4ai import WebCrawler
+from crawl4ai import AsyncWebCrawler
 import os
 import logging
 import asyncio
@@ -122,7 +122,7 @@ async def tavily_web_search_handler(query):
     })
 
 def process_tavily_results(response):
-    crawler = WebCrawler()
+    crawler = AsyncWebCrawler()
     crawler.warmup()
     results = []
     for result in response.get('results', []):
@@ -151,7 +151,7 @@ async def fallback_to_duckduckgo(query):
         
         logger.debug(f"DuckDuckGo search results: {ddg_results}")
         
-        crawler = WebCrawler()
+        crawler = AsyncWebCrawler()
         crawler.warmup()
         results = []
         

src/praisonai/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PraisonAI"
-version = "2.2.19"
+version = "2.2.22"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 readme = "README.md"
 license = ""
@@ -19,6 +19,11 @@ dependencies = [
     "mcp>=1.6.0",
 ]
 
+[project.scripts]
+praisonai = "praisonai.__main__:main"
+setup-conda-env = "praisonai.setup.setup_conda_env:main"
+praisonai-call = "praisonai.api.call:main"
+
 [project.optional-dependencies]
 ui = [
     "chainlit==2.5.5",
@@ -89,7 +94,7 @@ autogen = ["pyautogen>=0.2.19", "praisonai-tools>=0.0.15", "crewai"]
 
 [tool.poetry]
 name = "PraisonAI"
-version = "2.2.19"
+version = "2.2.22"
 description = "PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration."
 authors = ["Mervin Praison"]
 license = ""

src/praisonai/tests/test.py

@@ -43,7 +43,7 @@ class TestPraisonAIFramework(unittest.TestCase):
 
     @pytest.mark.real
     def test_main_with_built_in_tool(self):
-        praisonai = PraisonAI(agent_file="tests/built-in-tools-agents.yaml")
+        praisonai = PraisonAI(agent_file="tests/inbuilt-tool-agents.yaml")
         result = praisonai.run()
         print(f"Result: {result}")
         self.assertIsNotNone(result)
@@ -77,7 +77,10 @@ class TestPraisonAICommandLine(unittest.TestCase):
         command = "praisonai --framework autogen --init \"create a 2-agent team to write a simple python game\""
         result = self.run_command(command)
         print(f"Result: {result}")
-        self.assertIn('created successfully', result)
+        # Check for success indicator in the output
+        success_phrases = ['created successfully', 'agents.yaml created', 'File created']
+        found_success = any(phrase in result for phrase in success_phrases)
+        self.assertTrue(found_success, f"No success message found. Expected one of {success_phrases}. Last 1000 chars: {result[-1000:]}")
 
 class TestExamples(unittest.TestCase):
     def test_advanced_example(self):

src/praisonai/tests/unit/test_database_config.py

@@ -5,10 +5,9 @@ Test script for database_config module functionality.
 
 import sys
 import os
-sys.path.insert(0, 'src/praisonai/praisonai/ui')
 
-# Test the database_config module
-from database_config import should_force_sqlite, get_database_url_with_sqlite_override, get_database_config_for_sqlalchemy
+# Import from the proper module path
+from praisonai.ui.database_config import should_force_sqlite, get_database_url_with_sqlite_override, get_database_config_for_sqlalchemy
 
 def test_database_config():
     print("Testing database_config utilities...")

src/praisonai/tests/unit/test_ollama_fix.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+Test script to verify Ollama tool-call fixes
+"""
+import sys
+import os
+
+# Add the source directory to Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src', 'praisonai-agents'))
+
+from praisonaiagents.llm.llm import LLM
+from praisonaiagents.agent.agent import Agent
+
+def test_ollama_provider_detection():
+    """Test the new Ollama provider detection logic"""
+    print("Testing Ollama provider detection...")
+    
+    # Test 1: Direct ollama/ prefix
+    llm1 = LLM(model="ollama/qwen3:32b")
+    assert llm1._is_ollama_provider() == True, "Should detect ollama/ prefix"
+    print("✓ Direct ollama/ prefix detection works")
+    
+    # Test 2: Environment variable detection
+    os.environ["OPENAI_BASE_URL"] = "http://localhost:11434/v1"
+    llm2 = LLM(model="qwen3:32b")
+    assert llm2._is_ollama_provider() == True, "Should detect via env var"
+    print("✓ Environment variable detection works")
+    
+    # Test 3: Non-Ollama model
+    os.environ.pop("OPENAI_BASE_URL", None)
+    llm3 = LLM(model="gpt-4o-mini")
+    assert llm3._is_ollama_provider() == False, "Should not detect non-Ollama"
+    print("✓ Non-Ollama detection works")
+
+def test_tool_call_parsing():
+    """Test the new tool call parsing logic"""
+    print("\nTesting tool call parsing...")
+    
+    llm = LLM(model="ollama/qwen3:32b")
+    
+    # Test 1: Standard format
+    tool_call_std = {
+        "id": "call_123",
+        "function": {
+            "name": "hello_world",
+            "arguments": '{"name": "test"}'
+        }
+    }
+    name, args, id = llm._parse_tool_call_arguments(tool_call_std, is_ollama=True)
+    assert name == "hello_world", f"Expected 'hello_world', got '{name}'"
+    assert args == {"name": "test"}, f"Expected {{'name': 'test'}}, got {args}"
+    print("✓ Standard format parsing works")
+    
+    # Test 2: Ollama alternative format
+    tool_call_alt = {
+        "name": "hello_world",
+        "arguments": '{"name": "test"}'
+    }
+    name, args, id = llm._parse_tool_call_arguments(tool_call_alt, is_ollama=True)
+    assert name == "hello_world", f"Expected 'hello_world', got '{name}'"
+    assert args == {"name": "test"}, f"Expected {{'name': 'test'}}, got {args}"
+    print("✓ Alternative format parsing works")
+    
+    # Test 3: Error handling - malformed JSON
+    tool_call_bad = {
+        "function": {
+            "name": "hello_world",
+            "arguments": 'invalid json'
+        }
+    }
+    name, args, id = llm._parse_tool_call_arguments(tool_call_bad, is_ollama=False)
+    assert name == "hello_world", f"Expected 'hello_world', got '{name}'"
+    assert args == {}, f"Expected empty dict, got {args}"
+    print("✓ Error handling works")
+
+def test_agent_tool_parameter_logic():
+    """Test the fixed tool parameter logic in Agent"""
+    print("\nTesting agent tool parameter logic...")
+    
+    def dummy_tool():
+        """Dummy tool for testing"""
+        return "test"
+    
+    # Test 1: None tools should use agent tools
+    agent = Agent(name="test", tools=[dummy_tool])
+    # Simulate the fixed logic
+    tools = None
+    if tools is None or (isinstance(tools, list) and len(tools) == 0):
+        tool_param = agent.tools
+    else:
+        tool_param = tools
+    
+    assert tool_param == [dummy_tool], "Should use agent tools when tools=None"
+    print("✓ None tools handling works")
+    
+    # Test 2: Empty list should use agent tools  
+    tools = []
+    if tools is None or (isinstance(tools, list) and len(tools) == 0):
+        tool_param = agent.tools
+    else:
+        tool_param = tools
+        
+    assert tool_param == [dummy_tool], "Should use agent tools when tools=[]"
+    print("✓ Empty list handling works")
+    
+    # Test 3: Non-empty list should use provided tools
+    custom_tools = [lambda: "custom"]
+    tools = custom_tools
+    if tools is None or (isinstance(tools, list) and len(tools) == 0):
+        tool_param = agent.tools
+    else:
+        tool_param = tools
+        
+    assert tool_param == custom_tools, "Should use provided tools when not empty"
+    print("✓ Non-empty list handling works")
+
+if __name__ == "__main__":
+    print("Running Ollama tool-call fix tests...\n")
+    
+    try:
+        test_ollama_provider_detection()
+        test_tool_call_parsing()
+        test_agent_tool_parameter_logic()
+        
+        print("\n🎉 All tests passed! The Ollama tool-call fixes are working correctly.")
+        sys.exit(0)
+        
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)

src/praisonai/uv.lock

@@ -3931,7 +3931,7 @@ wheels = [
 
 [[package]]
 name = "praisonai"
-version = "2.2.19"
+version = "2.2.22"
 source = { editable = "." }
 dependencies = [
     { name = "instructor" },