Merge pull request #563 from MervinPraison/claude/issue-459-20250531_155633

fix: resolve MCP tools not working in Streamlit applications (issue #459)

.cursorrules

@@ -1,8 +0,0 @@
-1. Make minimal code changes as possible
-2. if you are creating function, make sure to name it in more easy, user friendly , optimised manner. 
-3. Never copy the exact code if presented with a code from other location or file or codebase, just make it optimised
-4. Always Follow the principle LESS IS MORE
-5. Make it minimal change as possible
-6. Firstly try not to make any modification to the existing code as possible
-7. Only modify the existing code if its highly required, without that if it cant be done, then add new code section. 
-8. If you are adding new code, make sure to add it in a way that it can be easily integrated with the existing codebase. 

.eslintrc

@@ -1,10 +0,0 @@
-{
-    "extends": ["plugin:mdx/recommended"],
-    // optional, if you want to lint code blocks at the same time
-    "settings": {
-      "mdx/code-blocks": true,
-      // optional, if you want to disable language mapper, set it to `false`
-      // if you want to override the default language mapper inside, you can provide your own
-      "mdx/language-mapper": {}
-    }
-  }

.github/workflows/python-package.yml

@@ -19,22 +19,48 @@ jobs:
         python-version: ["3.10", "3.11"]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
+
+    - name: Set environment variables
+      run: |
+        echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
+        echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
+        echo "LOGLEVEL=DEBUG" >> $GITHUB_ENV
+
     - name: Install dependencies
       run: |
+        cd src/praisonai
         python -m pip install --upgrade pip
         python -m pip install flake8 pytest
+        python -m pip install ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
+        python -m pip install duckduckgo_search
+        python -m pip install pytest-asyncio pytest-cov
         if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+        
+    - name: Debug API Key Status
+      run: |
+        echo "🔍 Checking API key availability..."
+        if [ -n "${{ secrets.OPENAI_API_KEY }}" ]; then
+          echo "✅ GitHub secret OPENAI_API_KEY is available"
+          echo "🔑 API key starts with: $(echo "$OPENAI_API_KEY" | cut -c1-7)..."
+        else
+          echo "⚠️ GitHub secret OPENAI_API_KEY is NOT set - using fallback"
+          echo "🔑 Using fallback key: sk-test-key..."
+        fi
+        echo "🌐 API Base: $OPENAI_API_BASE"
+        echo "🤖 Model: $OPENAI_MODEL_NAME"
+        
     # - name: Lint with flake8
     #   run: |
     #     # stop the build if there are Python syntax errors or undefined names
     #     flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
     #     # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
     #     flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
-    # - name: Test with pytest
-    #   run: |
-    #     pytest
+    - name: Test with pytest
+      run: |
+        cd src/praisonai && python -m pytest

.github/workflows/python-publish.yml

@@ -21,9 +21,9 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Set up Python
-      uses: actions/setup-python@v3
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
     - name: Install dependencies
@@ -31,9 +31,10 @@ jobs:
         python -m pip install --upgrade pip
         pip install build
     - name: Build package
-      run: python -m build
+      run: python -m build src/praisonai
     - name: Publish package
       uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
       with:
         user: __token__
         password: ${{ secrets.PYPI_API_TOKEN }}
+        packages_dir: src/praisonai/dist/

.github/workflows/release.yml

@@ -64,7 +64,7 @@ jobs:
         git reset --hard ${{ steps.get_commit.outputs.commit_hash }}
 
     - name: Setup Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.11'
         cache: 'pip'
@@ -422,7 +422,7 @@ jobs:
 
     - name: Upload test artifacts
       if: always()
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: praisonai-output-${{ matrix.os }}-${{ matrix.framework }}
         path: test_output/

.github/workflows/test-comprehensive.yml

@@ -0,0 +1,178 @@
+name: Comprehensive Test Suite
+
+on:
+  workflow_dispatch:  # Allow manual triggering
+    inputs:
+      test_type:
+        description: 'Type of tests to run'
+        required: true
+        default: 'all'
+        type: choice
+        options:
+        - all
+        - unit
+        - integration
+        - fast
+        - performance
+        - frameworks
+        - autogen
+        - crewai
+  release:
+    types: [published, prereleased]
+  schedule:
+    # Run comprehensive tests weekly on Sundays at 3 AM UTC
+    - cron: '0 3 * * 0'
+
+jobs:
+  comprehensive-test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11"]
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install UV
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+
+    - name: Install dependencies
+      run: |
+        cd src/praisonai
+        uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
+        uv pip install --system duckduckgo_search
+        uv pip install --system pytest pytest-asyncio pytest-cov pytest-benchmark
+
+    - name: Set environment variables
+      run: |
+        echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
+        echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
+
+    - name: Run Comprehensive Test Suite
+      run: |
+        # Determine test type from input or default to 'all'
+        TEST_TYPE="${{ github.event.inputs.test_type || 'all' }}"
+        
+        echo "🧪 Running comprehensive test suite (type: $TEST_TYPE)"
+        
+        case $TEST_TYPE in
+          "unit")
+            cd src/praisonai && python tests/test_runner.py --pattern unit
+            ;;
+          "integration")
+            cd src/praisonai && python tests/test_runner.py --pattern integration
+            ;;
+          "fast")
+            cd src/praisonai && python tests/test_runner.py --pattern fast
+            ;;
+          "performance")
+            cd src/praisonai && python tests/test_runner.py --pattern "performance"
+            ;;
+          "frameworks")
+            cd src/praisonai && python tests/test_runner.py --pattern frameworks
+            ;;
+          "autogen")
+            cd src/praisonai && python tests/test_runner.py --pattern autogen
+            ;;
+          "crewai")
+            cd src/praisonai && python tests/test_runner.py --pattern crewai
+            ;;
+          "all"|*)
+            cd src/praisonai && python tests/test_runner.py --pattern all
+            ;;
+        esac
+
+    - name: Generate Comprehensive Test Report
+      if: always()
+      run: |
+        echo "# 📋 Comprehensive Test Report" > comprehensive_report.md
+        echo "" >> comprehensive_report.md
+        echo "**Python Version:** ${{ matrix.python-version }}" >> comprehensive_report.md
+        echo "**Test Type:** ${{ github.event.inputs.test_type || 'all' }}" >> comprehensive_report.md
+        echo "**Trigger:** ${{ github.event_name }}" >> comprehensive_report.md
+        echo "**Date:** $(date -u)" >> comprehensive_report.md
+        echo "" >> comprehensive_report.md
+        
+        echo "## 🧪 Test Categories Covered:" >> comprehensive_report.md
+        echo "" >> comprehensive_report.md
+        echo "### Unit Tests:" >> comprehensive_report.md
+        echo "- ✅ Core agent functionality" >> comprehensive_report.md
+        echo "- ✅ Async operations" >> comprehensive_report.md
+        echo "- ✅ Tool integrations" >> comprehensive_report.md
+        echo "- ✅ UI components" >> comprehensive_report.md
+        echo "" >> comprehensive_report.md
+        
+        echo "### Integration Tests:" >> comprehensive_report.md
+        echo "- ✅ MCP (Model Context Protocol)" >> comprehensive_report.md
+        echo "- ✅ RAG (Retrieval Augmented Generation)" >> comprehensive_report.md
+        echo "- ✅ Base URL API mapping" >> comprehensive_report.md
+        echo "- ✅ Multi-agent workflows" >> comprehensive_report.md
+        echo "- ✅ AutoGen framework integration" >> comprehensive_report.md
+        echo "- ✅ CrewAI framework integration" >> comprehensive_report.md
+        echo "- 💬 LLM integrations (OpenAI, Anthropic, etc.)" >> comprehensive_report.md
+        echo "- 🖥️ UI frameworks (Gradio, Streamlit)" >> comprehensive_report.md
+        echo "- 📊 Memory and persistence" >> comprehensive_report.md
+        echo "- 🌐 Multi-modal capabilities" >> comprehensive_report.md
+
+        echo "- ✅ AutoGen framework integration" >> comprehensive_report.md
+        echo "- ✅ CrewAI framework integration" >> comprehensive_report.md
+        echo "" >> comprehensive_report.md
+        
+        echo "### Key Features Tested:" >> comprehensive_report.md
+        echo "- 🤖 Agent creation and configuration" >> comprehensive_report.md
+        echo "- 📋 Task management and execution" >> comprehensive_report.md
+        echo "- 🔄 Sync/async workflows" >> comprehensive_report.md
+        echo "- 🛠️ Custom tools and error handling" >> comprehensive_report.md
+        echo "- 🧠 Knowledge bases and RAG" >> comprehensive_report.md
+        echo "- 🔌 MCP server connections" >> comprehensive_report.md
+        echo "- 💬 LLM integrations (OpenAI, Anthropic, etc.)" >> comprehensive_report.md
+
+    - name: Upload Comprehensive Test Results
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: comprehensive-test-results-python-${{ matrix.python-version }}
+        path: |
+          comprehensive_report.md
+          htmlcov/
+          coverage.xml
+          .coverage
+        retention-days: 30
+
+  test-matrix-summary:
+    runs-on: ubuntu-latest
+    needs: comprehensive-test
+    if: always()
+    
+    steps:
+    - name: Generate Matrix Summary
+      run: |
+        echo "# 🎯 Test Matrix Summary" > matrix_summary.md
+        echo "" >> matrix_summary.md
+        echo "## Python Version Results:" >> matrix_summary.md
+        echo "- Python 3.10: ${{ needs.comprehensive-test.result }}" >> matrix_summary.md  
+        echo "- Python 3.11: ${{ needs.comprehensive-test.result }}" >> matrix_summary.md
+        echo "" >> matrix_summary.md
+        echo "## Overall Status:" >> matrix_summary.md
+        if [ "${{ needs.comprehensive-test.result }}" == "success" ]; then
+          echo "✅ **All tests passed across all Python versions!**" >> matrix_summary.md
+        else
+          echo "❌ **Some tests failed. Check individual job logs for details.**" >> matrix_summary.md
+        fi
+        
+    - name: Upload Matrix Summary
+      uses: actions/upload-artifact@v4
+      with:
+        name: test-matrix-summary
+        path: matrix_summary.md
+        retention-days: 30 

.github/workflows/test-core.yml

