Merge pull request #534 from MervinPraison/develop

2.2.18
chore: update PraisonAI version and enhance environment variable handling
2026-11-09 11:51:37 -10:00 · 2025-05-29 04:52:31 +01:00 · 2025-05-29 04:51:53 +01:00 · 2025-05-29 04:38:51 +01:00 · 2025-05-28 18:41:01 +01:00 · 2025-05-28 18:40:48 +01:00
550 changed files with 14491 additions and 5957 deletions
@@ -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. 
@@ -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": {}
-    }
-  }
@@ -0,0 +1,37 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@beta
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+
@@ -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
@@ -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/
@@ -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/
@@ -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 
@@ -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
@@ -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 
@@ -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 
@@ -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 
@@ -1,36 +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 Poetry
+    - name: Install UV
      run: |
-        curl -sSL https://install.python-poetry.org | python3 -
-        export PATH="$HOME/.local/bin:$PATH"
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.local/bin" >> $GITHUB_PATH
+

    - name: Install dependencies
      run: |
-        poetry install
-        poetry run python -m 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: |
-        poetry 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
@@ -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
@@ -1,6 +1,6 @@
 FROM python:3.11-slim
 WORKDIR /app
 COPY . .
-RUN pip install flask praisonai==2.1.1 gunicorn markdown
+RUN pip install flask praisonai==2.2.18 gunicorn markdown
 EXPOSE 8080
 CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]
@@ -13,7 +13,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN pip install --no-cache-dir \
    praisonaiagents>=0.0.4 \
    praisonai_tools \
-    "praisonai==2.0.18" \
+    "praisonai==2.2.18" \
    "praisonai[chat]" \
    "embedchain[github,youtube]"

@@ -15,7 +15,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN pip install --no-cache-dir \
    praisonaiagents>=0.0.4 \
    praisonai_tools \
-    "praisonai==2.0.18" \
+    "praisonai==2.2.18" \
    "praisonai[ui]" \
    "praisonai[chat]" \
    "praisonai[realtime]" \
@@ -13,7 +13,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN pip install --no-cache-dir \
    praisonaiagents>=0.0.4 \
    praisonai_tools \
-    "praisonai==2.0.18" \
+    "praisonai==2.2.18" \
    "praisonai[ui]" \
    "praisonai[crewai]"