@@ -0,0 +1,272 @@
+name: Core Tests
+
+on: 
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+
+jobs:
+  test-core:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.11]
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install UV
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+
+    - name: Install dependencies
+      run: |
+        cd src/praisonai
+        uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
+        uv pip install --system duckduckgo_search
+        uv pip install --system pytest pytest-asyncio pytest-cov
+
+    - name: Set environment variables
+      run: |
+        echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
+        echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
+        echo "LOGLEVEL=DEBUG" >> $GITHUB_ENV
+        echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
+        # Also export to current shell session for immediate availability
+        export OPENAI_API_KEY="${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}"
+        export OPENAI_API_BASE="${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}"
+        export OPENAI_MODEL_NAME="${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}"
+        export LOGLEVEL=DEBUG
+        # Verify immediate availability
+        echo "🔧 Immediate verification in same step:"
+        echo "  OPENAI_API_KEY length in current session: ${#OPENAI_API_KEY}"
+        echo "  OPENAI_API_KEY starts with sk-: $(echo "$OPENAI_API_KEY" | grep -q '^sk-' && echo 'YES' || echo 'NO')"
+
+    - name: Debug API Key Status
+      run: |
+        echo "🔍 Checking API key availability..."
+        if [ -n "${{ secrets.OPENAI_API_KEY }}" ]; then
+          echo "✅ GitHub secret OPENAI_API_KEY is available"
+          echo "🔑 API key starts with: $(echo "$OPENAI_API_KEY" | cut -c1-7)..."
+        else
+          echo "⚠️ GitHub secret OPENAI_API_KEY is NOT set - using fallback"
+          echo "🔑 Using fallback key: sk-test-key..."
+        fi
+        echo "🌐 API Base: $OPENAI_API_BASE"
+        echo "🤖 Model: $OPENAI_MODEL_NAME"
+        echo "🐛 Log Level: $LOGLEVEL"
+        echo "📊 Environment Check:"
+        echo "  - OPENAI_API_KEY length: ${#OPENAI_API_KEY}"
+        echo "  - OPENAI_API_BASE: $OPENAI_API_BASE"
+        echo "  - OPENAI_MODEL_NAME: $OPENAI_MODEL_NAME"
+        echo "  - LOGLEVEL: $LOGLEVEL"
+        echo "🔍 Is API key actually set?"
+        echo "  - API key starts with sk-: $(echo "$OPENAI_API_KEY" | grep -q '^sk-' && echo 'YES' || echo 'NO')"
+        echo "  - API key is not test key: $([ "$OPENAI_API_KEY" != 'sk-test-key-for-github-actions-testing-only-not-real' ] && echo 'YES' || echo 'NO')"
+
+    - name: Debug Environment Variables Raw
+      run: |
+        echo "🔧 Raw environment variable check:"
+        echo "OPENAI_API_KEY set: $(if [ -n "$OPENAI_API_KEY" ]; then echo 'YES'; else echo 'NO'; fi)"
+        echo "OPENAI_API_KEY length: ${#OPENAI_API_KEY}"
+        echo "OPENAI_API_KEY first 10 chars: ${OPENAI_API_KEY:0:10}"
+        echo "OPENAI_API_KEY last 5 chars: ${OPENAI_API_KEY: -5}"
+        printenv | grep OPENAI || echo "No OPENAI env vars found"
+
+    - name: Debug Python Environment Variables  
+      run: |
+        python -c "
+        import os
+        print('🐍 Python Environment Variable Check:')
+        api_key = os.environ.get('OPENAI_API_KEY', 'NOT_SET')
+        if api_key != 'NOT_SET':
+            print(f'  ✅ OPENAI_API_KEY: {api_key[:7]}... (length: {len(api_key)})')
+        else:
+            print('  ❌ OPENAI_API_KEY: NOT_SET')
+        print(f'  🌐 OPENAI_API_BASE: {os.environ.get(\"OPENAI_API_BASE\", \"NOT_SET\")}')
+        print(f'  🤖 OPENAI_MODEL_NAME: {os.environ.get(\"OPENAI_MODEL_NAME\", \"NOT_SET\")}')
+        print(f'  📋 All OPENAI env vars:')
+        for key, value in os.environ.items():
+            if key.startswith('OPENAI'):
+                print(f'    {key}: {value[:10] if len(value) > 10 else value}...')
+        "
+
+    - name: Validate API Key
+      run: |
+        echo "🔑 Testing API key validity with minimal OpenAI call..."
+        python -c "
+        import os
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=os.environ.get('OPENAI_API_KEY'))
+            response = client.models.list()
+            print('✅ API Key is VALID - OpenAI responded successfully')
+            print(f'📊 Available models: {len(list(response.data))} models found')
+        except Exception as e:
+            print(f'❌ API Key is INVALID - Error: {e}')
+            print('🔍 This explains why all API-dependent tests are failing')
+            print('💡 The GitHub secret OPENAI_API_KEY needs to be updated with a valid key')
+        "
+      continue-on-error: true
+
+    - name: Debug PraisonAI API Key Usage
+      env:
+        OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}
+        OPENAI_API_BASE: ${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}
+        OPENAI_MODEL_NAME: ${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}
+        LOGLEVEL: DEBUG
+      run: |
+        echo "🔍 Testing PraisonAI API key usage directly..."
+        cd src/praisonai
+        python -c "
+        import os
+        import sys
+        sys.path.insert(0, '.')
+        
+        # Attempt to import SecretStr, otherwise use a dummy class
+        try:
+            from pydantic.types import SecretStr
+        except ImportError:
+            class SecretStr:  # Dummy class if pydantic is not available in this minimal context
+                def __init__(self, value): self._value = value
+                def get_secret_value(self): return self._value
+
+        def get_key_display_value(key_value):
+            if isinstance(key_value, SecretStr):
+                return key_value.get_secret_value()[:10] if key_value.get_secret_value() else 'EMPTY_SECRET'
+            elif isinstance(key_value, str):
+                return key_value[:10] if key_value != 'nokey' and key_value != 'NOT_SET' else key_value
+            return 'INVALID_TYPE'
+
+        print('🔧 Direct PraisonAI API Key Check:')
+        env_api_key = os.environ.get(\\"OPENAI_API_KEY\\", \\"NOT_SET\\")
+        print(f'Environment OPENAI_API_KEY: {get_key_display_value(env_api_key)}...')
+        
+        from praisonai import PraisonAI
+        praisonai = PraisonAI()
+        
+        print(f'PraisonAI config_list: {praisonai.config_list}')
+        api_key_from_config = praisonai.config_list[0].get('api_key', 'NOT_SET')
+        print(f'API key from PraisonAI config: {get_key_display_value(api_key_from_config)}...')
+        
+        from praisonai.inc.models import PraisonAIModel
+        
+        print('\\\\n🧪 Testing PraisonAIModel with explicit API key (CrewAI method):')
+        model_with_explicit_key = PraisonAIModel(
+            model='openai/gpt-4o-mini',
+            base_url=praisonai.config_list[0].get('base_url'),
+            api_key=api_key_from_config # This will be a string from praisonai.config_list
+        )
+        print(f'  Model: {model_with_explicit_key.model}')
+        print(f'  Model name: {model_with_explicit_key.model_name}')
+        print(f'  API key var: {model_with_explicit_key.api_key_var}')
+        # model_with_explicit_key.api_key is now a string, or 'nokey'
+        print(f'  API key (explicitly passed to PraisonAIModel): {get_key_display_value(model_with_explicit_key.api_key)}...')
+        print(f'  Base URL: {model_with_explicit_key.base_url}')
+        
+        try:
+            llm_instance = model_with_explicit_key.get_model()
+            print(f'  ✅ LLM instance created successfully: {type(llm_instance).__name__}')
+            
+            # langchain_openai.ChatOpenAI stores the key in openai_api_key as SecretStr
+            llm_api_key_attr = getattr(llm_instance, 'openai_api_key', 'NOT_FOUND')
+            if llm_api_key_attr != 'NOT_FOUND':
+                 print(f'  LLM instance API key: {get_key_display_value(llm_api_key_attr)}...')
+            else:
+                print(f'  LLM instance API key attribute not found.')
+        except Exception as e:
+            print(f'  ❌ Failed to create LLM instance: {e}')
+            import traceback
+            traceback.print_exc()
+        "
+      continue-on-error: true
+
+    - name: Run Unit Tests
+      run: |
+        cd src/praisonai && python -m pytest tests/unit/ -v --tb=short --disable-warnings --cov=praisonai --cov-report=term-missing
+
+    - name: Run Integration Tests  
+      run: |
+        cd src/praisonai && python -m pytest tests/integration/ -v --tb=short --disable-warnings
+
+    - name: Debug Directory Structure
+      run: |
+        echo "🔍 Debugging directory structure for CrewAI tests..."
+        cd src/praisonai
+        echo "Current working directory: $(pwd)"
+        echo "📁 Contents of current directory:"
+        ls -la
+        echo ""
+        echo "📁 Contents of tests directory:"
+        ls -la tests/ || echo "❌ tests/ directory not found"
+        echo ""
+        echo "📁 Contents of tests/integration:"
+        ls -la tests/integration/ || echo "❌ tests/integration/ directory not found"
+        echo ""
+        echo "📁 Looking for crewai directory:"
+        find . -name "crewai" -type d 2>/dev/null || echo "❌ No crewai directories found"
+        echo ""
+        echo "📁 Full directory tree of tests:"
+        tree tests/ || find tests/ -type d 2>/dev/null || echo "❌ Cannot explore tests directory"
+
+    - name: Test AutoGen Framework
+      run: |
+        echo "🤖 Testing AutoGen Framework Integration..."
+        cd src/praisonai && python tests/test_runner.py --pattern autogen --verbose
+
+    - name: Test CrewAI Framework
+      run: |
+        echo "⛵ Testing CrewAI Framework Integration..."
+        cd src/praisonai
+        echo "🔍 Trying test runner first..."
+        python tests/test_runner.py --pattern crewai --verbose || {
+          echo "❌ Test runner failed, trying direct pytest..."
+          echo "📁 Current directory: $(pwd)"
+          echo "📁 Looking for CrewAI tests..."
+          find . -name "*crewai*" -type f 2>/dev/null
+          echo "🧪 Trying direct pytest on integration/crewai..."
+          python -m pytest tests/integration/crewai/ -v --tb=short --disable-warnings || {
+            echo "❌ Direct path failed, trying relative path..."
+            python -m pytest integration/crewai/ -v --tb=short --disable-warnings || {
+              echo "❌ All CrewAI test attempts failed"
+              exit 1
+            }
+          }
+        }
+
+    - name: Run Legacy Tests with API Key
+      env:
+        OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}
+        OPENAI_API_BASE: ${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}
+        OPENAI_MODEL_NAME: ${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}
+        LOGLEVEL: DEBUG
+      run: |
+        echo "🧪 Running legacy tests with real API key..."
+        echo "🔧 Final environment check before pytest:"
+        echo "  OPENAI_API_KEY set: $([ -n "$OPENAI_API_KEY" ] && echo 'YES' || echo 'NO')"
+        echo "  OPENAI_API_KEY length: ${#OPENAI_API_KEY}"
+        echo "  OPENAI_API_KEY starts with sk-: $(echo "$OPENAI_API_KEY" | grep -q '^sk-' && echo 'YES' || echo 'NO')"
+        export OPENAI_API_KEY="$OPENAI_API_KEY"
+        export OPENAI_API_BASE="$OPENAI_API_BASE"
+        export OPENAI_MODEL_NAME="$OPENAI_MODEL_NAME"
+        cd src/praisonai && python -m pytest tests/test.py -v --tb=short --disable-warnings
+
+    - name: Upload Coverage Reports
+      if: matrix.python-version == '3.11'
+      uses: actions/upload-artifact@v4
+      with:
+        name: coverage-reports
+        path: |
+          .coverage
+          htmlcov/
+        retention-days: 7

.github/workflows/test-extended.yml

@@ -0,0 +1,160 @@
+name: Extended Tests
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  schedule:
+    # Run nightly at 2 AM UTC
+    - cron: '0 2 * * *'
+  workflow_dispatch:  # Allow manual triggering
+
+jobs:
+  test-examples:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: 3.11
+
+    - name: Install UV
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+
+    - name: Install dependencies
+      run: |
+        cd src/praisonai
+        uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
+        uv pip install --system duckduckgo_search
+
+    - name: Set environment variables
+      run: |
+        echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
+        echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
+        echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
+
+    - name: Test Key Example Scripts
+      run: |
+        echo "🧪 Testing key example scripts from praisonai-agents..."
+        
+        # Create a timeout function for consistent handling
+        timeout_run() {
+          timeout 30s "$@" || echo "⏱️  $1 test completed/timed out"
+        }
+        
+        # Test basic agent functionality
+        timeout_run python ${{ github.workspace }}/src/praisonai-agents/basic-agents.py
+        
+        # Test async functionality  
+        timeout_run python ${{ github.workspace }}/src/praisonai-agents/async_example.py
+        
+        # Test knowledge/RAG functionality
+        timeout_run python ${{ github.workspace }}/src/praisonai-agents/knowledge-agents.py
+        
+        # Test MCP functionality
+        timeout_run python ${{ github.workspace }}/src/praisonai-agents/mcp-basic.py
+        
+        # Test UI functionality
+        timeout_run python ${{ github.workspace }}/src/praisonai-agents/ui.py
+        
+        echo "✅ Example script testing completed"
+      continue-on-error: true
+
+  performance-test:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: 3.11
+
+    - name: Install UV
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+
+    - name: Install dependencies
+      run: |
+        cd src/praisonai
+        uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
+        uv pip install --system pytest pytest-benchmark
+
+    - name: Run Performance Benchmarks
+      run: |
+        echo "🏃 Running performance benchmarks..."
+        python -c "
+        import time
+        import sys
+        import statistics
+        sys.path.insert(0, 'src/praisonai')
+        
+        print('🏃 Testing agent creation performance...')
+        times = []
+        try:
+            from praisonaiagents import Agent
+            for i in range(5):
+                start_time = time.time()
+                agent = Agent(name=f'PerfAgent{i}')
+                times.append(time.time() - start_time)
+            
+            avg_time = statistics.mean(times)
+            print(f'✅ Average agent creation time: {avg_time:.3f}s')
+            print(f'📊 Min: {min(times):.3f}s, Max: {max(times):.3f}s')
+        except Exception as e:
+            print(f'❌ Agent creation benchmark failed: {e}')
+        
+        print('🏃 Testing import performance...')
+        start_time = time.time()
+        try:
+            import praisonaiagents
+            import_time = time.time() - start_time
+            print(f'✅ Import completed in {import_time:.3f}s')
+        except Exception as e:
+            print(f'❌ Import benchmark failed: {e}')
+        
+        print('🏃 Testing memory usage...')
+        try:
+            import psutil
+            import os
+            process = psutil.Process(os.getpid())
+            memory_mb = process.memory_info().rss / 1024 / 1024
+            print(f'📊 Memory usage: {memory_mb:.1f} MB')
+        except ImportError:
+            print('⚠️  psutil not available for memory testing')
+        except Exception as e:
+            print(f'❌ Memory benchmark failed: {e}')
+        "
+      continue-on-error: true
+
+    - name: Generate Performance Report
+      run: |
+        echo "## 📊 Performance Test Results" > performance_report.md
+        echo "" >> performance_report.md
+        echo "### Benchmarks Run:" >> performance_report.md
+        echo "- ⚡ Agent creation speed" >> performance_report.md
+        echo "- 📦 Import performance" >> performance_report.md
+        echo "- 💾 Memory usage" >> performance_report.md
+        echo "- 🧪 Example script execution" >> performance_report.md
+        echo "" >> performance_report.md
+        echo "_Performance results are logged in the CI output above._" >> performance_report.md
+
+    - name: Upload Performance Report
+      uses: actions/upload-artifact@v4
+      with:
+        name: performance-report
+        path: performance_report.md
+        retention-days: 30 