@@ -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.1.1 gunicorn markdown\n&#34;)
+            file.write(&#34;RUN pip install flask praisonai==2.2.18 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;)
            
@@ -0,0 +1,416 @@
+---
+title: "Deploying to AWS"
+sidebarTitle: "AWS"
+description: "Deploy PraisonAI agents to Amazon Web Services for scalable production environments"
+icon: "aws"
+---
+
+# Deploying PraisonAI Agents to AWS
+
+This guide provides step-by-step instructions for deploying PraisonAI agents to Amazon Web Services (AWS), offering multiple deployment options to suit different requirements.
+
+## Prerequisites
+
+- AWS account with appropriate permissions
+- AWS CLI installed and configured
+- Docker installed on your local machine (for container-based deployments)
+- Basic knowledge of AWS services and cloud deployment
+
+## Deployment Options
+
+There are several ways to deploy PraisonAI agents to AWS:
+
+1. **AWS Lambda with API Gateway** (for serverless deployments)
+2. **Amazon ECS/Fargate** (for containerized deployments)
+3. **Amazon EC2** (for traditional VM-based deployments)
+4. **AWS App Runner** (for simplified container deployments)
+
+## Option 1: Deploying to EC2 (Traditional VM)
+
+<Steps>
+    <Step title="Launch an EC2 Instance">
+        1. Go to the AWS Management Console
+        2. Navigate to EC2 and click "Launch Instance"
+        3. Choose Amazon Linux 2 or Ubuntu Server
+        4. Select an instance type (t2.micro for testing, t2.medium or larger for production)
+        5. Configure security groups to allow HTTP/HTTPS traffic
+        6. Launch the instance and connect to it via SSH
+    </Step>
+
+    <Step title="Set Up the Environment">
+        ```bash
+        # Update system packages
+        sudo apt update && sudo apt upgrade -y
+        
+        # Install Python and pip
+        sudo apt install -y python3 python3-pip
+        
+        # Install required packages
+        pip3 install "praisonaiagents[api]>=0.0.79"
+        ```
+    </Step>
+
+    <Step title="Create the API Application">
+        Create a file named `api.py`:
+        
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=8080, host="0.0.0.0")
+        ```
+    </Step>
+
+    <Step title="Set Up a Systemd Service">
+        Create a systemd service file to run your application as a background service:
+        
+        ```bash
+        sudo nano /etc/systemd/system/praisonai-agent.service
+        ```
+        
+        Add the following content:
+        
+        ```ini
+        [Unit]
+        Description=PraisonAI Agent API Service
+        After=network.target
+
+        [Service]
+        User=ubuntu
+        WorkingDirectory=/home/ubuntu
+        Environment="OPENAI_API_KEY=your_api_key"
+        ExecStart=/usr/bin/python3 /home/ubuntu/api.py
+        Restart=always
+
+        [Install]
+        WantedBy=multi-user.target
+        ```
+        
+        Enable and start the service:
+        
+        ```bash
+        sudo systemctl daemon-reload
+        sudo systemctl enable praisonai-agent
+        sudo systemctl start praisonai-agent
+        ```
+    </Step>
+
+    <Step title="Set Up Nginx as a Reverse Proxy">
+        ```bash
+        # Install Nginx
+        sudo apt install -y nginx
+        
+        # Create a configuration file
+        sudo nano /etc/nginx/sites-available/praisonai-agent
+        ```
+        
+        Add the following configuration:
+        
+        ```nginx
+        server {
+            listen 80;
+            server_name your_domain.com;
+
+            location / {
+                proxy_pass http://localhost:8080;
+                proxy_set_header Host $host;
+                proxy_set_header X-Real-IP $remote_addr;
+                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+                proxy_set_header X-Forwarded-Proto $scheme;
+            }
+        }
+        ```
+        
+        Enable the site and restart Nginx:
+        
+        ```bash
+        sudo ln -s /etc/nginx/sites-available/praisonai-agent /etc/nginx/sites-enabled/
+        sudo nginx -t
+        sudo systemctl restart nginx
+        ```
+    </Step>
+</Steps>
+
+## Option 2: Deploying with Docker and ECS/Fargate
+
+<Steps>
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        # Install dependencies
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        # Copy application code
+        COPY . .
+
+        # Run the application
+        CMD ["python", "api.py"]
+        ```
+        
+        Create a `requirements.txt` file:
+        ```
+        praisonaiagents[api]>=0.0.79
+        ```
+        
+        Create your `api.py` file:
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=8080, host="0.0.0.0")
+        ```
+    </Step>
+
+    <Step title="Build and Push the Docker Image to ECR">
+        ```bash
+        # Create an ECR repository
+        aws ecr create-repository --repository-name praisonai-agent
+        
+        # Get the login command
+        aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com
+        
+        # Build the Docker image
+        docker build -t praisonai-agent .
+        
+        # Tag the image
+        docker tag praisonai-agent:latest YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/praisonai-agent:latest
+        
+        # Push the image to ECR
+        docker push YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/praisonai-agent:latest
+        ```
+    </Step>
+
+    <Step title="Create an ECS Cluster and Task Definition">
+        ```bash
+        # Create an ECS cluster
+        aws ecs create-cluster --cluster-name praisonai-cluster
+        
+        # Create a task definition (JSON file)
+        cat > task-definition.json << EOF
+        {
+          "family": "praisonai-agent",
+          "networkMode": "awsvpc",
+          "executionRoleArn": "arn:aws:iam::YOUR_AWS_ACCOUNT_ID:role/ecsTaskExecutionRole",
+          "containerDefinitions": [
+            {
+              "name": "praisonai-agent",
+              "image": "YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/praisonai-agent:latest",
+              "essential": true,
+              "portMappings": [
+                {
+                  "containerPort": 8080,
+                  "hostPort": 8080,
+                  "protocol": "tcp"
+                }
+              ],
+              "environment": [
+                {
+                  "name": "OPENAI_API_KEY",
+                  "value": "your_api_key"
+                }
+              ],
+              "logConfiguration": {
+                "logDriver": "awslogs",
+                "options": {
+                  "awslogs-group": "/ecs/praisonai-agent",
+                  "awslogs-region": "us-east-1",
+                  "awslogs-stream-prefix": "ecs"
+                }
+              }
+            }
+          ],
+          "requiresCompatibilities": [
+            "FARGATE"
+          ],
+          "cpu": "256",
+          "memory": "512"
+        }
+        EOF
+        
+        # Register the task definition
+        aws ecs register-task-definition --cli-input-json file://task-definition.json
+        ```
+    </Step>
+
+    <Step title="Create a Fargate Service">
+        ```bash
+        # Create a service
+        aws ecs create-service \
+          --cluster praisonai-cluster \
+          --service-name praisonai-service \
+          --task-definition praisonai-agent:1 \
+          --desired-count 1 \
+          --launch-type FARGATE \
+          --network-configuration "awsvpcConfiguration={subnets=[subnet-12345678],securityGroups=[sg-12345678],assignPublicIp=ENABLED}" \
+          --load-balancers "targetGroupArn=arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/praisonai-tg/1234567890abcdef,containerName=praisonai-agent,containerPort=8080"
+        ```
+        
+        Note: You'll need to create an Application Load Balancer and target group before running this command.
+    </Step>
+</Steps>
+
+## Multi-Agent Deployment
+
+For deploying multiple agents, you can use a single service with different endpoints:
+
+```python
+# multi-agent-api.py
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=8080, host="0.0.0.0")
+stock_agent.launch(path="/stock", port=8080, host="0.0.0.0")
+travel_agent.launch(path="/travel", port=8080, host="0.0.0.0")
+```
+
+## Option 3: Serverless Deployment with AWS Lambda
+
+For lightweight agents that don't require long-running processes, you can use AWS Lambda with API Gateway:
+
+```python
+# lambda_function.py
+from praisonaiagents import Agent
+import json
+
+# Initialize the agent outside the handler for better cold start performance
+agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+
+def lambda_handler(event, context):
+    try:
+        # Extract the message from the event
+        body = json.loads(event.get('body', '{}'))
+        message = body.get('message', '')
+        
+        # Process the message with the agent
+        response = agent.process(message)
+        
+        # Return the response
+        return {
+            'statusCode': 200,
+            'headers': {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*'
+            },
+            'body': json.dumps({
+                'response': response
+            })
+        }
+    except Exception as e:
+        return {
+            'statusCode': 500,
+            'headers': {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*'
+            },
+            'body': json.dumps({
+                'error': str(e)
+            })
+        }
+```
+
+## Scaling and Performance
+
+### Auto Scaling
+
+For EC2 deployments, set up an Auto Scaling group:
+
+```bash
+# Create a launch template
+aws ec2 create-launch-template \
+  --launch-template-name praisonai-template \
+  --version-description "Initial version" \
+  --launch-template-data '{"ImageId":"ami-12345678","InstanceType":"t2.medium","UserData":"#!/bin/bash\ncd /home/ubuntu\npython3 api.py &"}'  
+
+# Create an Auto Scaling group
+aws autoscaling create-auto-scaling-group \
+  --auto-scaling-group-name praisonai-asg \
+  --launch-template "LaunchTemplateName=praisonai-template,Version=1" \
+  --min-size 1 \
+  --max-size 5 \
+  --desired-capacity 2 \
+  --vpc-zone-identifier "subnet-12345678,subnet-87654321" \
+  --target-group-arns "arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/praisonai-tg/1234567890abcdef"
+```
+
+### Load Balancing
+
+Set up an Application Load Balancer to distribute traffic:
+
+```bash
+# Create a load balancer
+aws elbv2 create-load-balancer \
+  --name praisonai-alb \
+  --subnets subnet-12345678 subnet-87654321 \
+  --security-groups sg-12345678
+
+# Create a target group
+aws elbv2 create-target-group \
+  --name praisonai-tg \
+  --protocol HTTP \
+  --port 8080 \
+  --vpc-id vpc-12345678 \
+  --target-type instance
+
+# Create a listener
+aws elbv2 create-listener \
+  --load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:loadbalancer/app/praisonai-alb/1234567890abcdef \
+  --protocol HTTP \
+  --port 80 \
+  --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/praisonai-tg/1234567890abcdef
+```
+
+## Security Best Practices
+
+1. **Secret Management**: Use AWS Secrets Manager for API keys
+   ```bash
+   # Store a secret
+   aws secretsmanager create-secret \
+     --name OPENAI_API_KEY \
+     --secret-string "your_api_key"
+   ```
+
+2. **IAM Roles**: Use the principle of least privilege
+3. **VPC**: Deploy in a private subnet with controlled access
+4. **WAF**: Set up AWS WAF to protect against common web exploits
+5. **API Gateway**: Implement request validation and throttling
+
+## Monitoring and Logging
+
+1. **CloudWatch**: Set up dashboards and alarms
+   ```bash
+   # Create a CloudWatch alarm for high CPU utilization
+   aws cloudwatch put-metric-alarm \
+     --alarm-name praisonai-high-cpu \
+     --alarm-description "Alarm when CPU exceeds 80%" \
+     --metric-name CPUUtilization \
+     --namespace AWS/EC2 \
+     --statistic Average \
+     --period 300 \
+     --threshold 80 \
+     --comparison-operator GreaterThanThreshold \
+     --dimensions Name=AutoScalingGroupName,Value=praisonai-asg \
+     --evaluation-periods 2 \
+     --alarm-actions arn:aws:sns:us-east-1:YOUR_AWS_ACCOUNT_ID:praisonai-alerts
+   ```
+
+2. **X-Ray**: Enable tracing for detailed request analysis
+3. **CloudTrail**: Monitor API calls for security analysis
+4. **Log Insights**: Query and analyze logs with CloudWatch Log Insights
@@ -0,0 +1,223 @@
+---
+title: "Deploying PraisonAI Agents as APIs"
+sidebarTitle: "API Deployment"
+description: "Learn how to deploy PraisonAI agents as RESTful APIs for production environments"
+icon: "server"
+---
+
+PraisonAI agents can be easily deployed as RESTful APIs, allowing you to integrate them into various applications and services. This guide covers how to deploy both single and multiple agents as APIs.
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Dependencies">
+        Make sure you have the required packages installed:
+        ```bash
+        pip install "praisonaiagents[api]"
+        ```
+    </Step>
+    <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY="your_api_key"
+        ```
+    </Step>
+    <Step title="Deploy a Simple Agent API">
+        Create a file named `simple-api.py` with the following code:
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=3030)
+        ```
+    </Step>
+    <Step title="Run the API Server">
+        ```bash
+        python simple-api.py
+        ```
+        
+        Your API will be available at `http://localhost:3030/ask`
+    </Step>
+</Steps>
+
+## Making API Requests
+
+Once your agent is deployed, you can make POST requests to interact with it:
+
+```bash
+curl -X POST http://localhost:3030/ask \
+  -H "Content-Type: application/json" \
+  -d '{"message": "What is artificial intelligence?"}'
+```
+
+The response will be in JSON format:
+
+```json
+{
+  "response": "Artificial intelligence (AI) refers to the simulation of human intelligence in machines that are programmed to think and learn like humans. It encompasses various technologies including machine learning, natural language processing, computer vision, and robotics. AI systems can perform tasks that typically require human intelligence such as understanding natural language, recognizing patterns, solving problems, and making decisions."
+}
+```
+
+## Multi-Agent API Deployment
+
+You can deploy multiple agents on the same server, each with its own endpoint:
+
+```python
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=3030)
+stock_agent.launch(path="/stock", port=3030)
+travel_agent.launch(path="/travel", port=3030) 
+```
+
+With this setup, you can access:
+- Weather agent at `http://localhost:3030/weather`
+- Stock agent at `http://localhost:3030/stock`
+- Travel agent at `http://localhost:3030/travel`
+
+## Production Deployment Options
+
+For production environments, consider the following deployment options:
+
+### Docker Deployment
+
+<Steps>
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        COPY . .
+
+        EXPOSE 3030
+
+        CMD ["python", "api.py"]
+        ```
+    </Step>
+    <Step title="Create requirements.txt">
+        ```
+        praisonaiagents[api]>=0.0.79
+        ```
+    </Step>
+    <Step title="Build and Run Docker Container">
+        ```bash
+        docker build -t praisonai-api .
+        docker run -p 3030:3030 -e OPENAI_API_KEY=your_api_key praisonai-api
+        ```
+    </Step>
+</Steps>
+
+### Cloud Deployment
+
+#### Deploying to AWS
+
+<Steps>
+    <Step title="Create an EC2 Instance">
+        Launch an EC2 instance with Ubuntu or Amazon Linux.
+    </Step>
+    <Step title="Install Dependencies">
+        ```bash
+        sudo apt update
+        sudo apt install -y python3-pip
+        pip install "praisonaiagents[api]"
+        ```
+    </Step>
+    <Step title="Configure Security Group">
+        Make sure to open port 3030 in your security group settings.
+    </Step>
+    <Step title="Run with Systemd">
+        Create a systemd service file for automatic startup and management.
+    </Step>
+</Steps>
+
+#### Deploying to Google Cloud Run
+
+<Steps>
+    <Step title="Build Docker Image">
+        ```bash
+        docker build -t gcr.io/your-project/praisonai-api .
+        ```
+    </Step>
+    <Step title="Push to Container Registry">
+        ```bash
+        docker push gcr.io/your-project/praisonai-api
+        ```
+    </Step>
+    <Step title="Deploy to Cloud Run">
+        ```bash
+        gcloud run deploy praisonai-api \
+          --image gcr.io/your-project/praisonai-api \
+          --platform managed \
+          --allow-unauthenticated \
+          --set-env-vars="OPENAI_API_KEY=your_api_key"
+        ```
+    </Step>
+</Steps>
+
+## API Configuration Options
+
+When launching your agent as an API, you can customize various parameters:
+
+```python
+agent.launch(
+    path="/custom-endpoint",  # API endpoint path
+    port=8080,                # Port number
+    host="0.0.0.0",           # Host address (0.0.0.0 for external access)
+    debug=True,               # Enable debug mode
+    cors_origins=["*"],       # CORS configuration
+    api_key="your-api-key"    # Optional API key for authentication
+)
+```
+
+## Securing Your API
+
+For production deployments, consider implementing:
+
+1. **API Key Authentication**: Require API keys for all requests
+2. **Rate Limiting**: Limit the number of requests per client
+3. **HTTPS**: Use SSL/TLS certificates for encrypted communication
+4. **Input Validation**: Validate all input data before processing
+
+## Monitoring and Scaling
+
+For production environments, consider:
+
+1. **Load Balancing**: Distribute traffic across multiple instances
+2. **Auto-Scaling**: Automatically adjust resources based on demand
+3. **Logging**: Implement comprehensive logging for debugging
+4. **Monitoring**: Set up alerts for errors and performance issues
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="RESTful API" icon="server">
+    Deploy your agents as standard RESTful APIs for easy integration.
+  </Card>
+  <Card title="Multi-Agent Support" icon="users">
+    Deploy multiple agents with different endpoints on the same server.
+  </Card>
+  <Card title="Customizable" icon="gear">
+    Configure ports, paths, CORS settings, and more.
+  </Card>
+  <Card title="Production-Ready" icon="rocket">
+    Easily deploy to Docker, AWS, Google Cloud, or other cloud platforms.
+  </Card>
+</CardGroup>
@@ -0,0 +1,248 @@
+---
+title: "Deploying to Google Cloud"
+sidebarTitle: "Google Cloud"
+description: "Deploy PraisonAI agents to Google Cloud Platform for scalable production environments"
+icon: "google"
+---
+
+# Deploying PraisonAI Agents to Google Cloud
+
+This guide provides step-by-step instructions for deploying PraisonAI agents to Google Cloud Platform using Cloud Run, which offers a serverless environment for containerized applications.
+
+## Prerequisites
+
+- Google Cloud account with billing enabled
+- Google Cloud SDK installed and configured
+- Docker installed on your local machine
+- Basic knowledge of containerization and cloud deployment
+
+## Deployment Options
+
+There are several ways to deploy PraisonAI agents to Google Cloud:
+
+1. **Google Cloud Run** (recommended for most use cases)
+2. **Google Compute Engine** (for custom VM requirements)
+3. **Google Kubernetes Engine** (for complex, scalable deployments)
+
+This guide focuses on Cloud Run as it's the simplest and most cost-effective option for most deployments.
+
+## Deploying to Google Cloud Run
+
+<Steps>
+    <Step title="Prepare Your Application">
+        Create a simple API file named `api.py`:
+
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="""You are a helpful assistant.""", llm="gpt-4o-mini")
+        agent.launch(path="/ask", port=8080, host="0.0.0.0")
+        ```
+
+        Note: Cloud Run expects your application to listen on the port defined by the `PORT` environment variable, which defaults to 8080.
+    </Step>
+
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        # Install dependencies
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        # Copy application code
+        COPY . .
+
+        # Set environment variables
+        ENV PORT=8080
+
+        # Run the application
+        CMD exec python api.py
+        ```
+
+        Create a `requirements.txt` file:
+        ```
+        praisonaiagents[api]>=0.0.79
+        ```
+    </Step>
+
+    <Step title="Build and Push the Docker Image">
+        ```bash
+        # Build the Docker image
+        docker build -t gcr.io/YOUR_PROJECT_ID/praisonai-agent .
+
+        # Configure Docker to use Google Cloud credentials
+        gcloud auth configure-docker
+
+        # Push the image to Google Container Registry
+        docker push gcr.io/YOUR_PROJECT_ID/praisonai-agent
+        ```
+    </Step>
+
+    <Step title="Deploy to Cloud Run">
+        ```bash
+        gcloud run deploy praisonai-agent \
+          --image gcr.io/YOUR_PROJECT_ID/praisonai-agent \
+          --platform managed \
+          --region us-central1 \
+          --allow-unauthenticated \
+          --set-env-vars="OPENAI_API_KEY=your_api_key"
+        ```
+
+        Note: For production deployments, it's recommended to use Secret Manager for API keys instead of environment variables.
+    </Step>
+</Steps>
+
+## Multi-Agent Deployment
+
+For deploying multiple agents, you can use a single Cloud Run service with different endpoints:
+
+```python
+# multi-agent-api.py
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=8080, host="0.0.0.0")
+stock_agent.launch(path="/stock", port=8080, host="0.0.0.0")
+travel_agent.launch(path="/travel", port=8080, host="0.0.0.0")
+```
+
+## Scaling and Performance
+
+Google Cloud Run automatically scales based on traffic, from zero to many instances. You can configure:
+
+- **Minimum instances**: Keep a certain number of instances warm to avoid cold starts
+- **Maximum instances**: Limit the number of instances to control costs
+- **Memory allocation**: Allocate more memory for complex agents
+- **CPU allocation**: Allocate dedicated CPUs for compute-intensive workloads
+
+```bash
+gcloud run services update praisonai-agent \
+  --min-instances=1 \
+  --max-instances=10 \
+  --memory=2Gi \
+  --cpu=1
+```
+
+## Continuous Deployment
+
+Set up continuous deployment with Cloud Build:
+
+```yaml
+# cloudbuild.yaml
+steps:
+  # Build the container image
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['build', '-t', 'gcr.io/$PROJECT_ID/praisonai-agent', '.']
+  # Push the container image to Container Registry
+  - name: 'gcr.io/cloud-builders/docker'
+    args: ['push', 'gcr.io/$PROJECT_ID/praisonai-agent']
+  # Deploy container image to Cloud Run
+  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
+    entrypoint: gcloud
+    args:
+    - 'run'
+    - 'deploy'
+    - 'praisonai-agent'
+    - '--image'
+    - 'gcr.io/$PROJECT_ID/praisonai-agent'
+    - '--region'
+    - 'us-central1'
+    - '--platform'
+    - 'managed'
+    - '--allow-unauthenticated'
+substitutions:
+  _REGION: us-central1
+images:
+  - 'gcr.io/$PROJECT_ID/praisonai-agent'
+```
+
+## Monitoring and Logging
+
+Google Cloud provides comprehensive monitoring and logging capabilities:
+
+- **Cloud Monitoring**: Set up dashboards and alerts for your deployed agents
+- **Cloud Logging**: View and analyze logs from your applications
+- **Error Reporting**: Automatically detect and group errors
+
+Access logs through the Google Cloud Console or using the gcloud command:
+
+```bash
+gcloud logging read "resource.type=cloud_run_revision AND resource.labels.service_name=praisonai-agent" --limit=10
+```
+
+## Cost Optimization
+
+Cloud Run charges based on the resources your service uses only when it's processing requests. To optimize costs:
+
+1. Set appropriate memory and CPU allocations
+2. Configure minimum instances based on traffic patterns
+3. Use regional deployments closest to your users
+4. Implement caching for frequent requests
+
+## Security Best Practices
+
+1. **Secret Management**: Store API keys and credentials in Secret Manager
+   ```bash
+   # Create a secret
+   echo -n "your_api_key" | gcloud secrets create openai-api-key --data-file=-
+   
+   # Grant access to the Cloud Run service
+   gcloud secrets add-iam-policy-binding openai-api-key \
+     --member=serviceAccount:YOUR_SERVICE_ACCOUNT \
+     --role=roles/secretmanager.secretAccessor
+   
+   # Reference in deployment
+   gcloud run deploy praisonai-agent \
+     --image gcr.io/YOUR_PROJECT_ID/praisonai-agent \
+     --set-secrets=OPENAI_API_KEY=openai-api-key:latest
+   ```
+
+2. **Service Identity**: Use dedicated service accounts with minimal permissions
+3. **Network Security**: Configure VPC Service Controls for sensitive deployments
+4. **API Authentication**: Implement authentication for your API endpoints
+
+## All in One 
+
+```bash
+gcloud init
+gcloud services enable run.googleapis.com
+gcloud services enable containerregistry.googleapis.com
+gcloud services enable cloudbuild.googleapis.com
+
+export OPENAI_MODEL_NAME="gpt-4o"
+export OPENAI_API_KEY="Enter your API key"
+export OPENAI_API_BASE="https://api.openai.com/v1"
+
+yes | gcloud auth configure-docker us-central1-docker.pkg.dev 
+gcloud artifacts repositories create praisonai-repository --repository-format=docker --location=us-central1
+
+PROJECT_ID=$(gcloud config get-value project)
+TAG="latest"
+docker build --platform linux/amd64 -t gcr.io/${PROJECT_ID}/praisonai-app:${TAG} .
+docker tag gcr.io/${PROJECT_ID}/praisonai-app:${TAG} us-central1-docker.pkg.dev/${PROJECT_ID}/praisonai-repository/praisonai-app:${TAG}
+docker push us-central1-docker.pkg.dev/${PROJECT_ID}/praisonai-repository/praisonai-app:${TAG}
+
+gcloud run deploy praisonai-service \
+    --image us-central1-docker.pkg.dev/${PROJECT_ID}/praisonai-repository/praisonai-app:${TAG} \
+    --platform managed \
+    --region us-central1 \
+    --allow-unauthenticated \
+    --set-env-vars OPENAI_MODEL_NAME=${OPENAI_MODEL_NAME},OPENAI_API_KEY=${OPENAI_API_KEY},OPENAI_API_BASE=${OPENAI_API_BASE}
+```
@@ -0,0 +1,405 @@
+---
+title: "Deploying MCP Servers"
+sidebarTitle: "MCP Servers"
+description: "Learn how to deploy Model Context Protocol (MCP) servers for production environments"
+icon: "server-rack"
+---
+
+# Deploying MCP Servers
+
+This guide focuses on deploying Model Context Protocol (MCP) servers for production environments. MCP servers allow AI models to access tools and external systems through a standardized protocol.
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Dependencies">
+        Make sure you have the required packages installed:
+        ```bash
+        pip install "praisonaiagents[mcp]"
+        ```
+        
+        For the multi-agent example with search capabilities:
+        ```bash
+        pip install "praisonaiagents[mcp]" duckduckgo-search
+        ```
+    </Step>
+    <Step title="Create MCP Server Files">
+        **Single Agent MCP Server**
+        
+        Create a file named `simple-mcp-server.py`:
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="Create a Tweet based on the topic provided")
+        agent.launch(port=8080, host="0.0.0.0", protocol="mcp")
+        ```
+        
+        **Multi-Agent MCP Server with Custom Tools**
+
+        Create a file named `simple-mcp-multi-agents-server.py`:
+        ```python
+        from praisonaiagents import Agent, Agents
+        from duckduckgo_search import DDGS
+
+        def internet_search_tool(query: str):
+            results = []
+            ddgs = DDGS()
+            for result in ddgs.text(keywords=query, max_results=5):
+                results.append({
+                    "title": result.get("title", ""),
+                    "url": result.get("href", ""),
+                    "snippet": result.get("body", "")
+                })
+            return results
+
+        agent = Agent(instructions="You Search the internet for information", tools=[internet_search_tool])
+        agent2 = Agent(instructions="You Summarise the information")
+
+        agents = Agents(agents=[agent, agent2])
+        agents.launch(port=8080, host="0.0.0.0", protocol="mcp")
+        ```
+        
+        **Simple Multi-Agent MCP Server**
+        
+        Create a file named `simple-multi-agents-server.py`:
+        ```python
+        from praisonaiagents import Agent, Agents
+
+        agent = Agent(instructions="You Search the internet for information")
+        agent2 = Agent(instructions="You Summarise the information")
+
+        agents = Agents(agents=[agent, agent2])
+        agents.launch(port=8080, host="0.0.0.0", protocol="mcp")
+        ```
+        ```python
+        from praisonaiagents import Agent, Agents
+        from duckduckgo_search import DDGS
+
+        def internet_search_tool(query: str):
+            results = []
+            ddgs = DDGS()
+            for result in ddgs.text(keywords=query, max_results=5):
+                results.append({
+                    "title": result.get("title", ""),
+                    "url": result.get("href", ""),
+                    "snippet": result.get("body", "")
+                })
+            return results
+
+        agent = Agent(instructions="You Search the internet for information", tools=[internet_search_tool])
+        agent2 = Agent(instructions="You Summarise the information")
+
+        agents = Agents(agents=[agent, agent2])
+        agents.launch(port=8080, host="0.0.0.0", protocol="mcp")
+        ```
+    </Step>
+</Steps>
+
+## Containerization with Docker
+
+<Steps>
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        # Install dependencies
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        # Copy application code
+        COPY . .
+
+        # Expose the port
+        EXPOSE 8080
+
+        # Run the MCP server
+        CMD ["python", "simple-mcp-server.py"]
+        ```
+        
+        Create a `requirements.txt` file:
+        ```
+        praisonaiagents[mcp]
+        duckduckgo-search  # Only needed for the multi-agent example
+        ```
+    </Step>
+    <Step title="Build and Run the Docker Container">
+        ```bash
+        # Build the Docker image
+        docker build -t mcp-server .
+
+        # Run the container
+        docker run -p 8080:8080 -e OPENAI_API_KEY=your_api_key mcp-server
+        ```
+    </Step>
+</Steps>
+
+## Cloud Deployment
+
+### AWS Elastic Container Service (ECS)
+
+<Steps>
+    <Step title="Push Docker Image to ECR">
+        ```bash
+        # Create an ECR repository
+        aws ecr create-repository --repository-name mcp-server
+        
+        # Authenticate Docker to ECR
+        aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com
+        
+        # Tag and push the image
+        docker tag mcp-server:latest YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/mcp-server:latest
+        docker push YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/mcp-server:latest
+        ```
+    </Step>
+    <Step title="Create ECS Task Definition">
+        ```json
+        {
+          "family": "mcp-server",
+          "networkMode": "awsvpc",
+          "executionRoleArn": "arn:aws:iam::YOUR_AWS_ACCOUNT_ID:role/ecsTaskExecutionRole",
+          "containerDefinitions": [
+            {
+              "name": "mcp-server",
+              "image": "YOUR_AWS_ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/mcp-server:latest",
+              "essential": true,
+              "portMappings": [
+                {
+                  "containerPort": 8080,
+                  "hostPort": 8080,
+                  "protocol": "tcp"
+                }
+              ],
+              "environment": [
+                {
+                  "name": "OPENAI_API_KEY",
+                  "value": "your_api_key"
+                }
+              ],
+              "logConfiguration": {
+                "logDriver": "awslogs",
+                "options": {
+                  "awslogs-group": "/ecs/mcp-server",
+                  "awslogs-region": "us-east-1",
+                  "awslogs-stream-prefix": "ecs"
+                }
+              }
+            }
+          ],
+          "requiresCompatibilities": [
+            "FARGATE"
+          ],
+          "cpu": "256",
+          "memory": "512"
+        }
+        ```
+    </Step>
+    <Step title="Deploy to ECS">
+        ```bash
+        # Create a service
+        aws ecs create-service \
+          --cluster your-cluster \
+          --service-name mcp-server \
+          --task-definition mcp-server:1 \
+          --desired-count 1 \
+          --launch-type FARGATE \
+          --network-configuration "awsvpcConfiguration={subnets=[subnet-12345678],securityGroups=[sg-12345678],assignPublicIp=ENABLED}" \
+          --load-balancers "targetGroupArn=arn:aws:elasticloadbalancing:us-east-1:YOUR_AWS_ACCOUNT_ID:targetgroup/mcp-server-tg/1234567890abcdef,containerName=mcp-server,containerPort=8080"
+        ```
+    </Step>
+</Steps>
+
+### Google Cloud Run
+
+<Steps>
+    <Step title="Push Docker Image to Google Container Registry">
+        ```bash
+        # Configure Docker to use Google Cloud credentials
+        gcloud auth configure-docker
+        
+        # Build and tag the image
+        docker build -t gcr.io/YOUR_PROJECT_ID/mcp-server .
+        
+        # Push the image
+        docker push gcr.io/YOUR_PROJECT_ID/mcp-server
+        ```
+    </Step>
+    <Step title="Deploy to Cloud Run">
+        ```bash
+        gcloud run deploy mcp-server \
+          --image gcr.io/YOUR_PROJECT_ID/mcp-server \
+          --platform managed \
+          --region us-central1 \
+          --allow-unauthenticated \
+          --set-env-vars="OPENAI_API_KEY=your_api_key"
+        ```
+    </Step>
+</Steps>
+
+## Production Configuration
+
+### Security
+
+For production deployments, implement these security measures:
+
+1. **API Key Authentication**:
+   ```python
+   agent.launch(port=8080, host="0.0.0.0", protocol="mcp", api_key="your-secret-key")
+   ```
+
+2. **HTTPS with SSL/TLS**:
+   Set up a reverse proxy like Nginx with SSL certificates:
+   ```nginx
+   server {
+       listen 443 ssl;
+       server_name your-mcp-server.com;
+       
+       ssl_certificate /path/to/cert.pem;
+       ssl_certificate_key /path/to/key.pem;
+       
+       location / {
+           proxy_pass http://localhost:8080;
+           proxy_set_header Host $host;
+           proxy_set_header X-Real-IP $remote_addr;
+       }
+   }
+   ```
+
+3. **Secret Management**:
+   Use environment variables or a secrets manager for API keys:
+   ```bash
+   # AWS Secrets Manager
+   aws secretsmanager create-secret \
+     --name OPENAI_API_KEY \
+     --secret-string "your_api_key"
+   
+   # Google Secret Manager
+   echo -n "your_api_key" | gcloud secrets create openai-api-key --data-file=-
+   ```
+
+### Scaling
+
+For high-traffic MCP servers, consider these scaling strategies:
+
+1. **Load Balancing**:
+   Deploy multiple instances behind a load balancer.
+
+2. **Auto Scaling**:
+   Configure auto-scaling based on CPU/memory usage or request count.
+
+3. **Resource Allocation**:
+   Allocate sufficient CPU and memory for your MCP servers:
+   ```bash
+   # AWS ECS
+   aws ecs update-service \
+     --cluster your-cluster \
+     --service mcp-server \
+     --desired-count 3
+   
+   # Google Cloud Run
+   gcloud run services update mcp-server \
+     --min-instances=2 \
+     --max-instances=10 \
+     --memory=2Gi \
+     --cpu=1
+   ```
+
+## Monitoring and Logging
+
+Set up comprehensive monitoring for your MCP servers:
+
+1. **Application Logging**:
+   ```python
+   import logging
+   
+   logging.basicConfig(
+       level=logging.INFO,
+       format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+       handlers=[
+           logging.FileHandler("mcp-server.log"),
+           logging.StreamHandler()
+       ]
+   )
+   
+   logger = logging.getLogger("mcp-server")
+   ```
+
+2. **Health Checks**:
+   Create a health check endpoint:
+   ```python
+   from flask import Flask
+   
+   app = Flask(__name__)
+   
+   @app.route('/health')
+   def health_check():
+       return {"status": "healthy"}, 200
+   
+   if __name__ == "__main__":
+       app.run(host="0.0.0.0", port=8081)
+   ```
+
+3. **Metrics Collection**:
+   Use Prometheus or similar tools to collect metrics.
+
+## Testing MCP Servers
+
+Before deploying to production, thoroughly test your MCP server:
+
+```python
+import requests
+import json
+
+def test_mcp_server():
+    url = "http://localhost:8080/v1/chat/completions"
+    
+    headers = {
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "messages": [
+            {"role": "user", "content": "Create a tweet about artificial intelligence"}
+        ]
+    }
+    
+    response = requests.post(url, headers=headers, data=json.dumps(data))
+    
+    print(f"Status Code: {response.status_code}")
+    print(f"Response: {response.json()}")
+
+if __name__ == "__main__":
+    test_mcp_server()
+```
+
+## Deployment Checklist
+
+Before going live with your MCP server, ensure you've addressed these items:
+
+- [ ] Implemented proper authentication
+- [ ] Set up HTTPS with valid SSL certificates
+- [ ] Configured proper logging and monitoring
+- [ ] Tested the server under load
+- [ ] Implemented rate limiting
+- [ ] Secured all API keys and credentials
+- [ ] Set up automated backups
+- [ ] Created a disaster recovery plan
+- [ ] Documented the deployment process
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Containerized Deployment" icon="docker">
+    Package your MCP servers in Docker containers for consistent deployment.
+  </Card>
+  <Card title="Cloud-Ready" icon="cloud">
+    Deploy to AWS, Google Cloud, or other cloud providers with ease.
+  </Card>
+  <Card title="Scalable Architecture" icon="server">
+    Scale your MCP servers to handle production workloads.
+  </Card>
+  <Card title="Security-Focused" icon="shield">
+    Implement best practices for secure MCP server deployments.
+  </Card>
+</CardGroup>
@@ -0,0 +1,210 @@
+---
+title: "Deploying Multi-Agent Systems as APIs"
+sidebarTitle: "Multi-Agent Deployment"
+description: "Learn how to deploy PraisonAI multi-agent systems as RESTful APIs for production environments"
+icon: "network-wired"
+---
+
+# Deploying Multi-Agent Systems as APIs
+
+PraisonAI allows you to deploy sophisticated multi-agent systems as RESTful APIs, enabling seamless integration with various applications and services. This guide covers different approaches to deploying multi-agent systems.
+
+## Quick Start
+
+<Steps>
+    <Step title="Install Dependencies">
+        Make sure you have the required packages installed:
+        ```bash
+        pip install "praisonaiagents[api]>=0.0.81"
+        ```
+    </Step>
+    <Step title="Set API Key">
+        ```bash
+        export OPENAI_API_KEY="your_api_key"
+        ```
+    </Step>
+    <Step title="Deploy a Multi-Agent System">
+        Create a file named `multi-agents-api.py` with the following code:
+        ```python
+        from praisonaiagents import Agent, Agents, Tools
+
+        research_agent = Agent(name="Research", instructions="You are a research agent to search internet about AI 2024", tools=[Tools.internet_search])
+        summarise_agent = Agent(name="Summarise", instructions="You are a summarize agent to summarise in points")
+        agents = Agents(agents=[research_agent, summarise_agent])
+        agents.launch(path="/agents", port=3030)
+        ```
+    </Step>
+    <Step title="Run the API Server">
+        ```bash
+        python multi-agents-api.py
+        ```
+        
+        Your multi-agent API will be available at `http://localhost:3030/agents`
+    </Step>
+</Steps>
+
+## Making API Requests
+
+Once your multi-agent system is deployed, you can make POST requests to interact with it:
+
+```bash
+curl -X POST http://localhost:3030/agents \
+  -H "Content-Type: application/json" \
+  -d '{"message": "What are the latest developments in AI in 2024?"}'
+```
+
+The response will include the collaborative output from both the research and summarization agents:
+
+```json
+{
+  "response": "# Latest AI Developments in 2024\n\n- Multimodal AI models have become mainstream, combining text, image, audio, and video understanding\n- Significant advancements in AI reasoning capabilities with models like GPT-4o and Claude 3\n- Increased focus on AI alignment and safety research\n- Emergence of specialized AI agents for specific domains\n- Growth in open-source AI models and frameworks\n- Regulatory frameworks for AI being established globally"
+}
+```
+
+## Multiple Agent Groups
+
+You can deploy multiple agent groups on the same server, each with its own endpoint:
+
+```python
+from praisonaiagents import Agent, Agents, Tools
+
+research_agent = Agent(name="Research", instructions="You are a research agent to search internet about AI 2024", tools=[Tools.internet_search])
+summarise_agent = Agent(name="Summarise", instructions="You are a summarize agent to summarise in points")
+agents = Agents(agents=[research_agent, summarise_agent])
+agents2 = Agents(agents=[research_agent])
+agents.launch(path="/agents", port=3030)
+agents2.launch(path="/agents2", port=3030)
+```
+
+With this setup, you can access:
+- The full agent group at `http://localhost:3030/agents`
+- Just the research agent at `http://localhost:3030/agents2`
+
+## Independent Multi-Agent Deployment
+
+You can also deploy multiple independent agents on the same server:
+
+```python
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=3030)
+stock_agent.launch(path="/stock", port=3030)
+travel_agent.launch(path="/travel", port=3030) 
+```
+
+## Production Deployment Options
+
+For production environments, consider the following deployment options:
+
+### Docker Deployment
+
+<Steps>
+    <Step title="Create a Dockerfile">
+        ```dockerfile
+        FROM python:3.11-slim
+
+        WORKDIR /app
+
+        COPY requirements.txt .
+        RUN pip install --no-cache-dir -r requirements.txt
+
+        COPY . .
+
+        EXPOSE 3030
+
+        CMD ["python", "multi-agents-api.py"]
+        ```
+    </Step>
+    <Step title="Create requirements.txt">
+        ```
+        praisonaiagents[api]>=0.0.81
+        ```
+    </Step>
+    <Step title="Build and Run Docker Container">
+        ```bash
+        docker build -t praisonai-multi-agent .
+        docker run -p 3030:3030 -e OPENAI_API_KEY=your_api_key praisonai-multi-agent
+        ```
+    </Step>
+</Steps>
+
+### Cloud Deployment
+
+For detailed cloud deployment instructions, refer to:
+- [AWS Deployment Guide](/deploy/aws)
+- [Google Cloud Deployment Guide](/deploy/googlecloud)
+
+## Scaling Multi-Agent Systems
+
+When deploying multi-agent systems to production, consider these scaling strategies:
+
+1. **Horizontal Scaling**: Deploy multiple instances behind a load balancer
+2. **Vertical Scaling**: Allocate more CPU and memory resources for complex agent interactions
+3. **Caching**: Implement response caching for frequently asked questions
+4. **Asynchronous Processing**: Use message queues for handling long-running agent tasks
+
+## API Configuration Options
+
+When launching your multi-agent system as an API, you can customize various parameters:
+
+```python
+agents.launch(
+    path="/custom-endpoint",  # API endpoint path
+    port=8080,                # Port number
+    host="0.0.0.0",           # Host address (0.0.0.0 for external access)
+    debug=True,               # Enable debug mode
+    cors_origins=["*"],       # CORS configuration
+    api_key="your-api-key"    # Optional API key for authentication
+)
+```
+
+## Securing Your Multi-Agent API
+
+For production deployments, consider implementing:
+
+1. **API Key Authentication**: Require API keys for all requests
+2. **Rate Limiting**: Limit the number of requests per client
+3. **HTTPS**: Use SSL/TLS certificates for encrypted communication
+4. **Input Validation**: Validate all input data before processing
+5. **Output Filtering**: Implement content filtering for agent responses
+
+## Monitoring and Logging
+
+For production environments, consider:
+
+1. **Centralized Logging**: Collect logs from all agents in a central location
+2. **Performance Metrics**: Track response times and resource usage
+3. **Error Tracking**: Monitor and alert on agent failures
+4. **Usage Analytics**: Track which agents are used most frequently
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Collaborative Agents" icon="users-gear">
+    Deploy agent systems that collaborate to solve complex problems.
+  </Card>
+  <Card title="Specialized Endpoints" icon="sitemap">
+    Create dedicated endpoints for different agent groups or individual agents.
+  </Card>
+  <Card title="Tool Integration" icon="screwdriver-wrench">
+    Deploy agents with specialized tools like web search capabilities.
+  </Card>
+  <Card title="Scalable Architecture" icon="server">
+    Scale your multi-agent systems to handle production workloads.
+  </Card>
+</CardGroup>
@@ -27,7 +27,7 @@ WORKDIR /app

 COPY . .

-RUN pip install flask praisonai==2.0.18 watchdog
+RUN pip install flask praisonai==2.2.18 watchdog

 EXPOSE 5555

@@ -0,0 +1,212 @@
+---
+title: "MCP Servers"
+sidebarTitle: "MCP Servers"
+description: "Learn how to create Model Context Protocol (MCP) servers with PraisonAI agents"
+icon: "server"
+---
+
+# Creating MCP Servers
+
+This guide demonstrates how to create Model Context Protocol (MCP) servers using PraisonAI agents. MCP is a protocol that enables AI models to use tools and communicate with external systems in a standardized way.
+
+## Single Agent MCP Server
+
+The simplest way to create an MCP server is with a single agent. This approach is ideal for specialized tasks where you need just one agent with a specific capability.
+
+<Steps>
+    <Step title="Install Dependencies">
+        Make sure you have the required packages installed:
+        ```bash
+        pip install "praisonaiagents[mcp]>=0.0.81"
+        ```
+    </Step>
+    <Step title="Create a Simple MCP Server">
+        Create a file named `simple-mcp-server.py` with the following code:
+        ```python
+        from praisonaiagents import Agent
+
+        agent = Agent(instructions="Create a Tweet based on the topic provided")
+        agent.launch(port=8080, protocol="mcp")
+        ```
+    </Step>
+    <Step title="Run the Server">
+        ```bash
+        python simple-mcp-server.py
+        ```
+        
+        Your MCP server will be available at `http://localhost:8080`
+    </Step>
+</Steps>
+
+## Multi-Agent MCP Server with Custom Tools
+
+For more complex scenarios, you can create an MCP server with multiple agents and custom tools. This approach allows for collaborative problem-solving and specialized capabilities.
+
+<Steps>
+    <Step title="Install Additional Dependencies">
+        ```bash
+        pip install "praisonaiagents[mcp]" duckduckgo-search
+        ```
+    </Step>
+    <Step title="Create a Multi-Agent MCP Server">
+        Create a file named `simple-mcp-multi-agents-server.py` with the following code:
+        ```python
+        from praisonaiagents import Agent, Agents
+        from duckduckgo_search import DDGS
+
+        def internet_search_tool(query: str):
+            results = []
+            ddgs = DDGS()
+            for result in ddgs.text(keywords=query, max_results=5):
+                results.append({
+                    "title": result.get("title", ""),
+                    "url": result.get("href", ""),
+                    "snippet": result.get("body", "")
+                })
+            return results
+
+        agent = Agent(instructions="You Search the internet for information", tools=[internet_search_tool])
+        agent2 = Agent(instructions="You Summarise the information")
+
+        agents = Agents(agents=[agent, agent2])
+        agents.launch(port=8080, protocol="mcp")
+        ```
+    </Step>
+    <Step title="Run the Multi-Agent Server">
+        ```bash
+        python simple-mcp-multi-agents-server.py
+        ```
+        
+        Your multi-agent MCP server will be available at `http://localhost:8080`
+    </Step>
+</Steps>
+
+## Multi-Agent MCP Server (Simple)
+
+For scenarios where you need multiple agents to collaborate without custom tools, you can create a simpler multi-agent MCP server:
+
+```python
+from praisonaiagents import Agent, Agents
+
+agent = Agent(instructions="You Search the internet for information")
+agent2 = Agent(instructions="You Summarise the information")
+
+agents = Agents(agents=[agent, agent2])
+agents.launch(port=8080, protocol="mcp")
+```
+
+This approach is ideal for cases where you want agents with different specializations to work together using their built-in capabilities.
+
+## Connecting to MCP Servers
+
+You can connect to MCP servers using various clients:
+
+### Using PraisonAI Agents
+
+```python
+from praisonaiagents import Agent, MCP
+
+client_agent = Agent(
+    instructions="Use the MCP server to complete tasks",
+    llm="gpt-4o-mini",
+    tools=MCP("http://localhost:8080")
+)
+
+response = client_agent.start("Create a tweet about artificial intelligence")
+print(response)
+```
+
+### Using JavaScript/TypeScript
+
+```typescript
+import { MCPClient } from '@modelcontextprotocol/client';
+
+async function main() {
+  const client = new MCPClient('http://localhost:8080');
+  
+  const response = await client.chat([
+    { role: 'user', content: 'Create a tweet about artificial intelligence' }
+  ]);
+  
+  console.log(response.choices[0].message.content);
+}
+
+main();
+```
+
+## Advanced Configuration
+
+### Custom Port and Host
+
+```python
+agent.launch(port=9000, host="0.0.0.0", protocol="mcp")
+```
+
+### Authentication
+
+```python
+agent.launch(port=8080, protocol="mcp", api_key="your-secret-key")
+```
+
+### CORS Configuration
+
+```python
+agent.launch(port=8080, protocol="mcp", cors_origins=["https://yourdomain.com"])
+```
+
+## Deployment Options
+
+For production deployments, consider:
+
+1. **Docker Containerization**:
+   ```dockerfile
+   FROM python:3.11-slim
+   
+   WORKDIR /app
+   
+   COPY requirements.txt .
+   RUN pip install --no-cache-dir -r requirements.txt
+   
+   COPY . .
+   
+   EXPOSE 8080
+   
+   CMD ["python", "simple-mcp-server.py"]
+   ```
+
+2. **Cloud Deployment**: Deploy to AWS, Google Cloud, or Azure using their container services.
+
+3. **Kubernetes**: For scalable deployments, use Kubernetes to manage your MCP server containers.
+
+## Security Considerations
+
+1. **API Authentication**: Always use API keys in production
+2. **Rate Limiting**: Implement rate limiting to prevent abuse
+3. **Input Validation**: Validate all incoming requests
+4. **HTTPS**: Use SSL/TLS for all production deployments
+5. **Tool Permissions**: Limit what custom tools can access
+
+## Features and Benefits
+
+<CardGroup cols={2}>
+  <Card title="Standardized Protocol" icon="diagram-project">
+    MCP provides a standardized way for AI models to interact with tools and services.
+  </Card>
+  <Card title="Custom Tools" icon="screwdriver-wrench">
+    Easily integrate custom tools like web search, database access, or API calls.
+  </Card>
+  <Card title="Multi-Agent Collaboration" icon="users-gear">
+    Create systems where multiple specialized agents collaborate on complex tasks.
+  </Card>
+  <Card title="Language Agnostic" icon="language">
+    Connect to MCP servers from any programming language that supports HTTP.
+  </Card>
+</CardGroup>
+
+## Best Practices
+
+1. **Agent Instructions**: Provide clear, specific instructions for each agent
+2. **Tool Documentation**: Document your custom tools thoroughly
+3. **Error Handling**: Implement robust error handling in your tools
+4. **Monitoring**: Set up logging and monitoring for your MCP servers
+5. **Testing**: Test your MCP servers thoroughly before deployment
@@ -55,14 +55,6 @@
    }
  ],
  "tabs": [
-    {
-        "name": "Documentation",
-        "url": "/index"
-    },
-    {
-        "name": "Examples",
-        "url": "/examples"
-    },
    {
        "name": "Agents",
        "url": "/agents"
@@ -79,6 +71,14 @@
        "name": "MCP",
        "url": "/mcp"
    },
+    {
+        "name": "Deploy",
+        "url": "/deploy"
+    },
+    {
+      "name": "Examples",
+      "url": "/examples"
+    },
    {
        "name": "JS",
        "url": "/js"
@@ -156,6 +156,7 @@
        "models/google",
        "models/openrouter",
        "models/anthropic",
+        "models/aws",
        "models/cohere",
        "models/mistral",
        "models/deepseek",
@@ -240,6 +241,7 @@
        "mcp/airbnb",
        "mcp/stdio",
        "mcp/sse",
+        "mcp/mcp-server",
        "mcp/ollama",
        "mcp/groq",
        "mcp/openrouter",
@@ -372,6 +374,16 @@
        "ui/code"
      ]
    },