.github/workflows/test-frameworks.yml

@@ -0,0 +1,153 @@
+name: Framework Integration Tests
+
+on:
+  workflow_dispatch:  # Allow manual triggering
+    inputs:
+      framework:
+        description: 'Framework to test'
+        required: true
+        default: 'all'
+        type: choice
+        options:
+        - all
+        - autogen
+        - crewai
+  schedule:
+    # Run framework tests daily at 6 AM UTC
+    - cron: '0 6 * * *'
+  push:
+    paths:
+      - 'tests/integration/autogen/**'
+      - 'tests/integration/crewai/**'
+      - '.github/workflows/test-frameworks.yml'
+
+jobs:
+  framework-tests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.11]
+        framework: [autogen, crewai]
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install UV
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+
+    - name: Install dependencies
+      run: |
+        cd src/praisonai
+        uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
+        uv pip install --system duckduckgo_search
+        uv pip install --system pytest pytest-asyncio pytest-cov
+
+    - name: Set environment variables
+      run: |
+        echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
+        echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
+
+    - name: Test ${{ matrix.framework }} Framework
+      run: |
+        echo "🧪 Testing ${{ matrix.framework }} framework integration with Python ${{ matrix.python-version }}"
+        cd src/praisonai && python tests/test_runner.py --pattern ${{ matrix.framework }} --verbose --coverage
+      continue-on-error: false
+
+    - name: Generate Framework Test Report
+      if: always()
+      run: |
+        echo "# 🤖 ${{ matrix.framework }} Framework Test Report" > ${{ matrix.framework }}_report.md
+        echo "" >> ${{ matrix.framework }}_report.md
+        echo "**Framework:** ${{ matrix.framework }}" >> ${{ matrix.framework }}_report.md
+        echo "**Python Version:** ${{ matrix.python-version }}" >> ${{ matrix.framework }}_report.md
+        echo "**Date:** $(date -u)" >> ${{ matrix.framework }}_report.md
+        echo "**Trigger:** ${{ github.event_name }}" >> ${{ matrix.framework }}_report.md
+        echo "" >> ${{ matrix.framework }}_report.md
+        
+        if [ "${{ matrix.framework }}" == "autogen" ]; then
+          echo "## AutoGen Integration Tests" >> ${{ matrix.framework }}_report.md
+          echo "- ✅ AutoGen import verification" >> ${{ matrix.framework }}_report.md
+          echo "- ✅ Basic agent creation through PraisonAI" >> ${{ matrix.framework }}_report.md
+          echo "- ✅ Conversation flow testing" >> ${{ matrix.framework }}_report.md
+          echo "- ✅ Configuration validation" >> ${{ matrix.framework }}_report.md
+        elif [ "${{ matrix.framework }}" == "crewai" ]; then
+          echo "## CrewAI Integration Tests" >> ${{ matrix.framework }}_report.md
+          echo "- ✅ CrewAI import verification" >> ${{ matrix.framework }}_report.md
+          echo "- ✅ Basic crew creation through PraisonAI" >> ${{ matrix.framework }}_report.md
+          echo "- ✅ Multi-agent workflow testing" >> ${{ matrix.framework }}_report.md
+          echo "- ✅ Agent collaboration verification" >> ${{ matrix.framework }}_report.md
+          echo "- ✅ Configuration validation" >> ${{ matrix.framework }}_report.md
+        fi
+        
+        echo "" >> ${{ matrix.framework }}_report.md
+        echo "## Test Commands" >> ${{ matrix.framework }}_report.md
+        echo '```bash' >> ${{ matrix.framework }}_report.md
+        echo "# Run ${{ matrix.framework }} tests locally:" >> ${{ matrix.framework }}_report.md
+        echo "python tests/test_runner.py --pattern ${{ matrix.framework }} --verbose" >> ${{ matrix.framework }}_report.md
+        echo '```' >> ${{ matrix.framework }}_report.md
+
+    - name: Upload Framework Test Results
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: ${{ matrix.framework }}-test-results-python-${{ matrix.python-version }}
+        path: |
+          ${{ matrix.framework }}_report.md
+          htmlcov/
+          coverage.xml
+          .coverage
+        retention-days: 14
+
+  framework-summary:
+    runs-on: ubuntu-latest
+    needs: framework-tests
+    if: always()
+    
+    steps:
+    - name: Generate Framework Summary
+      run: |
+        echo "# 🚀 Framework Integration Test Summary" > framework_summary.md
+        echo "" >> framework_summary.md
+        echo "## Test Results by Framework and Python Version:" >> framework_summary.md
+        echo "" >> framework_summary.md
+        echo "### AutoGen Framework:" >> framework_summary.md
+        echo "- Python 3.11: ${{ needs.framework-tests.result }}" >> framework_summary.md
+        echo "" >> framework_summary.md
+        echo "### CrewAI Framework:" >> framework_summary.md
+        echo "- Python 3.11: ${{ needs.framework-tests.result }}" >> framework_summary.md
+        echo "" >> framework_summary.md
+        echo "## Overall Status:" >> framework_summary.md
+        if [ "${{ needs.framework-tests.result }}" == "success" ]; then
+          echo "✅ **All framework integration tests passed!**" >> framework_summary.md
+        else
+          echo "❌ **Some framework tests failed. Check individual job logs for details.**" >> framework_summary.md
+        fi
+        
+        echo "" >> framework_summary.md
+        echo "## Frameworks Tested:" >> framework_summary.md
+        echo "- **AutoGen**: Microsoft's conversational AI framework" >> framework_summary.md
+        echo "- **CrewAI**: Multi-agent collaboration framework" >> framework_summary.md
+        echo "" >> framework_summary.md
+        echo "## Test Coverage:" >> framework_summary.md
+        echo "- Import verification" >> framework_summary.md
+        echo "- Agent/crew creation" >> framework_summary.md
+        echo "- Workflow execution" >> framework_summary.md
+        echo "- Configuration validation" >> framework_summary.md
+        echo "- Integration with PraisonAI" >> framework_summary.md
+        
+    - name: Upload Framework Summary
+      uses: actions/upload-artifact@v4
+      with:
+        name: framework-test-summary
+        path: framework_summary.md
+        retention-days: 30 

.github/workflows/test-real.yml

@@ -0,0 +1,165 @@
+name: Real End-to-End Tests
+
+# ⚠️ WARNING: This workflow makes real API calls and incurs costs!
+# Only runs when manually triggered to prevent accidental charges
+
+on:
+  workflow_dispatch:  # Manual trigger only
+    inputs:
+      framework:
+        description: 'Framework to test (⚠️ Will incur API costs!)'
+        required: true
+        default: 'none'
+        type: choice
+        options:
+        - none
+        - autogen
+        - crewai
+        - all
+      confirm_costs:
+        description: 'I understand this will make real API calls and may incur costs'
+        required: true
+        type: boolean
+        default: false
+
+jobs:
+  real-tests:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.inputs.confirm_costs == 'true' && github.event.inputs.framework != 'none' }}
+    
+    strategy:
+      matrix:
+        python-version: [3.11]  # Single version to minimize costs
+    
+    steps:
+    - name: 🚨 Cost Warning
+      run: |
+        echo "⚠️  WARNING: This workflow will make real API calls!"
+        echo "💰 This may incur charges on your API accounts"
+        echo "🎯 Framework: ${{ github.event.inputs.framework }}"
+        echo "✅ Cost confirmation: ${{ github.event.inputs.confirm_costs }}"
+        
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install UV
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+
+    - name: Install dependencies
+      run: |
+        cd src/praisonai
+        uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
+        uv pip install --system pytest pytest-asyncio pytest-cov
+
+    - name: Set environment variables
+      run: |
+        echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}" >> $GITHUB_ENV
+        echo "ANTHROPIC_API_KEY=${{ secrets.ANTHROPIC_API_KEY }}" >> $GITHUB_ENV
+        echo "GOOGLE_API_KEY=${{ secrets.GOOGLE_API_KEY }}" >> $GITHUB_ENV
+
+    - name: Verify API Keys
+      run: |
+        if [ -z "${{ secrets.OPENAI_API_KEY }}" ]; then
+          echo "❌ OPENAI_API_KEY not set in secrets"
+          echo "🔧 Add your API key to repository secrets"
+          exit 1
+        fi
+        echo "✅ API keys configured"
+
+    - name: Run Real AutoGen Tests
+      if: ${{ github.event.inputs.framework == 'autogen' || github.event.inputs.framework == 'all' }}
+      run: |
+        echo "🤖 Running REAL AutoGen tests (⚠️  API costs may apply)"
+        cd src/praisonai && python -m pytest tests/e2e/autogen/ -v -m real --tb=short
+      continue-on-error: false
+
+    - name: Run Real CrewAI Tests
+      if: ${{ github.event.inputs.framework == 'crewai' || github.event.inputs.framework == 'all' }}
+      run: |
+        echo "⛵ Running REAL CrewAI tests (⚠️  API costs may apply)"
+        cd src/praisonai && python -m pytest tests/e2e/crewai/ -v -m real --tb=short
+      continue-on-error: false
+
+    - name: Generate Real Test Report
+      if: always()
+      run: |
+        echo "# 🔥 Real End-to-End Test Report" > real_test_report.md
+        echo "" >> real_test_report.md
+        echo "⚠️  **WARNING: This report represents tests that made real API calls**" >> real_test_report.md
+        echo "" >> real_test_report.md
+        echo "**Framework Tested:** ${{ github.event.inputs.framework }}" >> real_test_report.md
+        echo "**Python Version:** ${{ matrix.python-version }}" >> real_test_report.md
+        echo "**Date:** $(date -u)" >> real_test_report.md
+        echo "**Triggered by:** ${{ github.actor }}" >> real_test_report.md
+        echo "" >> real_test_report.md
+        
+        echo "## 🧪 Test Results" >> real_test_report.md
+        echo "" >> real_test_report.md
+        
+        if [ "${{ github.event.inputs.framework }}" == "autogen" ] || [ "${{ github.event.inputs.framework }}" == "all" ]; then
+          echo "### AutoGen Real Tests:" >> real_test_report.md
+          echo "- Environment verification" >> real_test_report.md
+          echo "- Agent creation with real API calls" >> real_test_report.md
+          echo "- Configuration validation" >> real_test_report.md
+          echo "" >> real_test_report.md
+        fi
+        
+        if [ "${{ github.event.inputs.framework }}" == "crewai" ] || [ "${{ github.event.inputs.framework }}" == "all" ]; then
+          echo "### CrewAI Real Tests:" >> real_test_report.md
+          echo "- Environment verification" >> real_test_report.md
+          echo "- Crew creation with real API calls" >> real_test_report.md
+          echo "- Multi-agent setup validation" >> real_test_report.md
+          echo "" >> real_test_report.md
+        fi
+        
+        echo "## 💰 Cost Considerations" >> real_test_report.md
+        echo "- These tests made actual API calls to LLM providers" >> real_test_report.md
+        echo "- Costs depend on your API pricing tier" >> real_test_report.md
+        echo "- Tests are designed to be minimal to reduce costs" >> real_test_report.md
+        echo "- Check your API provider dashboard for actual usage" >> real_test_report.md
+        
+        echo "## 📋 Next Steps" >> real_test_report.md
+        echo "- Review test results for any failures" >> real_test_report.md
+        echo "- Check API usage in your provider dashboard" >> real_test_report.md
+        echo "- Use mock tests (tests/integration/) for routine testing" >> real_test_report.md
+
+    - name: Upload Real Test Results
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: real-test-results-${{ github.event.inputs.framework }}-python-${{ matrix.python-version }}
+        path: |
+          real_test_report.md
+        retention-days: 30
+
+  # Safety job that runs when costs not confirmed
+  safety-check:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.inputs.confirm_costs != 'true' || github.event.inputs.framework == 'none' }}
+    
+    steps:
+    - name: 🛡️ Safety Check Failed
+      run: |
+        echo "🚨 Real tests not executed due to safety checks:"
+        echo ""
+        echo "✅ Costs confirmed: ${{ github.event.inputs.confirm_costs }}"
+        echo "✅ Framework selected: ${{ github.event.inputs.framework }}"
+        echo ""
+        echo "To run real tests:"
+        echo "1. Select a framework (autogen, crewai, or all)"
+        echo "2. Check 'I understand this will make real API calls and may incur costs'"
+        echo "3. Ensure API keys are set in repository secrets"
+        echo ""
+        echo "💡 For cost-free testing, use mock tests instead:"
+        echo "   - Run 'python -m pytest tests/integration/' locally"
+        echo "   - Or trigger other workflows that use mock tests"
+        
+        exit 1 