+    {
+      "group": "Deploy",
+      "pages": [
+        "deploy/deploy",
+        "deploy/multi-agents-deploy",
+        "deploy/mcp-server-deploy",
+        "deploy/aws",
+        "deploy/googlecloud"
+      ]
+    },
    {
      "group": "Monitoring",
      "pages": ["monitoring/agentops"]
@@ -385,8 +397,7 @@
        "developers/wrapper-tools",
        "developers/googlecolab",
        "developers/googlecolab-tools",
-        "developers/local-development",
-        "deploy"
+        "developers/local-development"
      ]
    },
    {
@@ -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) |
@@ -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>
@@ -155,7 +155,7 @@ To facilitate local development with live reload, you can use Docker. Follow the

    COPY . .

-    RUN pip install flask praisonai==2.0.18 watchdog
+    RUN pip install flask praisonai==2.2.18 watchdog

    EXPOSE 5555

@@ -208,7 +208,7 @@ To facilitate local development with live reload, you can use Docker. Follow the

    COPY . .

-    RUN pip install flask praisonai==2.0.18 watchdog
+    RUN pip install flask praisonai==2.2.18 watchdog

    EXPOSE 5555

@@ -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',
-    },
-  },
-];
@@ -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
@@ -0,0 +1,9 @@
+from praisonaiagents import Agent, MCP
+
+qa_agent = Agent(
+    instructions="""You are a Question Answering Agent.""",
+    llm="openai/gpt-4o-mini",
+    tools=MCP("http://localhost:8080/agents/sse")
+)
+
+qa_agent.start("AI in 2025")
@@ -0,0 +1,20 @@
+from praisonaiagents import Agent
+
+weather_agent = Agent(
+    instructions="""You are a weather agent that can provide weather information for a given city.""",
+    llm="gpt-4o-mini"
+)
+
+stock_agent = Agent(
+    instructions="""You are a stock market agent that can provide information about stock prices and market trends.""",
+    llm="gpt-4o-mini"
+)
+
+travel_agent = Agent(
+    instructions="""You are a travel agent that can provide recommendations for destinations, hotels, and activities.""",
+    llm="gpt-4o-mini"
+)
+
+weather_agent.launch(path="/weather", port=3030)
+stock_agent.launch(path="/stock", port=3030)
+travel_agent.launch(path="/travel", port=3030) 
@@ -0,0 +1,6 @@
+from praisonaiagents import Agent, Agents, Tools
+
+research_agent = Agent(name="Research", instructions="You are a research agent to search internet about AI 2024", tools=[Tools.internet_search])
+summarise_agent = Agent(name="Summarise", instructions="You are a summarize agent to summarise in points")
+agents = Agents(agents=[research_agent, summarise_agent])
+agents.launch(path="/agents", port=3030)
@@ -0,0 +1,8 @@
+from praisonaiagents import Agent, Agents, Tools
+
+research_agent = Agent(name="Research", instructions="You are a research agent to search internet about AI 2024", tools=[Tools.internet_search])
+summarise_agent = Agent(name="Summarise", instructions="You are a summarize agent to summarise in points")
+agents = Agents(agents=[research_agent, summarise_agent])
+agents2 = Agents(agents=[research_agent])
+agents.launch(path="/agents", port=3030)
+agents2.launch(path="/agents2", port=3030)
@@ -0,0 +1,19 @@
+from praisonaiagents import Agent, Agents
+from duckduckgo_search import DDGS
+
+def internet_search_tool(query: str):
+    results = []
+    ddgs = DDGS()
+    for result in ddgs.text(keywords=query, max_results=5):
+        results.append({
+            "title": result.get("title", ""),
+            "url": result.get("href", ""),
+            "snippet": result.get("body", "")
+        })
+    return results
+
+agent = Agent(name="SearchAgent", instructions="You Search the internet for information", tools=[internet_search_tool])
+agent2 = Agent(name="SummariseAgent", instructions="You Summarise the information")
+
+agents = Agents(name="MultiAgents", agents=[agent, agent2])
+agents.launch(port=8080, protocol="mcp")
@@ -0,0 +1,4 @@
+from praisonaiagents import Agent
+
+agent = Agent(name="TweetAgent", instructions="Create a Tweet based on the topic provided")
+agent.launch(port=8080, protocol="mcp")