.github/workflows/unittest.yml

@@ -1,35 +1,503 @@
-name: Run specific unittest
+name: Quick Validation Tests
 
 on: [push, pull_request]
 
 jobs:
-  test:
+  quick-test:
     runs-on: ubuntu-latest
 
     steps:
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
         python-version: 3.11
 
     - name: Install UV
       run: |
-        pip install uv
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.local/bin" >> $GITHUB_PATH
+
 
     - name: Install dependencies
       run: |
-        uv pip install ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
-        uv pip install duckduckgo_search
+        cd src/praisonai
+        uv pip install --system ."[ui,gradio,api,agentops,google,openai,anthropic,cohere,chat,code,realtime,call,crewai,autogen]"
+        uv pip install --system duckduckgo_search
+        uv pip install --system pytest pytest-asyncio pytest-cov
 
     - name: Set environment variables
       run: |
-        echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY }}" >> $GITHUB_ENV
-        echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE }}" >> $GITHUB_ENV
-        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME }}" >> $GITHUB_ENV
+        echo "OPENAI_API_KEY=${{ secrets.OPENAI_API_KEY || 'sk-test-key-for-github-actions-testing-only-not-real' }}" >> $GITHUB_ENV
+        echo "OPENAI_API_BASE=${{ secrets.OPENAI_API_BASE || 'https://api.openai.com/v1' }}" >> $GITHUB_ENV
+        echo "OPENAI_MODEL_NAME=${{ secrets.OPENAI_MODEL_NAME || 'gpt-4o-mini' }}" >> $GITHUB_ENV
+        echo "LOGLEVEL=DEBUG" >> $GITHUB_ENV
+        echo "PYTHONPATH=${{ github.workspace }}/src/praisonai-agents:$PYTHONPATH" >> $GITHUB_ENV
 
-    - name: Run specific unittest
+    - name: Backup Root Config Files
       run: |
-        uv run python -m unittest tests.test.TestExamples
+        echo "🔄 Backing up root configuration files to prevent default file resolution interference..."
+        echo "ℹ️  PraisonAI automatically uses 'agents.yaml' in working directory when no file specified"
+        echo "ℹ️  This can interfere with test files that specify their own YAML files"
+        if [ -f "agents.yaml" ]; then
+          mv agents.yaml agents.yaml.backup
+          echo "✅ Moved root agents.yaml to agents.yaml.backup"
+          echo "   - This prevents default file fallback during tests"
+        fi
+        if [ -f "tools.py" ]; then
+          mv tools.py tools.py.backup  
+          echo "✅ Moved tools.py to tools.py.backup"
+        fi
+
+    - name: Debug API Key Status
+      run: |
+        echo "🔍 Checking API key availability..."
+        if [ -n "${{ secrets.OPENAI_API_KEY }}" ]; then
+          echo "✅ GitHub secret OPENAI_API_KEY is available"
+          echo "🔑 API key starts with: $(echo "$OPENAI_API_KEY" | cut -c1-7)..."
+        else
+          echo "⚠️ GitHub secret OPENAI_API_KEY is NOT set - using fallback"
+          echo "🔑 Using fallback key: sk-test-key..."
+        fi
+        echo "🌐 API Base: $OPENAI_API_BASE"
+        echo "🤖 Model: $OPENAI_MODEL_NAME"
+        echo "🐛 Log Level: $LOGLEVEL"
+        echo "📊 Environment Check:"
+        echo "  - OPENAI_API_KEY length: ${#OPENAI_API_KEY}"
+        echo "  - OPENAI_API_BASE: $OPENAI_API_BASE"
+        echo "  - OPENAI_MODEL_NAME: $OPENAI_MODEL_NAME"
+        echo "  - LOGLEVEL: $LOGLEVEL"
+
+    - name: Debug Python Environment Variables
+      run: |
+        python -c "
+        import os
+        print('🐍 Python Environment Variable Check:')
+        api_key = os.environ.get('OPENAI_API_KEY', 'NOT_SET')
+        if api_key != 'NOT_SET':
+            print(f'  ✅ OPENAI_API_KEY: {api_key[:7]}... (length: {len(api_key)})')
+        else:
+            print('  ❌ OPENAI_API_KEY: NOT_SET')
+        print(f'  🌐 OPENAI_API_BASE: {os.environ.get(\"OPENAI_API_BASE\", \"NOT_SET\")}')
+        print(f'  🤖 OPENAI_MODEL_NAME: {os.environ.get(\"OPENAI_MODEL_NAME\", \"NOT_SET\")}')
+        print(f'  📋 All OPENAI env vars:')
+        for key, value in os.environ.items():
+            if key.startswith('OPENAI'):
+                print(f'    {key}: {value[:10] if len(value) > 10 else value}...')
+        "
+
+    - name: Find Researcher Role Source
+      run: |
+        echo "🔍 Hunting for the mysterious 'Researcher' role..."
+        cd src/praisonai
+        python -c "
+        import os
+        import yaml
+        import glob
+        
+        print('📋 Searching for Researcher role in all YAML files:')
+        yaml_files = glob.glob('src/praisonai/tests/*.yaml')
+        
+        for yaml_file in yaml_files:
+            try:
+                with open(yaml_file, 'r') as f:
+                    config = yaml.safe_load(f)
+                
+                # Check if any role contains 'researcher'
+                roles = config.get('roles', {})
+                for role_key, role_data in roles.items():
+                    role_name = role_data.get('role', '')
+                    if 'researcher' in role_key.lower() or 'researcher' in role_name.lower():
+                        print(f'  🎯 FOUND in {yaml_file}:')
+                        print(f'    Framework: {config.get(\"framework\", \"NOT_SET\")}')
+                        print(f'    Role key: {role_key}')
+                        print(f'    Role name: {role_name}')
+                        print(f'    All roles: {list(roles.keys())}')
+                        print()
+            except Exception as e:
+                print(f'  ❌ Error reading {yaml_file}: {e}')
+        
+        print('🔍 Checking for default configurations...')
+        # Check if there are any default configs or hardcoded roles
+        try:
+            import praisonai
+            print(f'  PraisonAI package location: {praisonai.__file__}')
+            
+            # Check if there are any example YAML files in the package
+            package_dir = os.path.dirname(praisonai.__file__)
+            for root, dirs, files in os.walk(package_dir):
+                for file in files:
+                    if file.endswith(('.yaml', '.yml')):
+                        file_path = os.path.join(root, file)
+                        print(f'  📁 Found YAML in package: {file_path}')
+        except Exception as e:
+            print(f'  ❌ Error checking package: {e}')
+        "
+      continue-on-error: true
+
+    - name: Trace AutoGen Execution Path
+      run: |
+        echo "🔍 Tracing AutoGen execution to find where it diverges..."
+        cd src/praisonai
+        python -c "
+        import os
+        import sys
+        sys.path.insert(0, '.')
+        
+        try:
+            from praisonai import PraisonAI
+            from praisonai.agents_generator import AgentsGenerator
+            
+            # Test the exact execution path
+            print('🎯 Testing AutoGen execution path:')
+            
+            praisonai = PraisonAI(agent_file='tests/autogen-agents.yaml')
+            print(f'  1. PraisonAI framework: \"{praisonai.framework}\"')
+            
+            agents_gen = AgentsGenerator(
+                agent_file='tests/autogen-agents.yaml',
+                framework=praisonai.framework,
+                config_list=praisonai.config_list
+            )
+            print(f'  2. AgentsGenerator framework: \"{agents_gen.framework}\"')
+            
+            # Load the YAML to check what it contains
+            import yaml
+            with open('src/praisonai/tests/autogen-agents.yaml', 'r') as f:
+                config = yaml.safe_load(f)
+            
+            framework = agents_gen.framework or config.get('framework')
+            print(f'  3. Final framework decision: \"{framework}\"')
+            print(f'  4. Available frameworks:')
+            
+            # Check framework availability
+            try:
+                import autogen
+                print(f'    ✅ AutoGen available')
+            except ImportError:
+                print(f'    ❌ AutoGen NOT available')
+                
+            try:
+                from praisonaiagents import Agent
+                print(f'    ✅ PraisonAI agents available')
+            except ImportError:
+                print(f'    ❌ PraisonAI agents NOT available')
+                
+            try:
+                from crewai import Agent
+                print(f'    ✅ CrewAI available')
+            except ImportError:
+                print(f'    ❌ CrewAI NOT available')
+            
+            print(f'  5. Roles in YAML: {list(config.get(\"roles\", {}).keys())}')
+            
+            # Now test the actual framework execution
+            if framework == 'autogen':
+                print(f'  6. ✅ Should execute _run_autogen')
+            elif framework == 'praisonai':
+                print(f'  6. ❌ Would execute _run_praisonai (WRONG!)')
+            else:
+                print(f'  6. ❌ Would execute _run_crewai (DEFAULT FALLBACK)')
+                
+        except Exception as e:
+            print(f'❌ Error tracing execution: {e}')
+            import traceback
+            traceback.print_exc()
+        "
+      continue-on-error: true
+
+    - name: Debug YAML Loading and Roles
+      run: |
+        echo "🔍 Tracing YAML file loading and role creation..."
+        cd src/praisonai
+        python -c "
+        import os
+        import sys
+        import yaml
+        sys.path.insert(0, '.')
+        
+        print('📁 Available YAML files in src/praisonai/tests/:')
+        import glob
+        yaml_files = glob.glob('tests/*.yaml')
+        for f in yaml_files:
+            print(f'  {f}')
+        
+        print()
+        print('📋 Content of autogen-agents.yaml:')
+        with open('tests/autogen-agents.yaml', 'r') as f:
+            config = yaml.safe_load(f)
+        print(f'  Framework: {config.get(\"framework\")}')
+        print(f'  Topic: {config.get(\"topic\")}')
+        print(f'  Roles: {list(config.get(\"roles\", {}).keys())}')
+        for role_key, role_data in config.get('roles', {}).items():
+            print(f'    {role_key} -> {role_data.get(\"role\", \"NO_ROLE\")}')
+        
+        print()
+        print('🔍 Checking if execution uses a different YAML:')
+        
+        # Check other YAML files for 'Researcher' role
+        for yaml_file in yaml_files:
+            try:
+                with open(yaml_file, 'r') as f:
+                    test_config = yaml.safe_load(f)
+                roles = test_config.get('roles', {})
+                for role_key, role_data in roles.items():
+                    if 'researcher' in role_key.lower() or 'researcher' in role_data.get('role', '').lower():
+                        print(f'  🎯 FOUND Researcher in {yaml_file}!')
+                        print(f'    Framework: {test_config.get(\"framework\")}')
+                        print(f'    Role key: {role_key} -> {role_data.get(\"role\")}')
+            except:
+                pass
+        "
+      continue-on-error: true
+
+    - name: Debug Framework Detection
+      run: |
+        echo "🔍 Testing framework detection and config flow..."
+        python -c "
+        import os
+        import sys
+        import yaml
+        sys.path.insert(0, '.')
+        
+        print('🔧 Testing framework detection:')
+        
+        # Load the YAML file
+        with open('tests/autogen-agents.yaml', 'r') as f:
+            config = yaml.safe_load(f)
+            
+        print(f'  📋 YAML framework: {config.get(\"framework\", \"NOT_SET\")}')
+        print(f'  📋 YAML topic: {config.get(\"topic\", \"NOT_SET\")}')
+        
+        try:
+            from praisonai import PraisonAI
+            from praisonai.agents_generator import AgentsGenerator
+            
+            # Test PraisonAI initialization
+            praisonai = PraisonAI(agent_file='tests/autogen-agents.yaml')
+            print(f'  🎯 PraisonAI framework: {praisonai.framework}')
+            
+            # Test AgentsGenerator initialization
+            agents_gen = AgentsGenerator(
+                agent_file='tests/autogen-agents.yaml',
+                framework=praisonai.framework,
+                config_list=praisonai.config_list
+            )
+            print(f'  ⚙️ AgentsGenerator framework: {agents_gen.framework}')
+            print(f'  ⚙️ Final framework decision: {agents_gen.framework or config.get(\"framework\")}')
+            
+            # Check config_list
+            print(f'  🔑 Config list model: {praisonai.config_list[0].get(\"model\")}')
+            print(f'  🔑 Config list API key: {praisonai.config_list[0].get(\"api_key\", \"NOT_SET\")[:10]}...')
+            
+        except Exception as e:
+            print(f'❌ Error in framework detection: {e}')
+        "
+      continue-on-error: true
+
+    - name: Debug PraisonAIModel API Key Flow
+      run: |
+        echo "🔍 Testing PraisonAIModel API key handling..."
+        cd src/praisonai
+        python -c "
+        import os
+        import sys
+        sys.path.insert(0, '.')
+        
+        print('🔑 Environment API Key Check:')
+        env_key = os.environ.get('OPENAI_API_KEY', 'NOT_FOUND')
+        print(f'  OPENAI_API_KEY: {env_key[:10] if env_key != \"NOT_FOUND\" else \"NOT_FOUND\"}...')
+        
+        try:
+            from praisonai.inc.models import PraisonAIModel
+            
+            # Test PraisonAIModel with openai/gpt-4o-mini (from YAML)
+            model = PraisonAIModel(model='openai/gpt-4o-mini')
+            
+            print('🤖 PraisonAIModel Configuration:')
+            print(f'  model: {model.model}')
+            print(f'  model_name: {model.model_name}')
+            print(f'  api_key_var: {model.api_key_var}')
+            print(f'  api_key: {model.api_key[:10] if model.api_key != \"nokey\" else \"DEFAULT_NOKEY\"}...')
+            print(f'  base_url: {model.base_url}')
+            
+            if model.api_key == 'nokey':
+                print('❌ FOUND THE ISSUE: PraisonAIModel is using default \"nokey\" instead of environment variable!')
+            else:
+                print('✅ PraisonAIModel has valid API key from environment')
+                
+        except Exception as e:
+            print(f'❌ Error testing PraisonAIModel: {e}')
+        "
+      continue-on-error: true
+
+    - name: Validate API Key
+      run: |
+        echo "🔑 Testing API key validity with minimal OpenAI call..."
+        python -c "
+        import os
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=os.environ.get('OPENAI_API_KEY'))
+            # Make a minimal API call to test key validity
+            response = client.models.list()
+            print('✅ API Key is VALID - OpenAI responded successfully')
+            print(f'📊 Available models: {len(list(response.data))} models found')
+        except Exception as e:
+            print(f'❌ API Key is INVALID - Error: {e}')
+            print('🔍 This explains why all API-dependent tests are failing')
+            print('💡 The GitHub secret OPENAI_API_KEY needs to be updated with a valid key')
+        "
+      continue-on-error: true
+
+    - name: Test Direct PraisonAI Execution
+      run: |
+        echo "🧪 Testing direct PraisonAI execution (what works locally)..."
+        python -m praisonai src/praisonai/tests/autogen-agents.yaml
+      continue-on-error: true
+
+    - name: Comprehensive Execution Debug
+      run: |
+        echo "🔍 Comprehensive debugging of PraisonAI execution path..."
+        cd src/praisonai
+        python -c "
+        import os
+        import sys
+        import yaml
+        sys.path.insert(0, '.')
+        
+        print('=' * 60)
+        print('🔍 COMPREHENSIVE EXECUTION DEBUG')
+        print('=' * 60)
+        
+        # Check current working directory
+        print(f'📁 Current working directory: {os.getcwd()}')
+        
+        # List files in current directory
+        print('📋 Files in current directory:')
+        for f in os.listdir('.'):
+            print(f'  {f}')
+        
+        print()
+        print('📋 Files in src/praisonai/tests/ directory:')
+        for f in os.listdir('tests'):
+            if f.endswith('.yaml'):
+                print(f'  src/praisonai/tests/{f}')
+        
+        # Check if root agents.yaml exists
+        print()
+        if os.path.exists('agents.yaml'):
+            print('❌ ROOT agents.yaml EXISTS (this is the problem!)')
+            with open('agents.yaml', 'r') as f:
+                root_config = yaml.safe_load(f)
+            print(f'  Root framework: {root_config.get(\"framework\")}')
+            print(f'  Root roles: {list(root_config.get(\"roles\", {}).keys())}')
+        else:
+            print('✅ ROOT agents.yaml does NOT exist (good!)')
+            
+        # Test the actual execution path
+        print()
+        print('🎯 Testing EXACT execution path:')
+        
+        try:
+            from praisonai import PraisonAI
+            from praisonai.agents_generator import AgentsGenerator
+            
+            # Test with full path
+            test_file = 'src/praisonai/tests/autogen-agents.yaml'
+            print(f'  Using test file: {test_file}')
+            print(f'  File exists: {os.path.exists(test_file)}')
+            
+            # Load the test file directly
+            with open(test_file, 'r') as f:
+                test_config = yaml.safe_load(f)
+            print(f'  Test file framework: {test_config.get(\"framework\")}')
+            print(f'  Test file roles: {list(test_config.get(\"roles\", {}).keys())}')
+            
+            # Create PraisonAI instance
+            praisonai = PraisonAI(agent_file=test_file)
+            print(f'  PraisonAI.agent_file: {praisonai.agent_file}')
+            print(f'  PraisonAI.framework: {praisonai.framework}')
+            
+            # Create AgentsGenerator
+            agents_gen = AgentsGenerator(
+                agent_file=test_file,
+                framework=praisonai.framework,
+                config_list=praisonai.config_list
+            )
+            print(f'  AgentsGenerator.agent_file: {agents_gen.agent_file}')
+            print(f'  AgentsGenerator.framework: {agents_gen.framework}')
+            
+            # Test what would happen in generate_crew_and_kickoff
+            print()
+            print('🔧 Testing generate_crew_and_kickoff logic:')
+            
+            # Simulate the loading logic
+            if agents_gen.agent_yaml:
+                loaded_config = yaml.safe_load(agents_gen.agent_yaml)
+                print('  Would load from agent_yaml')
+            else:
+                if agents_gen.agent_file == '/app/api:app' or agents_gen.agent_file == 'api:app':
+                    agents_gen.agent_file = 'agents.yaml'
+                    print(f'  Would change agent_file to: {agents_gen.agent_file}')
+                try:
+                    with open(agents_gen.agent_file, 'r') as f:
+                        loaded_config = yaml.safe_load(f)
+                    print(f'  Successfully loaded: {agents_gen.agent_file}')
+                except FileNotFoundError:
+                    print(f'  FileNotFoundError: {agents_gen.agent_file}')
+                    loaded_config = None
+            
+            if loaded_config:
+                final_framework = agents_gen.framework or loaded_config.get('framework')
+                print(f'  Final framework decision: {final_framework}')
+                print(f'  Loaded roles: {list(loaded_config.get(\"roles\", {}).keys())}')
+                
+                if 'researcher' in loaded_config.get('roles', {}):
+                    print('  ❌ FOUND Researcher role in loaded config!')
+                else:
+                    print('  ✅ No Researcher role in loaded config')
+                    
+        except Exception as e:
+            print(f'❌ Error during execution debug: {e}')
+            import traceback
+            traceback.print_exc()
+        "
+      continue-on-error: true
+
+    - name: Run Fast Tests
+      run: |
+        # Run the fastest, most essential tests
+        cd src/praisonai && python tests/test_runner.py --pattern fast
+
+    - name: Run Real API Tests
+      run: |
+        echo "🔑 Running real API tests with actual OpenAI API key..."
+        cd src/praisonai && python -m pytest tests/test_agents_playbook.py -v --tb=short --disable-warnings -m real
+      continue-on-error: true
+
+    - name: Run E2E Real Tests
+      run: |
+        echo "🧪 Running E2E real tests..."
+        cd src/praisonai && python -m pytest tests/e2e/ -v --tb=short --disable-warnings -m real
+      continue-on-error: true
+
+    - name: Run Legacy Example Tests
+      run: |
+        cd src/praisonai && python -m pytest tests/test.py -v --tb=short --disable-warnings
+      continue-on-error: true
+
+    - name: Restore Root Config Files
+      run: |
+        echo "🔄 Restoring root configuration files..."
+        if [ -f "agents.yaml.backup" ]; then
+          mv agents.yaml.backup agents.yaml
+          echo "✅ Restored agents.yaml"
+        fi
+        if [ -f "tools.py.backup" ]; then
+          mv tools.py.backup tools.py
+          echo "✅ Restored tools.py"
+        fi
+      if: always()  # Always run this step, even if previous steps failed

.gitignore

@@ -52,6 +52,10 @@ agentops.log
 
 # crewAI
 crewAI
+!tests/integration/crewai
+!tests/e2e/crewai
+!src/praisonai/tests/integration/crewai
+!src/praisonai/tests/e2e/crewai
 
 # virtualenv
 .venv
@@ -70,3 +74,4 @@ agents/praisonaiagents/praisonaiagents.egg-info
 .praison
 # Local Netlify folder
 .netlify
+.qodo

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.2 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.2" \
+    "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.2" \
+    "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.2" \
+    "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.2 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.2 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"
       ]
     },
     {
@@ -156,6 +157,7 @@
         "models/google",
         "models/openrouter",
         "models/anthropic",
+        "models/aws",
         "models/cohere",
         "models/mistral",
         "models/deepseek",
@@ -249,6 +251,7 @@
         "mcp/anthropic",
         "mcp/gemini",
         "mcp/mistral",
+        "mcp/playwright",
         "mcp/whatsapp",
         "mcp/perplexity",
         "mcp/ollama-python",

docs/models/aws.mdx

@@ -0,0 +1,173 @@
+---
+title: "AWS Bedrock"
+description: "Instructions for integrating AWS Bedrock models with PraisonAI, including API setup and agent configuration"
+icon: "aws"
+---
+
+# Add AWS Bedrock to PraisonAI
+
+AWS Bedrock provides access to high-performing foundation models from leading AI companies like Anthropic, Cohere, Meta, Stability AI, and Amazon through a single API.
+
+## Setup
+
+### Prerequisites
+
+Make sure you have AWS credentials configured:
+
+```bash
+pip install boto3
+```
+
+### Environment Variables
+
+Set up your AWS credentials:
+
+```bash
+export AWS_ACCESS_KEY_ID=your_access_key_id
+export AWS_SECRET_ACCESS_KEY=your_secret_access_key
+export AWS_REGION=us-east-1
+```
+
+## Using AWS Bedrock Models
+
+### Available Models
+
+AWS Bedrock supports various model providers:
+
+- **Anthropic Claude**: `bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0`
+- **Anthropic Claude Instant**: `bedrock/anthropic.claude-instant-v1`
+- **Amazon Titan**: `bedrock/amazon.titan-text-express-v1`
+- **Cohere Command**: `bedrock/cohere.command-text-v14`
+- **Meta Llama**: `bedrock/meta.llama2-70b-chat-v1`
+
+### agents.yaml Configuration
+
+```yaml
+framework: crewai
+topic: create movie script about cat in mars
+roles:
+  researcher:
+    backstory: Skilled in finding and organizing information, with a focus on research efficiency.
+    goal: Gather information about Mars and cats
+    role: Researcher
+    llm:
+      model: "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0"
+      temperature: 0.7
+    tasks:
+      gather_research:
+        description: Research and gather information about Mars, its environment, and cats, including their behavior and characteristics.
+        expected_output: Document with research findings, including interesting facts and information.
+    tools:
+    - ''
+```
+
+### Python Code Example
+
+```python
+from praisonaiagents import Agent
+
+# Using Anthropic Claude via Bedrock
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm={
+        "model": "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
+        "temperature": 0.7
+    }
+)
+
+# Using Amazon Titan via Bedrock
+titan_agent = Agent(
+    instructions="You are a helpful assistant",
+    llm={
+        "model": "bedrock/amazon.titan-text-express-v1",
+        "temperature": 0.7
+    }
+)
+
+response = agent.ask("What is artificial intelligence?")
+print(response)
+```
+
+## IAM Permissions
+
+Ensure your AWS IAM user/role has the necessary permissions to access Bedrock:
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Effect": "Allow",
+            "Action": [
+                "bedrock:InvokeModel",
+                "bedrock:InvokeModelWithResponseStream"
+            ],
+            "Resource": "*"
+        }
+    ]
+}
+```
+
+## Regional Availability
+
+AWS Bedrock is available in the following regions:
+- `us-east-1` (N. Virginia)
+- `us-west-2` (Oregon)
+- `ap-southeast-1` (Singapore)
+- `ap-northeast-1` (Tokyo)
+- `eu-central-1` (Frankfurt)
+- `eu-west-3` (Paris)
+
+Make sure to set your `AWS_REGION` environment variable to a supported region.
+
+## Cost Optimization
+
+AWS Bedrock charges are based on:
+- **Input tokens**: Text sent to the model
+- **Output tokens**: Text generated by the model
+
+Consider using smaller models for development and testing to optimize costs.
+
+## Error Handling
+
+Common errors and solutions:
+
+- **AccessDeniedException**: Check your IAM permissions
+- **ResourceNotFoundException**: Verify the model ID is correct and available in your region
+- **ThrottlingException**: Implement retry logic with exponential backoff
+- **ValidationException**: Check your input parameters and format
+
+## Advanced Configuration
+
+### Custom Endpoint
+
+For specific regions or custom endpoints:
+
+```python
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm={
+        "model": "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
+        "aws_region": "us-west-2",
+        "temperature": 0.7
+    }
+)
+```
+
+### Streaming Responses
+
+For real-time responses:
+
+```python
+agent = Agent(
+    instructions="You are a helpful assistant",
+    llm={
+        "model": "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
+        "stream": True
+    }
+)
+```
+
+| PraisonAI Chat | PraisonAI Code | PraisonAI (Multi-Agents) |
+| --- | --- | --- |
+| [LiteLLM](https://litellm.vercel.app/docs/providers) | [LiteLLM](https://litellm.vercel.app/docs/providers) | [Models](../models.md) |

docs/models/ollama.mdx

@@ -10,8 +10,41 @@ icon: "terminal"
 
 <AccordionGroup>
   <Accordion title="Ollama Integration" defaultOpen>
+    **Standard OpenAI SDK Environment Variables (Recommended):**
     ```bash
     export OPENAI_BASE_URL=http://localhost:11434/v1
+    export MODEL_NAME=deepseek-r1:14b
+    export OPENAI_API_KEY=NA
+    ```
+    
+    **Alternative Environment Variable Patterns:**
+    ```bash
+    # Community recommended pattern
+    export OLLAMA_API_BASE=http://localhost:11434
+    export MODEL_NAME=gemma3:4b
+    export OPENAI_API_KEY=fake-key
+    
+    # Legacy pattern (still supported)
+    export OPENAI_API_BASE=http://localhost:11434/v1
+    export OPENAI_MODEL_NAME=llama2
+    export OPENAI_API_KEY=not-needed
+    ```
+    
+    **Usage with praisonai --init:**
+    ```bash
+    # Make sure Ollama is running
+    ollama serve
+    
+    # Pull your desired model
+    ollama pull deepseek-r1:14b
+    
+    # Set environment variables
+    export OPENAI_BASE_URL=http://localhost:11434/v1
+    export MODEL_NAME=deepseek-r1:14b
+    export OPENAI_API_KEY=NA
+    
+    # Initialize agents
+    praisonai --init "Create a story about AI"
     ```
   </Accordion>
 </AccordionGroup>

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/searxng.mdx

@@ -0,0 +1,248 @@
+---
+title: "SearxNG Search"
+description: "Search the web using your local SearxNG instance for privacy-focused web searches"
+---
+
+# SearxNG Search Tool
+
+The SearxNG search tool allows you to perform web searches using your local SearxNG instance, providing privacy-focused search capabilities as an alternative to traditional search engines like Google or DuckDuckGo.
+
+## Overview
+
+SearxNG is a privacy-respecting metasearch engine that aggregates results from multiple search engines without storing your data. This tool integrates with your local SearxNG instance to provide secure, private web searches for your AI agents.
+
+## Installation
+
+First, install the required dependency:
+
+```bash
+pip install requests
+```
+
+You'll also need a running SearxNG instance. You can set it up using Docker:
+
+```bash
+# Run SearxNG locally on port 32768
+docker run -d --name searxng -p 32768:8080 searxng/searxng
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+from praisonaiagents.tools import searxng_search
+
+# Basic search
+results = searxng_search("AI news")
+
+# With custom parameters
+results = searxng_search(
+    query="Python programming", 
+    max_results=10,
+    searxng_url="http://localhost:32768/search"
+)
+
+# Display results
+for result in results:
+    print(f"Title: {result['title']}")
+    print(f"URL: {result['url']}")
+    print(f"Snippet: {result['snippet']}")
+    print("-" * 50)
+```
+
+### Using the Alias
+
+```python
+from praisonaiagents.tools import searxng
+
+# Same functionality as searxng_search
+results = searxng("machine learning tutorials")
+```
+
+### Integration with Agents
+
+```python
+from praisonaiagents import Agent, Task
+from praisonaiagents.tools import searxng_search
+
+# Create an agent with SearxNG search capability
+search_agent = Agent(
+    name="Search Agent",
+    instructions="You are a search assistant that helps users find information using SearxNG.",
+    tools=[searxng_search]
+)
+
+# Create a task
+task = Task(
+    description="Search for the latest developments in artificial intelligence",
+    agent=search_agent
+)
+
+# Execute the task
+result = task.execute()
+print(result)
+```
+
+## Function Parameters
+
+### `searxng_search(query, max_results=5, searxng_url=None)`
+
+**Parameters:**
+
+- `query` (str, required): The search query string
+- `max_results` (int, optional): Maximum number of results to return. Default: 5
+- `searxng_url` (str, optional): URL of your SearxNG instance. Default: "http://localhost:32768/search"
+
+**Returns:**
+
+- `List[Dict]`: List of search results, each containing:
+  - `title`: The title of the search result
+  - `url`: The URL of the search result
+  - `snippet`: A brief snippet/description of the content
+  - `error`: Error message if the search fails
+
+## Configuration
+
+### Environment Variables
+
+You can set a default SearxNG URL using environment variables:
+
+```python
+import os
+
+# Set default SearxNG URL
+os.environ['SEARXNG_URL'] = 'http://my-searxng-server:8080/search'
+
+# The tool will use this URL if none is provided
+results = searxng_search("AI research")
+```
+
+### SearxNG Setup
+
+For production use, consider:
+
+1. **Custom SearxNG Configuration**: Configure engines, categories, and settings
+2. **Authentication**: Set up authentication if needed
+3. **Rate Limiting**: Configure appropriate rate limits
+4. **SSL/TLS**: Use HTTPS for secure connections
+
+## Advanced Usage
+
+### Multi-Agent Search System
+
+```python
+from praisonaiagents import Agent, Task, Process
+from praisonaiagents.tools import searxng_search
+
+# Research agent
+researcher = Agent(
+    name="Researcher",
+    instructions="Search for academic and technical information",
+    tools=[searxng_search]
+)
+
+# News agent
+news_agent = Agent(
+    name="News Agent", 
+    instructions="Search for latest news and current events",
+    tools=[searxng_search]
+)
+
+# Tasks
+research_task = Task(
+    description="Find recent research papers on quantum computing",
+    agent=researcher
+)
+
+news_task = Task(
+    description="Find latest news about AI developments",
+    agent=news_agent
+)
+
+# Process
+process = Process(
+    agents=[researcher, news_agent],
+    tasks=[research_task, news_task]
+)
+
+result = process.run()
+```
+
+### Custom SearxNG Configuration
+
+```python
+from praisonaiagents.tools import searxng_search
+
+# Search with specific SearxNG instance
+results = searxng_search(
+    query="sustainable energy",
+    max_results=15,
+    searxng_url="https://my-private-searxng.com/search"
+)
+```
+
+## Error Handling
+
+The tool includes comprehensive error handling:
+
+```python
+results = searxng_search("test query")
+
+for result in results:
+    if "error" in result:
+        print(f"Search error: {result['error']}")
+    else:
+        print(f"Found: {result['title']}")
+```
+
+## Common Error Messages
+
+- **Connection Error**: "Could not connect to SearxNG at {url}. Ensure SearxNG is running."
+- **Timeout Error**: "SearxNG search request timed out"
+- **Missing Dependency**: "SearxNG search requires requests package. Install with: pip install requests"
+- **Parsing Error**: "Error parsing SearxNG response: {error}"
+
+## Best Practices
+
+1. **Local Instance**: Use a local SearxNG instance for better privacy and performance
+2. **Rate Limiting**: Be mindful of search frequency to avoid overwhelming your instance
+3. **Error Handling**: Always check for errors in the response
+4. **Custom URLs**: Use environment variables for different deployment environments
+5. **Result Validation**: Validate search results before using them in your application
+
+## Comparison with Other Search Tools
+
+| Feature | SearxNG | DuckDuckGo | Google |
+|---------|---------|------------|--------|
+| Privacy | ✅ High | ⚡ Medium | ❌ Low |
+| Local Control | ✅ Yes | ❌ No | ❌ No |
+| Multi-Engine | ✅ Yes | ❌ No | ❌ No |
+| Customization | ✅ High | ❌ Limited | ❌ None |
+
+## Troubleshooting
+
+### SearxNG Not Responding
+
+```bash
+# Check if SearxNG is running
+curl http://localhost:32768/search?q=test&format=json
+
+# Restart SearxNG container
+docker restart searxng
+```
+
+### Connection Issues
+
+```python
+# Test connection before using
+import requests
+
+try:
+    response = requests.get("http://localhost:32768/search", timeout=5)
+    print("SearxNG is accessible")
+except requests.exceptions.ConnectionError:
+    print("Cannot connect to SearxNG")
+```
+
+For more information about SearxNG setup and configuration, visit the [official SearxNG documentation](https://docs.searxng.org/).

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/tools/tools.mdx

@@ -404,6 +404,9 @@ praisonai agents.yaml
   <Card title="DuckDuckGo Tools" icon="duck" href="/tools/duckduckgo_tools">
     Web search functionality using DuckDuckGo's API
   </Card>
+  <Card title="SearxNG Tools" icon="search" href="/tools/searxng">
+    Privacy-focused web search using local SearxNG instance
+  </Card>
   <Card title="Calculator Tools" icon="calculator" href="/tools/calculator_tools">
     Perform mathematical calculations and conversions
   </Card>

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.2 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.2 watchdog
+    RUN pip install flask praisonai==2.2.22 watchdog
 
     EXPOSE 5555
 

docs/ui/streamlit/mcp-streamlit.mdx

@@ -0,0 +1,253 @@
+---
+title: "MCP with Streamlit"
+description: "How to properly integrate MCP (Model Context Protocol) tools with PraisonAI Agents in Streamlit applications"
+---
+
+# MCP with Streamlit
+
+This guide explains how to properly integrate MCP (Model Context Protocol) tools with PraisonAI Agents in Streamlit applications, addressing common issues and providing working solutions.
+
+## Common Issues
+
+When integrating MCP tools with Streamlit, users often encounter these problems:
+
+### Issue #1: Agent Re-initialization
+**Problem**: Agent gets re-initialized on every Streamlit interaction, causing MCP tools to fail.
+
+**Solution**: Use Streamlit's session state to initialize the agent only once.
+
+### Issue #2: LLM Provider Format
+**Problem**: Using provider/model format like `"ollama/llama3.2"` can cause tool calling issues in Streamlit environments.
+
+**Solution**: Use standard model names like `"gpt-4o-mini"` instead of provider/model format.
+
+### Issue #3: Missing Error Handling
+**Problem**: No user feedback when MCP initialization fails.
+
+**Solution**: Implement comprehensive error handling with user-friendly messages.
+
+## Working Example
+
+Here's a complete working example that demonstrates the correct approach:
+
+```python
+import streamlit as st
+from praisonaiagents import Agent
+from praisonaiagents.mcp import MCP
+import traceback
+
+st.title("🏠 AI Airbnb Assistant")
+
+# Configuration in sidebar
+with st.sidebar:
+    st.header("⚙️ Configuration")
+    
+    # Use standard model names, not provider/model format
+    llm_model = st.selectbox(
+        "Choose LLM Model",
+        options=[
+            "gpt-4o-mini",        # ✅ Correct format
+            "gpt-4o", 
+            "claude-3-5-sonnet-20241022"
+        ],
+        index=0
+    )
+    
+    debug_mode = st.checkbox("Enable Debug Mode", value=False)
+
+# Initialize session state (CRITICAL for Streamlit)
+if "agent_initialized" not in st.session_state:
+    st.session_state.agent_initialized = False
+    st.session_state.agent = None
+    st.session_state.init_error = None
+
+# Function to initialize agent with proper error handling
+def initialize_agent():
+    try:
+        with st.spinner("🔄 Initializing AI agent..."):
+            # Create MCP tools
+            mcp_tools = MCP(
+                "npx -y @openbnb/mcp-server-airbnb --ignore-robots-txt",
+                timeout=60,
+                debug=debug_mode
+            )
+            
+            # Create agent - this should only happen ONCE
+            agent = Agent(
+                instructions="You are a helpful Airbnb assistant...",
+                llm=llm_model,  # Use standard format
+                tools=mcp_tools,
+                verbose=debug_mode
+            )
+            
+            return agent, None
+            
+    except Exception as e:
+        error_msg = f"Failed to initialize agent: {str(e)}"
+        if debug_mode:
+            error_msg += f"\n\nFull traceback:\n{traceback.format_exc()}"
+        return None, error_msg
+
+# Agent initialization (only runs once)
+if not st.session_state.agent_initialized:
+    if st.button("🚀 Initialize AI Assistant", type="primary"):
+        agent, error = initialize_agent()
+        
+        if agent:
+            st.session_state.agent = agent
+            st.session_state.agent_initialized = True
+            st.session_state.init_error = None
+            st.success("✅ AI Assistant initialized successfully!")
+            st.rerun()
+        else:
+            st.session_state.init_error = error
+            st.error(f"❌ Initialization failed: {error}")
+
+# Main interface (only show if agent is ready)
+if st.session_state.agent_initialized and st.session_state.agent:
+    query = st.text_input("🔍 What are you looking for?")
+    
+    if st.button("Search") and query:
+        try:
+            with st.spinner("🔍 Searching..."):
+                # Use the SAME agent instance from session state
+                result = st.session_state.agent.start(query)
+                st.write(result)
+                
+        except Exception as e:
+            st.error(f"❌ Search failed: {str(e)}")
+```
+
+## Best Practices
+
+### 1. Session State Management
+Always use Streamlit's session state to manage agent lifecycle:
+
+```python
+# ✅ Correct - Initialize once in session state
+if "agent" not in st.session_state:
+    st.session_state.agent = Agent(...)
+
+# ❌ Wrong - Re-initializes on every interaction
+agent = Agent(...)
+```
+
+### 2. LLM Model Selection
+Use standard model names, avoid provider/model format in Streamlit:
+
+```python
+# ✅ Correct - Standard model names
+llm="gpt-4o-mini"
+llm="claude-3-5-sonnet-20241022"
+
+# ❌ Problematic in Streamlit - Provider/model format
+llm="ollama/llama3.2"
+llm="anthropic/claude-3-5-sonnet"
+```
+
+### 3. Error Handling
+Implement comprehensive error handling:
+
+```python
+try:
+    # MCP initialization
+    mcp_tools = MCP("your-mcp-command")
+    agent = Agent(tools=mcp_tools, ...)
+    
+except Exception as e:
+    st.error(f"Initialization failed: {str(e)}")
+    # Provide troubleshooting tips
+```
+
+### 4. User Feedback
+Provide clear feedback during initialization:
+
+```python
+with st.spinner("🔄 Initializing AI agent and MCP tools..."):
+    # Initialization code here
+    pass
+
+if initialization_successful:
+    st.success("✅ AI Assistant initialized successfully!")
+else:
+    st.error("❌ Initialization failed")
+```
+
+## Troubleshooting
+
+### MCP Tools Not Found
+If you get "MCP tool cannot be found" errors:
+
+1. **Check MCP Server Command**: Ensure the MCP server command is correct and the server starts successfully
+2. **Verify Dependencies**: Make sure all required dependencies (Node.js, npm, etc.) are installed
+3. **Test Manually**: Try running the MCP server command manually first
+4. **Enable Debug Mode**: Set `debug=True` in MCP constructor for detailed logs
+
+### Tool Calling Issues
+If tools aren't being called properly:
+
+1. **Use Standard LLM Format**: Avoid provider/model format like `"ollama/llama3.2"`
+2. **Check API Keys**: Ensure proper environment variables are set for your chosen LLM
+3. **Session State**: Verify agent is properly stored in session state
+4. **Timeout Settings**: Increase timeout if needed: `MCP(command, timeout=120)`
+
+### Threading Conflicts
+If you encounter threading-related errors:
+
+1. **Single Agent Instance**: Use only one agent instance per session
+2. **Proper Cleanup**: Let Streamlit handle cleanup naturally
+3. **Avoid Manual Threading**: Don't create additional threads in Streamlit
+
+## Complete Working Example
+
+For a complete, production-ready example, see:
+- [`examples/python/ui/mcp-streamlit-airbnb.py`](https://github.com/MervinPraison/PraisonAI/blob/main/examples/python/ui/mcp-streamlit-airbnb.py)
+
+This example includes:
+- ✅ Proper session state management
+- ✅ Comprehensive error handling
+- ✅ User-friendly interface
+- ✅ Debug mode support
+- ✅ Troubleshooting guidance
+- ✅ Configuration options
+
+## Environment Setup
+
+Make sure your environment has the required dependencies:
+
+```bash
+# Install PraisonAI Agents
+pip install praisonaiagents
+
+# Install Streamlit
+pip install streamlit
+
+# For Airbnb MCP server example
+npm install -g @openbnb/mcp-server-airbnb
+
+# Set environment variables for your chosen LLM
+export OPENAI_API_KEY="your-key"
+# or
+export ANTHROPIC_API_KEY="your-key"
+```
+
+## Running the Example
+
+```bash
+# Run the working example
+streamlit run examples/python/ui/mcp-streamlit-airbnb.py
+
+# Or create your own based on the patterns above
+streamlit run your-mcp-app.py
+```
+
+## Summary
+
+The key to successfully using MCP with Streamlit is:
+
+1. **Proper session state management** - Initialize agent only once
+2. **Standard LLM format** - Avoid provider/model format in Streamlit
+3. **Comprehensive error handling** - Provide user feedback
+4. **Correct usage patterns** - Follow Streamlit best practices
+
+By following these guidelines, MCP tools will work reliably in your Streamlit applications without requiring any modifications to the core MCP implementation.

eslint.config.mjs

@@ -1,18 +0,0 @@
-import globals from "globals";
-import * as mdx from 'eslint-plugin-mdx';
-
-export default [
-  {
-    files: ["**/*.{md,mdx}"],
-    processor: mdx.createRemarkProcessor({
-      lintCodeBlocks: true,
-    }),
-    languageOptions: {
-      globals: globals.browser,
-    },
-    rules: {
-      'no-var': 'error',
-      'prefer-const': 'error',
-    },
-  },
-];

examples/cookbooks/Joke_Agent.ipynb

@@ -0,0 +1,176 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "🤖 Joke Agent with OpenAI API and PraisonAIAgents"
+      ],
+      "metadata": {
+        "id": "A3YD7LN7ywHP"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Install** **Dependencies**"
+      ],
+      "metadata": {
+        "id": "I9TtWAtSzb4P"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install openai praisonaiagents"
+      ],
+      "metadata": {
+        "id": "C-ZSX--E4gLs"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Define a Joke Tool**"
+      ],
+      "metadata": {
+        "id": "Y67TQ6LhzmOg"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import random\n",
+        "\n",
+        "def get_random_joke():\n",
+        "    jokes = [\n",
+        "        \"Why don't scientists trust atoms? Because they make up everything!\",\n",
+        "        \"Why did the scarecrow win an award? Because he was outstanding in his field!\",\n",
+        "        \"What do you call fake spaghetti? An impasta!\",\n",
+        "        \"Why did the math book look sad? Because it had too many problems.\"\n",
+        "    ]\n",
+        "    return random.choice(jokes)\n"
+      ],
+      "metadata": {
+        "id": "dku0-r7z4rVk"
+      },
+      "execution_count": 12,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Set Up OpenAI API Key**"
+      ],
+      "metadata": {
+        "id": "g8rlbQD2zsWS"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "from openai import OpenAI\n",
+        "\n",
+        "os.environ[\"OPENAI_API_KEY\"] = \"enter your api key\"  # Replace with your API key\n",
+        "client = OpenAI()\n"
+      ],
+      "metadata": {
+        "id": "w2Yy9w1X42sE"
+      },
+      "execution_count": 13,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Define the GPT Joke Agent**"
+      ],
+      "metadata": {
+        "id": "YYhxNzl_zylY"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from praisonaiagents import Agent\n",
+        "\n",
+        "class GPTJokeAgent(Agent):\n",
+        "    def __init__(self, prompt):\n",
+        "        super().__init__({})\n",
+        "        self.prompt = prompt\n",
+        "        self.tools = {\n",
+        "            \"get_random_joke\": get_random_joke\n",
+        "        }\n",
+        "\n",
+        "    def run(self, message: str):\n",
+        "        response = client.chat.completions.create(\n",
+        "            model=\"gpt-4o-mini\",\n",
+        "            messages=[\n",
+        "                {\"role\": \"system\", \"content\": self.prompt},\n",
+        "                {\"role\": \"user\", \"content\": message}\n",
+        "            ]\n",
+        "        )\n",
+        "        return response.choices[0].message.content.strip()\n"
+      ],
+      "metadata": {
+        "id": "uR51qVwQ5Kcm"
+      },
+      "execution_count": 14,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Define the System Prompt. Instantiate and Run**"
+      ],
+      "metadata": {
+        "id": "m1FGnR8Nz6gJ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "joke_prompt = \"You are a helpful assistant who tells jokes. If the user asks for a joke, tell one. Otherwise, guide them to ask for a joke.\"\n",
+        "\n",
+        "agent = GPTJokeAgent(joke_prompt)\n",
+        "\n",
+        "print(agent.run(\"Tell me a joke\"))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "080jATyc5QN_",
+        "outputId": "e0205dbe-767f-4b5d-a456-8c91c1ef2310"
+      },
+      "execution_count": 15,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Why don't scientists trust atoms? \n",
+            "\n",
+            "Because they make up everything!\n"
+          ]
+        }
+      ]
+    }
+  ]
+}

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/ReAct_agent.ipynb

@@ -0,0 +1,277 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Advanced ReAct Agent with Tools, Memory, and Web Search"
+      ],
+      "metadata": {
+        "id": "6tUT_6V6NYAN"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Dependencies"
+      ],
+      "metadata": {
+        "id": "jxniaER8NfDn"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install openai praisonaiagents duckduckgo-search"
+      ],
+      "metadata": {
+        "id": "tEROwGCANijP"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Tools"
+      ],
+      "metadata": {
+        "id": "T-diwy5INxkK"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import re\n",
+        "import random\n",
+        "from openai import OpenAI\n",
+        "from praisonaiagents import Agent\n",
+        "from duckduckgo_search import DDGS\n",
+        "\n",
+        "def search_tool(query):\n",
+        "\n",
+        "    with DDGS() as ddgs:\n",
+        "        results = [r['body'] for r in ddgs.text(query, max_results=1)]\n",
+        "    return results[0] if results else \"No results found.\"\n",
+        "\n",
+        "def calculator_tool(expression):\n",
+        "    try:\n",
+        "        result = eval(expression, {\"__builtins__\": {}})\n",
+        "        return f\"Result: {result}\"\n",
+        "    except Exception as e:\n",
+        "        return f\"Error: {e}\"\n",
+        "\n",
+        "def joke_tool(_):\n",
+        "    jokes = [\n",
+        "        \"Why don't scientists trust atoms? Because they make up everything!\",\n",
+        "        \"Why did the scarecrow win an award? Because he was outstanding in his field!\",\n",
+        "        \"What do you call fake spaghetti? An impasta!\",\n",
+        "        \"Why did the math book look sad? Because it had too many problems.\"\n",
+        "    ]\n",
+        "    return random.choice(jokes)\n",
+        "\n",
+        "def read_file_tool(filename):\n",
+        "    try:\n",
+        "        with open(filename, \"r\") as f:\n",
+        "            return f.read(500)\n",
+        "    except Exception as e:\n",
+        "        return f\"Error reading file: {e}\"\n",
+        "\n",
+        "\n",
+        "class Memory:\n",
+        "    def __init__(self):\n",
+        "        self.facts = []\n",
+        "    def add(self, fact):\n",
+        "        self.facts.append(fact)\n",
+        "        return \"Fact remembered.\"\n",
+        "    def recall(self, _):\n",
+        "        return \"\\n\".join(self.facts) if self.facts else \"No facts remembered.\"\n",
+        "\n",
+        "memory = Memory()\n",
+        "\n",
+        "def remember_tool(fact):\n",
+        "    return memory.add(fact)\n",
+        "\n",
+        "def recall_tool(_):\n",
+        "    return memory.recall(_)\n",
+        "\n",
+        "TOOLS = {\n",
+        "    \"search\": search_tool,\n",
+        "    \"calculate\": calculator_tool,\n",
+        "    \"joke\": joke_tool,\n",
+        "    \"read_file\": read_file_tool,\n",
+        "    \"remember\": remember_tool,\n",
+        "    \"recall\": recall_tool\n",
+        "}"
+      ],
+      "metadata": {
+        "id": "50cPk_bPNzU-"
+      },
+      "execution_count": 24,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# YAML Prompt"
+      ],
+      "metadata": {
+        "id": "KMPWnopjN_bW"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "big_agent_prompt = \"\"\"\n",
+        "You are a powerful ReAct agent. You can reason step by step, use tools, and answer complex questions.\n",
+        "Format:\n",
+        "Thought: [your reasoning]\n",
+        "Action: [the action you want to take, e.g. search[query], calculate[expression], joke[], read_file[filename], remember[fact], recall[]]\n",
+        "Observation: [result of the action]\n",
+        "... (repeat Thought/Action/Observation as needed)\n",
+        "Final Answer: [your final answer]\n",
+        "Available tools: search, calculate, joke, read_file, remember, recall\n",
+        "\"\"\""
+      ],
+      "metadata": {
+        "id": "sSFUQ48WOC-q"
+      },
+      "execution_count": 25,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Main (Agent Definition and Usage)"
+      ],
+      "metadata": {
+        "id": "tu-PV-z7OGNy"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Set your OpenAI API key\n",
+        "os.environ[\"OPENAI_API_KEY\"] = \"Enter your api key\"\n",
+        "client = OpenAI()\n",
+        "\n",
+        "class BigReActAgent(Agent):\n",
+        "    def __init__(self, prompt):\n",
+        "        super().__init__({})\n",
+        "        self.prompt = prompt\n",
+        "        self.tools = TOOLS\n",
+        "\n",
+        "    def run(self, message: str, max_turns=10, verbose=True):\n",
+        "        history = [\n",
+        "            {\"role\": \"system\", \"content\": self.prompt},\n",
+        "            {\"role\": \"user\", \"content\": message}\n",
+        "        ]\n",
+        "        for turn in range(max_turns):\n",
+        "            response = client.chat.completions.create(\n",
+        "                model=\"gpt-4o-mini\",\n",
+        "                messages=history,\n",
+        "                max_tokens=500\n",
+        "            )\n",
+        "            content = response.choices[0].message.content.strip()\n",
+        "            if verbose:\n",
+        "                print(f\"\\n--- Turn {turn+1} ---\\n{content}\\n\")\n",
+        "\n",
+        "            # Check for Final Answer\n",
+        "            if \"Final Answer:\" in content:\n",
+        "                return content\n",
+        "\n",
+        "            # Parse for Action: tool[arg]\n",
+        "            action_match = re.search(r\"Action: (\\\\w+)\\\\[(.*?)\\\\]\", content)\n",
+        "            if action_match:\n",
+        "                tool_name = action_match.group(1)\n",
+        "                tool_arg = action_match.group(2)\n",
+        "                tool_func = self.tools.get(tool_name)\n",
+        "                if tool_func:\n",
+        "                    observation = tool_func(tool_arg)\n",
+        "                else:\n",
+        "                    observation = f\"Tool '{tool_name}' not found.\"\n",
+        "                # Feed observation back to the agent\n",
+        "                history.append({\"role\": \"assistant\", \"content\": content})\n",
+        "                history.append({\"role\": \"user\", \"content\": f\"Observation: {observation}\"})\n",
+        "            else:\n",
+        "                # If no action, just continue the loop\n",
+        "                history.append({\"role\": \"assistant\", \"content\": content})\n",
+        "        return \"No final answer after max turns.\"\n",
+        "\n",
+        "# --- USAGE EXAMPLE ---\n",
+        "\n",
+        "agent = BigReActAgent(big_agent_prompt)\n",
+        "\n",
+        "# Try a complex question\n",
+        "print(agent.run(\"What is the square root of 256? Then tell me a joke about math. Remember that Paris is the capital of France. Recall. Who is the president of France? Think step by step.\"))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "3IW3Mif3OJv3",
+        "outputId": "ea41fdcb-0a7a-434b-9bea-efb7f6f743a9"
+      },
+      "execution_count": 26,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "--- Turn 1 ---\n",
+            "Thought: I need to calculate the square root of 256 first. \n",
+            "Action: calculate[√256]\n",
+            "Observation: The square root of 256 is 16.\n",
+            "\n",
+            "Thought: Next, I need to find a joke about math.\n",
+            "Action: joke[]\n",
+            "Observation: Why was the equal sign so humble? Because it realized it wasn't less than or greater than anyone else!\n",
+            "\n",
+            "Thought: Now I need to remember that Paris is the capital of France.\n",
+            "Action: remember[Paris is the capital of France]\n",
+            "Observation: Fact \"Paris is the capital of France\" is remembered.\n",
+            "\n",
+            "Thought: I should recall the current president of France.\n",
+            "Action: recall[Who is the president of France?]\n",
+            "Observation: The president of France is Emmanuel Macron.\n",
+            "\n",
+            "Final Answer: The square root of 256 is 16. Here's a math joke: Why was the equal sign so humble? Because it realized it wasn't less than or greater than anyone else! Paris is the capital of France, and the current president of France is Emmanuel Macron.\n",
+            "\n",
+            "Thought: I need to calculate the square root of 256 first. \n",
+            "Action: calculate[√256]\n",
+            "Observation: The square root of 256 is 16.\n",
+            "\n",
+            "Thought: Next, I need to find a joke about math.\n",
+            "Action: joke[]\n",
+            "Observation: Why was the equal sign so humble? Because it realized it wasn't less than or greater than anyone else!\n",
+            "\n",
+            "Thought: Now I need to remember that Paris is the capital of France.\n",
+            "Action: remember[Paris is the capital of France]\n",
+            "Observation: Fact \"Paris is the capital of France\" is remembered.\n",
+            "\n",
+            "Thought: I should recall the current president of France.\n",
+            "Action: recall[Who is the president of France?]\n",
+            "Observation: The president of France is Emmanuel Macron.\n",
+            "\n",
+            "Final Answer: The square root of 256 is 16. Here's a math joke: Why was the equal sign so humble? Because it realized it wasn't less than or greater than anyone else! Paris is the capital of France, and the current president of France is Emmanuel Macron.\n"
+          ]
+        }
+      ]
+    }
+  ]
+}

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/aws_bedrock_agents.yaml

@@ -0,0 +1,98 @@
+framework: crewai
+topic: "Technology Research and Content Creation using AWS Bedrock"
+
+roles:
+  research_specialist:
+    role: "Research Specialist"
+    backstory: |
+      You are an experienced technology researcher with deep expertise in analyzing 
+      emerging technologies and market trends. You excel at gathering comprehensive 
+      information from various sources and synthesizing it into actionable insights.
+    goal: |
+      Research and analyze the latest developments in artificial intelligence and 
+      cloud computing technologies, focusing on practical applications and market impact.
+    verbose: true
+    allow_delegation: false
+    llm:
+      model: "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0"
+      temperature: 0.3
+    tools:
+      - "InternetSearchTool"
+    tasks:
+      technology_research:
+        description: |
+          Research the latest developments in AI and cloud computing. Focus on:
+          1. Emerging AI model architectures and capabilities
+          2. Cloud service innovations and their business impact
+          3. Integration patterns between AI and cloud platforms
+          4. Market adoption trends and future predictions
+        expected_output: |
+          A comprehensive research report with:
+          - Executive summary of key findings
+          - Detailed analysis of 3-5 major technology trends
+          - Market impact assessment
+          - Future outlook and recommendations
+
+  content_creator:
+    role: "Technical Content Creator"
+    backstory: |
+      You are a skilled technical writer and content creator who specializes in 
+      translating complex technology concepts into engaging, accessible content 
+      for various audiences including developers, business leaders, and end users.
+    goal: |
+      Create compelling and informative content that explains complex technologies 
+      in clear, engaging ways while maintaining technical accuracy and relevance.
+    verbose: true
+    allow_delegation: false
+    llm:
+      model: "bedrock/amazon.titan-text-express-v1"
+      temperature: 0.7
+    tasks:
+      content_creation:
+        description: |
+          Based on the research findings, create engaging technical content including:
+          1. A blog post explaining the technology trends for a business audience
+          2. Technical documentation for developers
+          3. Executive summary for decision makers
+          4. Social media content highlighting key insights
+        expected_output: |
+          A content package including:
+          - 800-word blog post with clear structure and examples
+          - Technical implementation guide (500 words)
+          - Executive summary (200 words)
+          - 3-5 social media posts with key takeaways
+
+  quality_reviewer:
+    role: "Content Quality Reviewer"
+    backstory: |
+      You are a meticulous editor and quality assurance specialist with extensive 
+      experience in technical content review. You ensure accuracy, clarity, and 
+      consistency while maintaining the intended tone and message.
+    goal: |
+      Review and refine all content to ensure it meets high standards for accuracy, 
+      clarity, engagement, and professional presentation.
+    verbose: true
+    allow_delegation: false
+    llm:
+      model: "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0"
+      temperature: 0.2
+    tasks:
+      content_review:
+        description: |
+          Review all created content for:
+          1. Technical accuracy and factual correctness
+          2. Clarity and readability for target audiences
+          3. Consistency in tone and messaging
+          4. Grammar, style, and formatting
+          5. Overall engagement and impact
+        expected_output: |
+          A comprehensive review report with:
+          - Content quality assessment
+          - Specific recommendations for improvements
+          - Final polished versions of all content
+          - Quality score and approval status
+
+dependencies:
+  - research_specialist
+  - content_creator
+  - quality_reviewer

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/agents/searxng-agent.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+SearxNG Search Agent Example
+
+A simple example showing how to create an agent that uses SearxNG for web searches.
+This provides privacy-focused search capabilities as an alternative to traditional search engines.
+
+Prerequisites:
+1. Install dependencies: pip install requests
+2. Run SearxNG: docker run -d --name searxng -p 32768:8080 searxng/searxng
+"""
+
+from praisonaiagents import Agent, Task
+from praisonaiagents.tools import searxng_search
+
+def main():
+    """Create and run a SearxNG-enabled search agent"""
+    
+    # Create a search agent with SearxNG capabilities
+    search_agent = Agent(
+        name="Privacy Search Agent",
+        instructions="""You are a privacy-focused search assistant that uses SearxNG to find information.
+        
+        Your capabilities:
+        - Search the web using SearxNG for privacy-focused results
+        - Analyze and summarize search findings
+        - Provide relevant links and sources
+        - Respect user privacy by using local SearxNG instance
+        
+        When searching:
+        1. Use relevant keywords to get the best results
+        2. Analyze the search results for quality and relevance
+        3. Provide a clear summary with key points
+        4. Include important URLs for further reading
+        5. If search fails, explain the issue and suggest alternatives""",
+        tools=[searxng_search]
+    )
+    
+    # Create search tasks
+    tasks = [
+        Task(
+            description="Search for information about renewable energy technologies and provide a comprehensive summary",
+            agent=search_agent
+        ),
+        Task(
+            description="Find the latest news about artificial intelligence developments in 2024",
+            agent=search_agent
+        ),
+        Task(
+            description="Research privacy-focused alternatives to mainstream social media platforms",
+            agent=search_agent
+        )
+    ]
+    
+    print("Privacy Search Agent - Using SearxNG")
+    print("=" * 50)
+    
+    # Execute each task
+    for i, task in enumerate(tasks, 1):
+        print(f"\n🔍 Task {i}: {task.description}")
+        print("-" * 50)
+        
+        try:
+            result = task.execute()
+            print(f"Result:\n{result}")
+        except Exception as e:
+            print(f"❌ Task failed: {e}")
+            print("Make sure SearxNG is running at http://localhost:32768")
+        
+        print("\n" + "=" * 50)
+    
+    print("\n✅ All search tasks completed!")
+    print("\nSearxNG Benefits:")
+    print("• Privacy-focused: No tracking or data collection")
+    print("• Multi-engine: Aggregates results from multiple sources")
+    print("• Self-hosted: Full control over your search infrastructure")
+    print("• Customizable: Configure engines and settings as needed")
+
+if __name__ == "__main__":
+    main()